This commit was manufactured by cvs2svn to create tag

'Version_1_33_1_beta'.

[SVN r31604]

example/Jamfile.v2

@@ -1,22 +0,0 @@
-#  Boost algorithm library example programs Jamfile
-#
-#  Copyright Marshall Clow 2010-2012. 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.
-
-
-project /boost/algorithm/example
-    : requirements
-      <include>../../../
-      <optimization>speed
-      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
-      <toolset>msvc:<define>NOMINMAX
-      <link>static
-    :
-    ;
-
-exe clamp_example   : clamp_example.cpp ;
-exe search_example  : search_example.cpp ;

example/clamp_example.cpp

@@ -1,54 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#include <string>
-#include <iostream>     // for cout, etc
-
-#include <boost/algorithm/clamp.hpp>
-
-namespace ba = boost::algorithm;
-
-bool compare_string_lengths ( const std::string &one, const std::string &two )
-{
-    return one.length () < two.length ();
-}
-
-int main ( int /*argc*/, char * /*argv*/ [] ) {
-//  Clamp takes a value and two "fenceposts", and brings the value "between" the fenceposts.
-
-//  If the input value is "between" the fenceposts, then it is returned unchanged.
-    std::cout << "Clamping   5 to between [1, 10] -> " << ba::clamp ( 5, 1, 10 ) << std::endl;
-
-//  If the input value is out side the range of the fenceposts, it "brought into" range.
-    std::cout << "Clamping  15 to between [1, 10] -> " << ba::clamp (  15, 1, 10 ) << std::endl;
-    std::cout << "Clamping -15 to between [1, 10] -> " << ba::clamp ( -15, 1, 10 ) << std::endl;
-
-//  It doesn't just work for ints
-    std::cout << "Clamping 5.1 to between [1, 10] -> " << ba::clamp ( 5.1, 1.0, 10.0 ) << std::endl;
-
-    {
-        std::string one ( "Lower Bound" ), two ( "upper bound!" ), test1 ( "test#" ), test2 ( "#test" );
-        std::cout << "Clamping '" << test1 << "' between ['" << one << "' and '" << two << "'] -> '" << 
-            ba::clamp ( test1, one, two ) << "'" << std::endl;
-        std::cout << "Clamping '" << test2 << "' between ['" << one << "' and '" << two << "'] -> '" << 
-            ba::clamp ( test2, one, two ) << "'" << std::endl;
-    //  There is also a predicate based version, if you want to compare objects in your own way
-        std::cout << "Clamping '" << test1 << "' between ['" << one << "' and '" << two << "'] (comparing lengths) -> '" << 
-            ba::clamp ( test1, one, two, compare_string_lengths ) << "'" << std::endl;
-        std::cout << "Clamping '" << test2 << "' between ['" << one << "' and '" << two << "'] (comparing lengths) -> '" << 
-            ba::clamp ( test2, one, two, compare_string_lengths ) << "'" << std::endl;
-    
-    }
-
-//  Sometimes, though, you don't get quite what you expect
-//  This is because the two double arguments get converted to int
-    std::cout << "Somewhat unexpected: clamp ( 12, 14.7, 15.9 ) --> " << ba::clamp ( 12, 14.7, 15.9 ) << std::endl;
-    std::cout << "Expected:     clamp ((double)12, 14.7, 15.9 ) --> " << ba::clamp ((double) 12, 14.7, 15.9 ) << std::endl;
-    return 0;
-    }

example/search_example.cpp

@@ -1,57 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#include <string>
-#include <iostream>     //  for cout, etc.
-
-#include <boost/algorithm/searching/boyer_moore.hpp>
-#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
-#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
-
-namespace ba = boost::algorithm;
-
-const std::string haystack ( "ABACAB is it everywhere!" );
-const std::string needle1  ( "ACAB" );
-const std::string needle2  ( "not ABA" );
-
-
-
-int main ( int /*argc*/, char * /*argv*/ [] ) {
-//  In search.hpp, there are generic implementations of three classic sequence search
-//  algorithms. They all have the same (dual) interface.
-
-//  There is a procedural interface, based on std::search:
-    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
-        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
-    else
-        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
-
-//  If you plan on searching for the same pattern in several different data sets,
-//  you can create a search object and use that over and over again - amortizing the setup
-//  costs across several searches
-    ba::boyer_moore<std::string::const_iterator> search1 ( needle1.begin (), needle1.end ());
-    if ( search1 ( haystack.begin (), haystack.end ()) != haystack.end ())
-        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
-    else
-        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
-
-//  There is also an implementation of boyer-moore-horspool searching
-    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
-        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
-    else
-        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
-
-//  And also the knuth-pratt-morris search algorithm
-    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
-        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
-    else
-        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
-
-    return 0;
-    }

include/boost/algorithm/clamp.hpp

@@ -1,175 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
- Revision history:
-   27 June 2009 mtc First version
-   23 Oct  2010 mtc Added predicate version
-   
-*/
-
-/// \file clamp.hpp
-/// \brief Clamp algorithm
-/// \author Marshall Clow
-///
-/// Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215
-
-#ifndef BOOST_ALGORITHM_CLAMP_HPP
-#define BOOST_ALGORITHM_CLAMP_HPP
-
-#include <functional>       //  For std::less
-#include <iterator>         //  For std::iterator_traits
-#include <cassert>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/mpl/identity.hpp>      // for identity
-#include <boost/utility/enable_if.hpp> // for boost::disable_if
-
-namespace boost { namespace algorithm {
-
-/// \fn clamp ( T const& val, 
-///               typename boost::mpl::identity<T>::type const& lo, 
-///               typename boost::mpl::identity<T>::type const& hi, Pred p )
-/// \return the value "val" brought into the range [ lo, hi ]
-///     using the comparison predicate p.
-///     If p ( val, lo ) return lo.
-///     If p ( hi, val ) return hi.
-///     Otherwise, return the original value.
-/// 
-/// \param val   The value to be clamped
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-/// \param p     A predicate to use to compare the values.
-///                 p ( a, b ) returns a boolean.
-///
-  template<typename T, typename Pred> 
-  T const & clamp ( T const& val, 
-    typename boost::mpl::identity<T>::type const & lo, 
-    typename boost::mpl::identity<T>::type const & hi, Pred p )
-  {
-//    assert ( !p ( hi, lo ));    // Can't assert p ( lo, hi ) b/c they might be equal
-    return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val;
-  } 
-
-
-/// \fn clamp ( T const& val, 
-///               typename boost::mpl::identity<T>::type const& lo, 
-///               typename boost::mpl::identity<T>::type const& hi )
-/// \return the value "val" brought into the range [ lo, hi ].
-///     If the value is less than lo, return lo.
-///     If the value is greater than "hi", return hi.
-///     Otherwise, return the original value.
-///
-/// \param val   The value to be clamped
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-///
-  template<typename T> 
-  T const& clamp ( const T& val, 
-    typename boost::mpl::identity<T>::type const & lo, 
-    typename boost::mpl::identity<T>::type const & hi )
-  {
-    return (clamp) ( val, lo, hi, std::less<T>());
-  } 
-
-/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 
-///       std::iterator_traits<InputIterator>::value_type lo, 
-///       std::iterator_traits<InputIterator>::value_type hi )
-/// \return clamp the sequence of values [first, last) into [ lo, hi ]
-/// 
-/// \param first The start of the range of values
-/// \param last  One past the end of the range of input values
-/// \param out   An output iterator to write the clamped values into
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-///
-  template<typename InputIterator, typename OutputIterator> 
-  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
-    typename std::iterator_traits<InputIterator>::value_type lo, 
-    typename std::iterator_traits<InputIterator>::value_type hi )
-  {
-  // this could also be written with bind and std::transform
-    while ( first != last )
-        *out++ = clamp ( *first++, lo, hi );
-    return out;
-  } 
-
-/// \fn clamp_range ( const Range &r, OutputIterator out, 
-///       typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
-///       typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi )
-/// \return clamp the sequence of values [first, last) into [ lo, hi ]
-/// 
-/// \param r     The range of values to be clamped
-/// \param out   An output iterator to write the clamped values into
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-///
-  template<typename Range, typename OutputIterator> 
-  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
-  clamp_range ( const Range &r, OutputIterator out,
-    typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo, 
-    typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi )
-  {
-    return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
-  } 
-
-
-/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 
-///       std::iterator_traits<InputIterator>::value_type lo, 
-///       std::iterator_traits<InputIterator>::value_type hi, Pred p )
-/// \return clamp the sequence of values [first, last) into [ lo, hi ]
-///     using the comparison predicate p.
-/// 
-/// \param first The start of the range of values
-/// \param last  One past the end of the range of input values
-/// \param out   An output iterator to write the clamped values into
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-/// \param p     A predicate to use to compare the values.
-///                 p ( a, b ) returns a boolean.
-
-///
-  template<typename InputIterator, typename OutputIterator, typename Pred> 
-  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
-    typename std::iterator_traits<InputIterator>::value_type lo, 
-    typename std::iterator_traits<InputIterator>::value_type hi, Pred p )
-  {
-  // this could also be written with bind and std::transform
-    while ( first != last )
-        *out++ = clamp ( *first++, lo, hi, p );
-    return out;
-  } 
-
-/// \fn clamp_range ( const Range &r, OutputIterator out, 
-///       typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
-///       typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
-///       Pred p )
-/// \return clamp the sequence of values [first, last) into [ lo, hi ]
-///     using the comparison predicate p.
-/// 
-/// \param r     The range of values to be clamped
-/// \param out   An output iterator to write the clamped values into
-/// \param lo    The lower bound of the range to be clamped to
-/// \param hi    The upper bound of the range to be clamped to
-/// \param p     A predicate to use to compare the values.
-///                 p ( a, b ) returns a boolean.
-//
-//  Disable this template if the first two parameters are the same type;
-//  In that case, the user will get the two iterator version.
-  template<typename Range, typename OutputIterator, typename Pred> 
-  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
-  clamp_range ( const Range &r, OutputIterator out,
-    typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo, 
-    typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
-    Pred p )
-  {
-    return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
-  } 
-
-
-}}
-
-#endif // BOOST_ALGORITHM_CLAMP_HPP

include/boost/algorithm/cxx11/all_of.hpp

@@ -1,90 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  all_of.hpp
-/// \brief Test ranges to see if all elements match a value or predicate.
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_ALL_OF_HPP
-#define BOOST_ALGORITHM_ALL_OF_HPP
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of all_of if it is available
-using std::all_of;      // Section 25.2.1
-#else
-/// \fn all_of ( InputIterator first, InputIterator last, Predicate p )
-/// \return true if all elements in [first, last) satisfy the predicate 'p'
-/// \note returns true on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param p     A predicate for testing the elements of the sequence
-///
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template<typename InputIterator, typename Predicate> 
-bool all_of ( InputIterator first, InputIterator last, Predicate p )
-{
-    for ( ; first != last; ++first )
-        if ( !p(*first)) 
-            return false;
-    return true; 
-} 
-#endif
-
-/// \fn all_of ( const Range &r, Predicate p )
-/// \return true if all elements in the range satisfy the predicate 'p'
-/// \note returns true on an empty range
-/// 
-/// \param r    The input range
-/// \param p    A predicate for testing the elements of the range
-///
-template<typename Range, typename Predicate> 
-bool all_of ( const Range &r, Predicate p )
-{
-    return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p );
-} 
-
-/// \fn all_of_equal ( InputIterator first, InputIterator last, const T &val )
-/// \return true if all elements in [first, last) are equal to 'val'
-/// \note returns true on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param val   A value to compare against
-///
-template<typename InputIterator, typename T> 
-bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
-{
-    for ( ; first != last; ++first )
-    if ( val != *first ) 
-        return false;
-    return true; 
-} 
-
-/// \fn all_of_equal ( const Range &r, const T &val )
-/// \return true if all elements in the range are equal to 'val'
-/// \note returns true on an empty range
-/// 
-/// \param r    The input range
-/// \param val  A value to compare against
-///
-template<typename Range, typename T> 
-bool all_of_equal ( const Range &r, const T &val ) 
-{
-    return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val );
-} 
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_ALL_OF_HPP

include/boost/algorithm/cxx11/any_of.hpp

@@ -1,89 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-/// \file
-/// \brief Test ranges to see if any elements match a value or predicate.
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_ANY_OF_HPP
-#define BOOST_ALGORITHM_ANY_OF_HPP
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-//  Use the C++11 versions of any_of if it is available
-#if __cplusplus >= 201103L
-using std::any_of;      // Section 25.2.2
-#else
-/// \fn any_of ( InputIterator first, InputIterator last, Predicate p )
-/// \return true if any of the elements in [first, last) satisfy the predicate
-/// \note returns false on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param p     A predicate for testing the elements of the sequence
-///
-template<typename InputIterator, typename Predicate> 
-bool any_of ( InputIterator first, InputIterator last, Predicate p ) 
-{
-    for ( ; first != last; ++first )
-        if ( p(*first)) 
-            return true;
-    return false; 
-} 
-#endif
-
-/// \fn any_of ( const Range &r, Predicate p )
-/// \return true if any elements in the range satisfy the predicate 'p'
-/// \note returns false on an empty range
-/// 
-/// \param r    The input range
-/// \param p    A predicate for testing the elements of the range
-///
-template<typename Range, typename Predicate> 
-bool any_of ( const Range &r, Predicate p )
-{
-    return boost::algorithm::any_of (boost::begin (r), boost::end (r), p);
-} 
-
-/// \fn any_of_equal ( InputIterator first, InputIterator last, const V &val )
-/// \return true if any of the elements in [first, last) are equal to 'val'
-/// \note returns false on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param val   A value to compare against
-///
-template<typename InputIterator, typename V> 
-bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) 
-{
-    for ( ; first != last; ++first )
-        if ( val == *first )
-            return true;
-    return false; 
-} 
-
-/// \fn any_of_equal ( const Range &r, const V &val )
-/// \return true if any of the elements in the range are equal to 'val'
-/// \note returns false on an empty range
-/// 
-/// \param r     The input range
-/// \param val   A value to compare against
-///
-template<typename Range, typename V> 
-bool any_of_equal ( const Range &r, const V &val ) 
-{
-    return boost::algorithm::any_of_equal (boost::begin (r), boost::end (r), val);
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_ANY_OF_HPP

include/boost/algorithm/cxx11/copy_if.hpp

@@ -1,133 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  copy_if.hpp
-/// \brief Copy a subset of a sequence to a new sequence
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_COPY_IF_HPP
-#define BOOST_ALGORITHM_COPY_IF_HPP
-
-#include <algorithm>	// for std::copy_if, if available
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of copy_if if it is available
-using std::copy_if;         // Section 25.3.1
-#else
-/// \fn copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
-/// \brief Copies all the elements from the input range that satisfy the
-/// predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template<typename InputIterator, typename OutputIterator, typename Predicate> 
-OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
-{
-    for ( ; first != last; ++first )
-        if (p(*first))
-            *result++ = first;
-    return result;
-}
-#endif
-
-/// \fn copy_if ( const Range &r, OutputIterator result, Predicate p )
-/// \brief Copies all the elements from the input range that satisfy the
-/// predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param r        The input range
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename Range, typename OutputIterator, typename Predicate>
-OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
-{
-    return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p);
-}
-
-
-/// \fn copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
-/// \brief Copies all the elements at the start of the input range that
-///     satisfy the predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename InputIterator, typename OutputIterator, typename Predicate> 
-OutputIterator copy_while ( InputIterator first, InputIterator last, 
-                                OutputIterator result, Predicate p )
-{
-    for ( ; first != last && p(*first); ++first )
-        *result++ = first;
-    return result;
-}
-
-/// \fn copy_while ( const Range &r, OutputIterator result, Predicate p )
-/// \brief Copies all the elements at the start of the input range that
-///     satisfy the predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param r        The input range
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename Range, typename OutputIterator, typename Predicate>
-OutputIterator copy_while ( const Range &r, OutputIterator result, Predicate p )
-{
-    return boost::algorithm::copy_while (boost::begin (r), boost::end(r), result, p);
-}
-
-
-/// \fn copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
-/// \brief Copies all the elements at the start of the input range that do not
-///     satisfy the predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename InputIterator, typename OutputIterator, typename Predicate> 
-OutputIterator copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
-{
-    for ( ; first != last && !p(*first); ++first )
-        *result++ = first;
-    return result;
-}
-
-/// \fn copy_until ( const Range &r, OutputIterator result, Predicate p )
-/// \brief Copies all the elements at the start of the input range that do not
-///     satisfy the predicate to the output range.
-/// \return The updated output iterator
-/// 
-/// \param r        The input range
-/// \param result   An output iterator to write the results into
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename Range, typename OutputIterator, typename Predicate>
-OutputIterator copy_until ( const Range &r, OutputIterator result, Predicate p )
-{
-    return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p);
-}
-
-}} // namespace boost and algorithm
-
-#endif  // BOOST_ALGORITHM_COPY_IF_HPP

include/boost/algorithm/cxx11/copy_n.hpp

@@ -1,44 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  copy_n.hpp
-/// \brief Copy n items from one sequence to another
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_COPY_N_HPP
-#define BOOST_ALGORITHM_COPY_N_HPP
-
-#include <algorithm>    // for std::copy_n, if available
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of copy_n if it is available
-using std::copy_n;          // Section 25.3.1
-#else
-/// \fn copy_n ( InputIterator first, Size n, OutputIterator result )
-/// \brief Copies exactly n (n > 0) elements from the range starting at first to
-///     the range starting at result.
-/// \return         The updated output iterator
-/// 
-/// \param first    The start of the input sequence
-/// \param n        The number of elements to copy
-/// \param result   An output iterator to write the results into
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///     otherwise we have our own implementation.
-template <typename InputIterator, typename Size, typename OutputIterator>
-OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
-{
-    for ( ; n > 0; --n, ++first, ++result )
-        *result = *first;
-    return result;
-}
-#endif
-}} // namespace boost and algorithm
-
-#endif  // BOOST_ALGORITHM_COPY_IF_HPP

include/boost/algorithm/cxx11/find_if_not.hpp

@@ -1,60 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  find_if_not.hpp
-/// \brief Find the first element in a sequence that does not satisfy a predicate.
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
-#define BOOST_ALGORITHM_FIND_IF_NOT_HPP
-
-#include <algorithm>    // for std::find_if_not, if it exists
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of find_if_not if it is available
-using std::find_if_not;      // Section 25.2.5
-#else
-/// \fn find_if_not(InputIterator first, InputIterator last, Predicate p)
-/// \brief Finds the first element in the sequence that does not satisfy the predicate.
-/// \return         The iterator pointing to the desired element.
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param p        A predicate for testing the elements of the range
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template<typename InputIterator, typename Predicate> 
-InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
-{
-    for ( ; first != last; ++first )
-        if ( !p(*first))
-            break;
-    return first;
-}
-#endif
-
-/// \fn find_if_not ( const Range &r, Predicate p )
-/// \brief Finds the first element in the sequence that does not satisfy the predicate.
-/// \return         The iterator pointing to the desired element.
-/// 
-/// \param r        The input range
-/// \param p        A predicate for testing the elements of the range
-///
-template<typename Range, typename Predicate>
-typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p )
-{
-    return boost::algorithm::find_if_not (boost::begin (r), boost::end(r), p);
-}
-
-}}
-#endif  // BOOST_ALGORITHM_FIND_IF_NOT_HPP

include/boost/algorithm/cxx11/iota.hpp

@@ -1,74 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  iota.hpp
-/// \brief Generate an increasing series
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_IOTA_HPP
-#define BOOST_ALGORITHM_IOTA_HPP
-
-#include <numeric>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
-using std::iota;      // Section 26.7.6
-#else
-/// \fn iota ( ForwardIterator first, ForwardIterator last, T value )
-/// \brief Generates an increasing sequence of values, and stores them in [first, last)
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param value    The initial value of the sequence to be generated
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template <typename ForwardIterator, typename T>
-void iota ( ForwardIterator first, ForwardIterator last, T value )
-{
-    for ( ; first != last; ++first, ++value )
-        *first = value;
-}
-#endif
-
-/// \fn iota ( Range &r, T value )
-/// \brief Generates an increasing sequence of values, and stores them in the input Range.
-/// 
-/// \param r        The input range
-/// \param value    The initial value of the sequence to be generated
-///
-template <typename Range, typename T>
-void iota ( Range &r, T value )
-{
-    boost::algorithm::iota (boost::begin(r), boost::end(r), value);
-}
-
-
-/// \fn iota_n ( OutputIterator out, T value, std::size_t n )
-/// \brief Generates an increasing sequence of values, and stores them in the input Range.
-/// 
-/// \param out      An output iterator to write the results into
-/// \param value    The initial value of the sequence to be generated
-/// \param n        The number of items to write
-///
-template <typename OutputIterator, typename T>
-OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
-{
-    while ( n-- > 0 )
-        *out++ = value++;
-
-    return out;
-}
-
-}}
-
-#endif  // BOOST_ALGORITHM_IOTA_HPP

include/boost/algorithm/cxx11/is_partitioned.hpp

@@ -1,65 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  is_partitioned.hpp
-/// \brief Tell if a sequence is partitioned
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
-#define BOOST_ALGORITHM_IS_PARTITIONED_HPP
-
-#include <algorithm>	// for std::is_partitioned, if available
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
-using std::is_partitioned;      // Section 25.3.13
-#else
-/// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partititioned according to a predicate
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param p        The predicicate to test the values with
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template <typename InputIterator, typename UnaryPredicate>
-bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
-{
-//	Run through the part that satisfy the predicate
-    for ( ; first != last; ++first )
-        if ( !p (*first))
-        	break;
-//	Now the part that does not satisfy the predicate
-    for ( ; first != last; ++first )
-        if ( p (*first))
-        	return false;
-    return true;
-}
-#endif
-
-/// \fn is_partitioned ( const Range &r, UnaryPredicate p )
-/// \brief Generates an increasing sequence of values, and stores them in the input Range.
-/// 
-/// \param r        The input range
-/// \param p        The predicicate to test the values with
-///
-template <typename Range, typename UnaryPredicate>
-bool is_partitioned ( const Range &r, UnaryPredicate p )
-{
-    return boost::algorithm::is_partitioned (boost::begin(r), boost::end(r), p);
-}
-
-
-}}
-
-#endif  // BOOST_ALGORITHM_IS_PARTITIONED_HPP

include/boost/algorithm/cxx11/is_permutation.hpp

@@ -1,139 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  is_permutation.hpp
-/// \brief Is a sequence a permutation of another sequence
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_IS_PERMUTATION_HPP
-#define BOOST_ALGORITHM_IS_PERMUTATION_HPP
-
-#include <algorithm>    // for std::less, tie, mismatch and is_permutation (if available)
-#include <utility>      // for std::make_pair
-#include <functional>   // for std::equal_to
-#include <iterator>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/tr1/tr1/tuple>      // for tie
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of is_permutation if it is available
-using std::is_permutation;              // Section 25.2.12
-#else
-/// \cond DOXYGEN_HIDE
-namespace detail {
-    template <typename Predicate, typename Iterator>
-    struct value_predicate {
-        value_predicate ( Predicate p, Iterator it ) : p_ ( p ), it_ ( it ) {}
-
-        template <typename T1>
-        bool operator () ( const T1 &t1 ) const { return p_ ( *it_, t1 ); }
-    private:
-        Predicate &p_;
-        Iterator it_;
-        };
-}
-/// \endcond
-
-
-/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
-///
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param first2   The start of the second sequence
-/// \param p        The predicate to compare elements with
-///
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available,
-///     otherwise we have our own implementation.
-template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
-bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
-                      ForwardIterator2 first2, BinaryPredicate p )
-{
-//  Skip the common prefix (if any)
-//  std::tie (first1, first2) = std::mismatch (first1, last1, first2, p);
-    std::pair<ForwardIterator1, ForwardIterator2> eq = std::mismatch (first1, last1, first2, p);
-    first1 = eq.first;
-    first2 = eq.second;
-    if ( first1 != last1 ) {
-    //  Create last2
-        ForwardIterator2 last2 = first2;
-        std::advance ( last2, std::distance (first1, last1));
-
-    //  for each unique value in the sequence [first1,last1), count how many times
-    //  it occurs, and make sure it occurs the same number of times in [first2, last2)
-        for ( ForwardIterator1 iter = first1; iter != last1; ++iter ) {
-            detail::value_predicate<BinaryPredicate, ForwardIterator1> pred ( p, iter );
-
-        /*  For each value we haven't seen yet... */
-            if ( std::find_if ( first1, iter, pred ) == iter ) {
-                std::size_t dest_count = std::count_if ( first2, last2, pred );
-                if ( dest_count == 0 || dest_count != (std::size_t) std::count_if ( iter, last1, pred ))
-                    return false;
-                }
-            }
-        }
-
-    return true;
-}
-
-/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2 )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
-///
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param first2   The start of the second sequence
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available,
-///     otherwise we have our own implementation.
-template< class ForwardIterator1, class ForwardIterator2 >
-bool is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2 )
-{
-//  How should I deal with the idea that ForwardIterator1::value_type
-//  and ForwardIterator2::value_type could be different? Define my own comparison predicate?
-    return boost::algorithm::is_permutation ( first, last, first2,
-                          std::equal_to<typename std::iterator_traits<ForwardIterator1>::value_type> ());
-}
-
-#endif
-
-/// \fn is_permutation ( const Range &r, ForwardIterator first2 )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
-///
-/// \param r        The input range
-/// \param first2   The start of the second sequence
-template <typename Range, typename ForwardIterator>
-bool is_permutation ( const Range &r, ForwardIterator first2 )
-{
-    return boost::algorithm::is_permutation (boost::begin (r), boost::end (r), first2 );
-}
-
-/// \fn is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
-///
-/// \param r        The input range
-/// \param first2   The start of the second sequence
-/// \param pred     The predicate to compare elements with
-///
-//  Disable this template when the first two parameters are the same type
-//  That way the non-range version will be chosen.
-template <typename Range, typename ForwardIterator, typename BinaryPredicate>
-typename boost::disable_if_c<boost::is_same<Range, ForwardIterator>::value, bool>::type
-is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred )
-{
-    return boost::algorithm::is_permutation (boost::begin (r), boost::end (r), first2, pred );
-}
-
-}}
-
-#endif  // BOOST_ALGORITHM_IS_PERMUTATION_HPP

include/boost/algorithm/cxx11/none_of.hpp

@@ -1,87 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  none_of.hpp
-/// \brief Test ranges to see if no elements match a value or predicate.
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_NONE_OF_HPP
-#define BOOST_ALGORITHM_NONE_OF_HPP
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-//  Use the C++11 versions of the none_of if it is available
-#if __cplusplus >= 201103L
-using std::none_of;     // Section 25.2.3
-#else
-/// \fn none_of ( InputIterator first, InputIterator last, Predicate p )
-/// \return true if none of the elements in [first, last) satisfy the predicate 'p'
-/// \note returns true on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param p     A predicate for testing the elements of the sequence
-///
-template<typename InputIterator, typename Predicate> 
-bool none_of ( InputIterator first, InputIterator last, Predicate p )
-{
-for ( ; first != last; ++first )
-    if ( p(*first)) 
-        return false;
-    return true;
-} 
-#endif
-
-/// \fn none_of ( const Range &r, Predicate p )
-/// \return true if none of the elements in the range satisfy the predicate 'p'
-/// \note returns true on an empty range
-/// 
-/// \param r     The input range
-/// \param p     A predicate for testing the elements of the range
-///
-template<typename Range, typename Predicate> 
-bool none_of ( const Range &r, Predicate p )
-{
-    return boost::algorithm::none_of (boost::begin (r), boost::end (r), p );
-} 
-
-/// \fn none_of_equal ( InputIterator first, InputIterator last, const V &val )
-/// \return true if none of the elements in [first, last) are equal to 'val'
-/// \note returns true on an empty range
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param val   A value to compare against
-///
-template<typename InputIterator, typename V> 
-bool none_of_equal ( InputIterator first, InputIterator last, const V &val ) 
-{
-    for ( ; first != last; ++first )
-        if ( val == *first )
-            return false;
-    return true; 
-} 
-
-/// \fn none_of_equal ( const Range &r, const V &val )
-/// \return true if none of the elements in the range are equal to 'val'
-/// \note returns true on an empty range
-/// 
-/// \param r     The input range
-/// \param val   A value to compare against
-///
-template<typename Range, typename V> 
-bool none_of_equal ( const Range &r, const V & val ) 
-{
-    return boost::algorithm::none_of_equal (boost::begin (r), boost::end (r), val);
-} 
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_NONE_OF_HPP

include/boost/algorithm/cxx11/one_of.hpp

@@ -1,82 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file one_of.hpp
-/// \brief Test ranges to see if only one element matches a value or predicate.
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_ONE_OF_HPP
-#define BOOST_ALGORITHM_ONE_OF_HPP
-
-#include <algorithm>            // for std::find and std::find_if
-#include <boost/algorithm/cxx11/none_of.hpp>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-/// \fn one_of ( InputIterator first, InputIterator last, Predicate p )
-/// \return true if the predicate 'p' is true for exactly one item in [first, last).
-/// 
-/// \param first The start of the input sequence
-/// \param last  One past the end of the input sequence
-/// \param p     A predicate for testing the elements of the sequence
-///
-template<typename InputIterator, typename Predicate> 
-bool one_of ( InputIterator first, InputIterator last, Predicate p )
-{
-    InputIterator i = std::find_if (first, last, p);
-    if (i == last)
-        return false;    // Didn't occur at all
-    return boost::algorithm::none_of (++i, last, p);
-}
-
-/// \fn one_of ( const Range &r, Predicate p )
-/// \return true if the predicate 'p' is true for exactly one item in the range.
-/// 
-/// \param r    The input range
-/// \param p    A predicate for testing the elements of the range
-///
-template<typename Range, typename Predicate> 
-bool one_of ( const Range &r, Predicate p ) 
-{
-    return boost::algorithm::one_of ( boost::begin (r), boost::end (r), p );
-}
-
-
-/// \fn one_of_equal ( InputIterator first, InputIterator last, const V &val )
-/// \return true if the value 'val' exists only once in [first, last).
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param val      A value to compare against
-///
-template<typename InputIterator, typename V> 
-bool one_of_equal ( InputIterator first, InputIterator last, const V &val )
-{
-    InputIterator i = std::find (first, last, val); // find first occurrence of 'val'
-    if (i == last)
-        return false;                    // Didn't occur at all
-    return boost::algorithm::none_of_equal (++i, last, val);
-}
-
-/// \fn one_of_equal ( const Range &r, const V &val )
-/// \return true if the value 'val' exists only once in the range.
-/// 
-/// \param r    The input range
-/// \param val  A value to compare against
-///
-template<typename Range, typename V> 
-bool one_of_equal ( const Range &r, const V &val )
-{
-    return boost::algorithm::one_of_equal ( boost::begin (r), boost::end (r), val );
-} 
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_ALL_HPP

include/boost/algorithm/cxx11/ordered.hpp

@@ -1,286 +0,0 @@
-//  Copyright (c) 2010 Nuovation System Designs, LLC
-//    Grant Erickson <gerickson@nuovations.com>
-//
-//  Reworked somewhat by Marshall Clow; August 2010
-//  
-//  Distributed under the Boost Software License, Version 1.0. (See
-//  accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-//
-//  See http://www.boost.org/ for latest version.
-//
-
-#ifndef BOOST_ALGORITHM_ORDERED_HPP
-#define BOOST_ALGORITHM_ORDERED_HPP
-
-#include <algorithm>
-#include <functional>
-#include <iterator>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
-using std::is_sorted_until; // Section 25.4.1.5
-using std::is_sorted;       // Section 25.4.1.5
-#else
-/// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
-/// \return the point in the sequence [first, last) where the elements are unordered
-///     (according to the comparison predicate 'p').
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-/// \param p     A binary predicate that returns true if two elements are ordered.
-///
-    template <typename ForwardIterator, typename Pred>
-    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
-    {
-        if ( first == last ) return last;  // the empty sequence is ordered
-        ForwardIterator next = first;
-        while ( ++next != last )
-        {
-            if ( !p ( *first, *next ))
-                return next;
-            first = next;
-        }
-        return last;    
-    }
-
-/// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last )
-/// \return the point in the sequence [first, last) where the elements are unordered
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-    template <typename ForwardIterator>
-    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
-    {
-        typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted_until ( first, last, std::less_equal<value_type>());
-    }
-
-
-/// \fn is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
-/// \return whether or not the entire sequence is sorted
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-/// \param p     A binary predicate that returns true if two elements are ordered.
-///
-    template <typename ForwardIterator, typename Pred>
-    bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
-    {
-        return boost::algorithm::is_sorted_until (first, last, p) == last;
-    }
-
-/// \fn is_sorted ( ForwardIterator first, ForwardIterator last )
-/// \return whether or not the entire sequence is sorted
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-    template <typename ForwardIterator>
-    bool is_sorted ( ForwardIterator first, ForwardIterator last )
-    {
-        return boost::algorithm::is_sorted_until (first, last) == last;
-    }
-#endif
-
-///
-///	-- Range based versions of the C++11 functions
-///
-
-/// \fn is_sorted_until ( const R &range, Pred p )
-/// \return the point in the range R where the elements are unordered
-///     (according to the comparison predicate 'p').
-/// 
-/// \param range The range to be tested.
-/// \param p     A binary predicate that returns true if two elements are ordered.
-///
-    template <typename R, typename Pred>
-    typename boost::lazy_disable_if_c<
-        boost::is_same<R, Pred>::value, 
-        typename boost::range_iterator<const R> 
-    >::type is_sorted_until ( const R &range, Pred p )
-    {
-        return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ), p );
-    }
-
-
-/// \fn is_sorted_until ( const R &range )
-/// \return the point in the range R where the elements are unordered
-/// 
-/// \param range The range to be tested.
-///
-    template <typename R>
-    typename boost::range_iterator<const R>::type is_sorted_until ( const R &range )
-    {
-        return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ));
-    }
-
-
-/// \fn is_sorted ( const R &range, Pred p )
-/// \return whether or not the entire range R is sorted
-///     (according to the comparison predicate 'p').
-/// 
-/// \param range The range to be tested.
-/// \param p     A binary predicate that returns true if two elements are ordered.
-///
-    template <typename R, typename Pred>
-    bool is_sorted ( const R &range, Pred p )
-    {
-        return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p );
-    }
-
-
-/// \fn is_sorted ( const R &range )
-/// \return whether or not the entire range R is sorted
-/// 
-/// \param range The range to be tested.
-///
-    template <typename R, typename Pred>
-    bool is_sorted ( const R &range )
-    {
-        return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ));
-    }
-
-
-///
-///	-- Range based versions of the C++11 functions
-///
-
-/// \fn is_increasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is increasing; i.e, each item is greater than or  
-///     equal to the previous one.
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-/// \note This function will return true for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_strictly_increasing instead.
-    template <typename ForwardIterator>
-    bool is_increasing ( ForwardIterator first, ForwardIterator last )
-    {
-        typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::less_equal<value_type>());
-    }
-
-
-/// \fn is_increasing ( const R &range )
-/// \return true if the entire sequence is increasing; i.e, each item is greater than or  
-///     equal to the previous one.
-/// 
-/// \param range The range to be tested.
-///
-/// \note This function will return true for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_strictly_increasing instead.
-    template <typename R>
-    bool is_increasing ( const R &range )
-    {
-        return is_increasing ( boost::begin ( range ), boost::end ( range ));
-    }
-
-
-
-/// \fn is_decreasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is decreasing; i.e, each item is less than 
-///     or equal to the previous one.
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-/// \note This function will return true for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_strictly_decreasing instead.
-    template <typename ForwardIterator>
-    bool is_decreasing ( ForwardIterator first, ForwardIterator last )
-    {
-        typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::greater_equal<value_type>());
-    }
-
-/// \fn is_decreasing ( const R &range )
-/// \return true if the entire sequence is decreasing; i.e, each item is less than 
-///     or equal to the previous one.
-/// 
-/// \param range The range to be tested.
-///
-/// \note This function will return true for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_strictly_decreasing instead.
-    template <typename R>
-    bool is_decreasing ( const R &range )
-    {
-        return is_decreasing ( boost::begin ( range ), boost::end ( range ));
-    }
-
-
-
-/// \fn is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is strictly increasing; i.e, each item is greater
-///     than the previous one
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-/// \note This function will return false for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_increasing instead.
-    template <typename ForwardIterator>
-    bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
-    {
-        typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::less<value_type>());
-    }
-
-/// \fn is_strictly_increasing ( const R &range )
-/// \return true if the entire sequence is strictly increasing; i.e, each item is greater
-///     than the previous one
-/// 
-/// \param range The range to be tested.
-///
-/// \note This function will return false for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_increasing instead.
-    template <typename R>
-    bool is_strictly_increasing ( const R &range )
-    {
-        return is_strictly_increasing ( boost::begin ( range ), boost::end ( range ));
-    }
-
-
-/// \fn is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is strictly decreasing; i.e, each item is less than
-///     the previous one
-/// 
-/// \param first The start of the sequence to be tested.
-/// \param last  One past the end of the sequence
-///
-/// \note This function will return false for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_decreasing instead.
-    template <typename ForwardIterator>
-    bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
-    {
-        typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::greater<value_type>());
-    }
-
-/// \fn is_strictly_decreasing ( const R &range )
-/// \return true if the entire sequence is strictly decreasing; i.e, each item is less than
-///     the previous one
-/// 
-/// \param range The range to be tested.
-///
-/// \note This function will return false for sequences that contain items that compare
-///     equal. If that is not what you intended, you should use is_decreasing instead.
-    template <typename R>
-    bool is_strictly_decreasing ( const R &range )
-    {
-        return is_strictly_decreasing ( boost::begin ( range ), boost::end ( range ));
-    }
-
-}} // namespace boost
-
-#endif  // BOOST_ALGORITHM_ORDERED_HPP

include/boost/algorithm/cxx11/partition_copy.hpp

@@ -1,77 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  partition_copy.hpp
-/// \brief Copy a subset of a sequence to a new sequence
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
-#define BOOST_ALGORITHM_PARTITION_COPY_HPP
-
-#include <utility>  // for make_pair
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of partition_copy if it is available
-using std::partition_copy;  // Section 25.3.13
-#else
-/// \fn partition_copy ( InputIterator first, InputIterator last,
-///     OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p )
-/// \brief Copies the elements that satisfy the predicate p from the range [first, last) 
-///     to the range beginning at d_first_true, and
-///     copies the elements that do not satisfy p to the range beginning at d_first_false.
-///
-/// 
-/// \param first     The start of the input sequence
-/// \param last      One past the end of the input sequence
-/// \param out_true  An output iterator to write the elements that satisfy the predicate into
-/// \param out_false An output iterator to write the elements that do not satisfy the predicate into
-/// \param p         A predicate for dividing the elements of the input sequence.
-///
-/// \note            This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template <typename InputIterator, 
-        typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
-std::pair<OutputIterator1, OutputIterator2>
-partition_copy ( InputIterator first, InputIterator last,
-        OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p )
-{
-    for ( ; first != last; ++first )
-        if ( p (*first))
-            *out_true++ = *first;
-        else
-            *out_false++ = *first;
-    return std::pair<OutputIterator1, OutputIterator2> ( out_true, out_false );
-}
-#endif
-
-/// \fn partition_copy ( const Range &r, 
-///     OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p )
-/// 
-/// \param r         The input range
-/// \param out_true  An output iterator to write the elements that satisfy the predicate into
-/// \param out_false An output iterator to write the elements that do not satisfy the predicate into
-/// \param p         A predicate for dividing the elements of the input sequence.
-///
-template <typename Range, typename OutputIterator1, typename OutputIterator2, 
-            typename UnaryPredicate>
-std::pair<OutputIterator1, OutputIterator2>
-partition_copy ( const Range &r, OutputIterator1 out_true, OutputIterator2 out_false, 
-                                UnaryPredicate p )
-{
-    return boost::algorithm::partition_copy 
-                      (boost::begin(r), boost::end(r), out_true, out_false, p );
-}
-
-}} // namespace boost and algorithm
-
-#endif  // BOOST_ALGORITHM_PARTITION_COPY_HPP

include/boost/algorithm/cxx11/partition_point.hpp

@@ -1,72 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2011-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-/// \file  partition_point.hpp
-/// \brief Find the partition point in a sequence
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
-#define BOOST_ALGORITHM_PARTITION_POINT_HPP
-
-#include <algorithm>	// for std::partition_point, if available
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
-using std::partition_point;      // Section 25.3.13
-#else
-/// \fn partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
-/// \brief Given a partitioned range, returns the partition point, i.e, the first element 
-///		that does not satisfy p
-/// 
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param p        The predicate to test the values with
-/// \note           This function is part of the C++2011 standard library.
-///  We will use the standard one if it is available, 
-///  otherwise we have our own implementation.
-template <typename ForwardIterator, typename Predicate>
-ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
-{
-    std::size_t dist = std::distance ( first, last );
-    while ( first != last ) {
-        std::size_t d2 = dist / 2;
-        ForwardIterator ret_val = first;
-        std::advance (ret_val, d2);
-        if (p (*ret_val)) {
-            first = ++ret_val;
-            dist -= d2 + 1;
-            }
-        else {
-            last = ret_val;
-            dist = d2;
-            }
-        }
-    return first;
-}
-#endif
-
-/// \fn partition_point ( Range &r, Predicate p )
-/// \brief Given a partitioned range, returns the partition point
-/// 
-/// \param r        The input range
-/// \param p        The predicate to test the values with
-///
-template <typename Range, typename Predicate>
-typename boost::range_iterator<Range> partition_point ( Range &r, Predicate p )
-{
-    return boost::algorithm::partition_point (boost::begin(r), boost::end(r), p);
-}
-
-
-}}
-
-#endif  // BOOST_ALGORITHM_PARTITION_POINT_HPP

include/boost/algorithm/minmax.hpp

@@ -1,7 +1,7 @@
 //  (C) Copyright Herve Bronnimann 2004.
-//
+//  Use, modification and distribution are subject to the
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  Boost Software License, Version 1.0. (See accompanying file
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 /*
  Revision history:

include/boost/algorithm/minmax_element.hpp

@@ -1,7 +1,7 @@
 //  (C) Copyright Herve Bronnimann 2004.
-//
+//  Use, modification and distribution are subject to the
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  Boost Software License, Version 1.0. (See accompanying file
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 /*
  Revision history:

include/boost/algorithm/searching/boyer_moore.hpp

@@ -1,268 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#ifndef BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP
-#define BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP
-
-#include <iterator>     // for std::iterator_traits
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/algorithm/searching/detail/bm_traits.hpp>
-#include <boost/algorithm/searching/detail/debugging.hpp>
-
-namespace boost { namespace algorithm {
-
-/*
-    A templated version of the boyer-moore searching algorithm.
-    
-References:
-    http://www.cs.utexas.edu/users/moore/best-ideas/string-searching/
-    http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf
-    
-Explanations:   boostinspect:noascii (test tool complains)
-    http://en.wikipedia.org/wiki/Boyer–Moore_string_search_algorithm
-    http://www.movsd.com/bm.htm
-    http://www.cs.ucdavis.edu/~gusfield/cs224f09/bnotes.pdf
-
-The Boyer-Moore search algorithm uses two tables, a "bad character" table
-to tell how far to skip ahead when it hits a character that is not in the pattern,
-and a "good character" table to tell how far to skip ahead when it hits a
-mismatch on a character that _is_ in the pattern.
-
-Requirements:
-        * Random access iterators
-        * The two iterator types (patIter and corpusIter) must 
-            "point to" the same underlying type and be comparable.
-        * Additional requirements may be imposed but the skip table, such as:
-        ** Numeric type (array-based skip table)
-        ** Hashable type (map-based skip table)
-*/
-
-    template <typename patIter, typename traits = detail::BM_traits<patIter> >
-    class boyer_moore {
-        typedef typename std::iterator_traits<patIter>::difference_type difference_type;
-    public:
-        boyer_moore ( patIter first, patIter last ) 
-                : pat_first ( first ), pat_last ( last ),
-                  k_pattern_length ( std::distance ( pat_first, pat_last )),
-                  skip_ ( k_pattern_length, -1 ),
-                  suffix_ ( k_pattern_length + 1 )
-            {
-            this->build_skip_table   ( first, last );
-            this->build_suffix_table ( first, last );
-            }
-            
-        ~boyer_moore () {}
-        
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        ///
-        template <typename corpusIter>
-        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
-            BOOST_STATIC_ASSERT (( boost::is_same<
-                                    typename std::iterator_traits<patIter>::value_type, 
-                                    typename std::iterator_traits<corpusIter>::value_type>::value ));
-
-            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
-            if (    pat_first ==    pat_last ) return corpus_first; // empty pattern matches at start
-
-            const difference_type k_corpus_length  = std::distance ( corpus_first, corpus_last );
-        //  If the pattern is larger than the corpus, we can't find it!
-            if ( k_corpus_length < k_pattern_length ) 
-                return corpus_last;
-
-        //  Do the search 
-            return this->do_search   ( corpus_first, corpus_last );
-            }
-            
-        template <typename Range>
-        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
-            return (*this) (boost::begin(r), boost::end(r));
-            }
-
-    private:
-/// \cond DOXYGEN_HIDE
-        patIter pat_first, pat_last;
-        const difference_type k_pattern_length;
-        typename traits::skip_table_t skip_;
-        std::vector <difference_type> suffix_;
-
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        /// \param p            A predicate used for the search comparisons.
-        ///
-        template <typename corpusIter>
-        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
-        /*  ---- Do the matching ---- */
-            corpusIter curPos = corpus_first;
-            const corpusIter lastPos = corpus_last - k_pattern_length;
-            difference_type j, k, m;
-
-            while ( curPos <= lastPos ) {
-        /*  while ( std::distance ( curPos, corpus_last ) >= k_pattern_length ) { */
-            //  Do we match right where we are?
-                j = k_pattern_length;
-                while ( pat_first [j-1] == curPos [j-1] ) {
-                    j--;
-                //  We matched - we're done!
-                    if ( j == 0 )
-                        return curPos;
-                    }
-                
-            //  Since we didn't match, figure out how far to skip forward
-                k = skip_ [ curPos [ j - 1 ]];
-                m = j - k - 1;
-                if ( k < j && m > suffix_ [ j ] )
-                    curPos += m;
-                else
-                    curPos += suffix_ [ j ];
-                }
-        
-            return corpus_last;     // We didn't find anything
-            }
-
-
-        void build_skip_table ( patIter first, patIter last ) {
-            for ( std::size_t i = 0; first != last; ++first, ++i )
-                skip_.insert ( *first, i );
-            }
-        
-
-        template<typename Iter, typename Container>
-        void compute_bm_prefix ( Iter pat_first, Iter pat_last, Container &prefix ) {
-            const std::size_t count = std::distance ( pat_first, pat_last );
-            BOOST_ASSERT ( count > 0 );
-            BOOST_ASSERT ( prefix.size () == count );
-                            
-            prefix[0] = 0;
-            std::size_t k = 0;
-            for ( std::size_t i = 1; i < count; ++i ) {
-                BOOST_ASSERT ( k < count );
-                while ( k > 0 && ( pat_first[k] != pat_first[i] )) {
-                    BOOST_ASSERT ( k < count );
-                    k = prefix [ k - 1 ];
-                    }
-                    
-                if ( pat_first[k] == pat_first[i] )
-                    k++;
-                prefix [ i ] = k;
-                }
-            }
-
-        void build_suffix_table ( patIter pat_first, patIter pat_last ) {
-            const std::size_t count = (std::size_t) std::distance ( pat_first, pat_last );
-            
-            if ( count > 0 ) {  // empty pattern
-                std::vector<typename std::iterator_traits<patIter>::value_type> reversed(count);
-                (void) std::reverse_copy ( pat_first, pat_last, reversed.begin ());
-                
-                std::vector<difference_type> prefix (count);
-                compute_bm_prefix ( pat_first, pat_last, prefix );
-        
-                std::vector<difference_type> prefix_reversed (count);
-                compute_bm_prefix ( reversed.begin (), reversed.end (), prefix_reversed );
-                
-                for ( std::size_t i = 0; i <= count; i++ )
-                    suffix_[i] = count - prefix [count-1];
-         
-                for ( std::size_t i = 0; i < count; i++ ) {
-                    const std::size_t     j = count - prefix_reversed[i];
-                    const difference_type k = i -     prefix_reversed[i] + 1;
-         
-                    if (suffix_[j] > k)
-                        suffix_[j] = k;
-                    }
-                }
-            }
-/// \endcond
-        };
-
-
-/*  Two ranges as inputs gives us four possibilities; with 2,3,3,4 parameters
-    Use a bit of TMP to disambiguate the 3-argument templates */
-
-/// \fn boyer_moore_search ( corpusIter corpus_first, corpusIter corpus_last, 
-///       patIter pat_first, patIter pat_last )
-/// \brief Searches the corpus for the pattern.
-/// 
-/// \param corpus_first The start of the data to search (Random Access Iterator)
-/// \param corpus_last  One past the end of the data to search
-/// \param pat_first    The start of the pattern to search for (Random Access Iterator)
-/// \param pat_last     One past the end of the data to search for
-///
-    template <typename patIter, typename corpusIter>
-    corpusIter boyer_moore_search ( 
-                  corpusIter corpus_first, corpusIter corpus_last, 
-                  patIter pat_first, patIter pat_last )
-    {
-        boyer_moore<patIter> bm ( pat_first, pat_last );
-        return bm ( corpus_first, corpus_last );
-    }
-
-    template <typename PatternRange, typename corpusIter>
-    corpusIter boyer_moore_search ( 
-        corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
-    {
-        typedef typename boost::range_iterator<PatternRange> pattern_iterator;
-        boyer_moore<pattern_iterator> bm ( boost::begin(pattern), boost::end (pattern));
-        return bm ( corpus_first, corpus_last );
-    }
-    
-    template <typename patIter, typename CorpusRange>
-    typename boost::lazy_disable_if_c<
-        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
-    ::type
-    boyer_moore_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
-    {
-        boyer_moore<patIter> bm ( pat_first, pat_last );
-        return bm (boost::begin (corpus), boost::end (corpus));
-    }
-    
-    template <typename PatternRange, typename CorpusRange>
-    typename boost::range_iterator<CorpusRange>::type
-    boyer_moore_search ( CorpusRange &corpus, const PatternRange &pattern )
-    {
-        typedef typename boost::range_iterator<PatternRange> pattern_iterator;
-        boyer_moore<pattern_iterator> bm ( boost::begin(pattern), boost::end (pattern));
-        return bm (boost::begin (corpus), boost::end (corpus));
-    }
-
-
-    //  Creator functions -- take a pattern range, return an object
-    template <typename Range>
-    boost::algorithm::boyer_moore<typename boost::range_iterator<const Range>::type>
-    make_boyer_moore ( const Range &r ) {
-        return boost::algorithm::boyer_moore
-            <typename boost::range_iterator<const Range>::type> (boost::begin(r), boost::end(r));
-        }
-    
-    template <typename Range>
-    boost::algorithm::boyer_moore<typename boost::range_iterator<Range>::type>
-    make_boyer_moore ( Range &r ) {
-        return boost::algorithm::boyer_moore
-            <typename boost::range_iterator<Range>::type> (boost::begin(r), boost::end(r));
-        }
-
-}}
-
-#endif  //  BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP

include/boost/algorithm/searching/boyer_moore_horspool.hpp

@@ -1,141 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#ifndef BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP
-#define BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP
-
-#include <iterator>     // for std::iterator_traits
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/algorithm/searching/detail/bm_traits.hpp>
-#include <boost/algorithm/searching/detail/debugging.hpp>
-
-// #define  BOOST_ALGORITHM_BOYER_MOORE_HORSPOOL_DEBUG_HPP
-
-namespace boost { namespace algorithm {
-
-/*
-    A templated version of the boyer-moore-horspool searching algorithm.
-    
-    Requirements:
-        * Random access iterators
-        * The two iterator types (patIter and corpusIter) must 
-            "point to" the same underlying type.
-        * Additional requirements may be imposed buy the skip table, such as:
-        ** Numeric type (array-based skip table)
-        ** Hashable type (map-based skip table)
-
-http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
-
-*/
-
-    template <typename patIter, typename traits = detail::BM_traits<patIter> >
-    class boyer_moore_horspool {
-        typedef typename std::iterator_traits<patIter>::difference_type difference_type;
-    public:
-        boyer_moore_horspool ( patIter first, patIter last ) 
-                : pat_first ( first ), pat_last ( last ),
-                  k_pattern_length ( std::distance ( pat_first, pat_last )),
-                  skip_ ( k_pattern_length, k_pattern_length ) {
-                  
-        //  Build the skip table
-            std::size_t i = 0;
-            if ( first != last )    // empty pattern?
-                for ( patIter iter = first; iter != last-1; ++iter, ++i )
-                    skip_.insert ( *iter, k_pattern_length - 1 - i );
-#ifdef BOOST_ALGORITHM_BOYER_MOORE_HORSPOOL_DEBUG_HPP
-            skip_.PrintSkipTable ();
-#endif
-            }
-            
-        ~boyer_moore_horspool () {}
-        
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        /// \param p            A predicate used for the search comparisons.
-        ///
-        template <typename corpusIter>
-        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
-            BOOST_STATIC_ASSERT (( boost::is_same<
-                typename std::iterator_traits<patIter>::value_type, 
-                typename std::iterator_traits<corpusIter>::value_type>::value ));
-
-            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
-            if (    pat_first ==    pat_last ) return corpus_first; // empty pattern matches at start
-
-            const difference_type k_corpus_length  = std::distance ( corpus_first, corpus_last );
-        //  If the pattern is larger than the corpus, we can't find it!
-            if ( k_corpus_length < k_pattern_length )
-                return corpus_last;
-    
-        //  Do the search 
-            return this->do_search ( corpus_first, corpus_last );
-            }
-            
-    private:
-/// \cond DOXYGEN_HIDE
-        patIter pat_first, pat_last;
-        const difference_type k_pattern_length;
-        typename traits::skip_table_t skip_;
-
-        /// \fn do_search ( corpusIter corpus_first, corpusIter corpus_last )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        /// \param k_corpus_length The length of the corpus to search
-        ///
-        template <typename corpusIter>
-        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
-            corpusIter curPos = corpus_first;
-            const corpusIter lastPos = corpus_last - k_pattern_length;
-            while ( curPos <= lastPos ) {
-            //  Do we match right where we are?
-                std::size_t j = k_pattern_length - 1;
-                while ( pat_first [j] == curPos [j] ) {
-                //  We matched - we're done!
-                    if ( j == 0 )
-                        return curPos;
-                    j--;
-                    }
-        
-                curPos += skip_ [ curPos [ k_pattern_length - 1 ]];
-                }
-            
-            return corpus_last;
-            }
-// \endcond
-        };
-
-/// \fn boyer_moore_horspool_search ( corpusIter corpus_first, corpusIter corpus_last, 
-///       patIter pat_first, patIter pat_last )
-/// \brief Searches the corpus for the pattern.
-/// 
-/// \param corpus_first The start of the data to search (Random Access Iterator)
-/// \param corpus_last  One past the end of the data to search
-/// \param pat_first    The start of the pattern to search for (Random Access Iterator)
-/// \param pat_last     One past the end of the data to search for
-///
-    template <typename patIter, typename corpusIter>
-    corpusIter boyer_moore_horspool_search ( 
-            corpusIter corpus_first, corpusIter corpus_last, 
-            patIter pat_first, patIter pat_last ) {
-        boyer_moore_horspool<patIter> bmh ( pat_first, pat_last );
-        return bmh ( corpus_first, corpus_last );
-        }
-
-}}
-
-#endif  //  BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP

include/boost/algorithm/searching/detail/bm_traits.hpp

@@ -1,105 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#ifndef BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP
-#define BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP
-
-#include <climits>      // for CHAR_BIT
-#include <vector>
-#include <iterator>     // for std::iterator_traits
-
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/array.hpp>
-#include <boost/tr1/tr1/unordered_map>
-
-#include <boost/algorithm/searching/detail/debugging.hpp>
-
-namespace boost { namespace algorithm { namespace detail {
-
-//
-//  Default implementations of the skip tables for B-M and B-M-H
-//
-    template<typename key_type, typename value_type, bool /*useArray*/> class skip_table;
-
-//  General case for data searching other than bytes; use a map
-    template<typename key_type, typename value_type>
-    class skip_table<key_type, value_type, false> {
-    private:
-        typedef std::tr1::unordered_map<key_type, value_type> skip_map;
-        const value_type k_default_value;
-        skip_map skip_;
-        
-    public:
-        skip_table ( std::size_t patSize, value_type default_value ) 
-            : k_default_value ( default_value ), skip_ ( patSize ) {}
-        
-        void insert ( key_type key, value_type val ) {
-            skip_ [ key ] = val;    // Would skip_.insert (val) be better here?
-            }
-
-        value_type operator [] ( key_type key ) const {
-            typename skip_map::const_iterator it = skip_.find ( key );
-            return it == skip_.end () ? k_default_value : it->second;
-            }
-            
-        void PrintSkipTable () const {
-            std::cout << "BM(H) Skip Table <unordered_map>:" << std::endl;
-            for ( typename skip_map::const_iterator it = skip_.begin (); it != skip_.end (); ++it )
-                if ( it->second != k_default_value )
-                    std::cout << "  " << it->first << ": " << it->second << std::endl;
-            std::cout << std::endl;
-            }
-        };
-        
-    
-//  Special case small numeric values; use an array
-    template<typename key_type, typename value_type>
-    class skip_table<key_type, value_type, true> {
-    private:
-        typedef typename boost::make_unsigned<key_type>::type unsigned_key_type;
-        typedef boost::array<value_type, 1U << (CHAR_BIT * sizeof(key_type))> skip_map;
-        skip_map skip_;
-        const value_type k_default_value;
-    public:
-        skip_table ( std::size_t patSize, value_type default_value ) : k_default_value ( default_value ) {
-            std::fill_n ( skip_.begin(), skip_.size(), default_value );
-            }
-        
-        void insert ( key_type key, value_type val ) {
-            skip_ [ static_cast<unsigned_key_type> ( key ) ] = val;
-            }
-
-        value_type operator [] ( key_type key ) const {
-            return skip_ [ static_cast<unsigned_key_type> ( key ) ];
-            }
-
-        void PrintSkipTable () const {
-            std::cout << "BM(H) Skip Table <boost:array>:" << std::endl;
-            for ( typename skip_map::const_iterator it = skip_.begin (); it != skip_.end (); ++it )
-                if ( *it != k_default_value )
-                    std::cout << "  " << std::distance (skip_.begin (), it) << ": " << *it << std::endl;
-            std::cout << std::endl;
-            }
-        };
-
-    template<typename Iterator>
-    struct BM_traits {
-        typedef typename std::iterator_traits<Iterator>::difference_type value_type;
-        typedef typename std::iterator_traits<Iterator>::value_type key_type;
-        typedef boost::algorithm::detail::skip_table<key_type, value_type, 
-                boost::is_integral<key_type>::value && (sizeof(key_type)==1)> skip_table_t;
-        };
-
-}}} // namespaces
-
-#endif  //  BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP

include/boost/algorithm/searching/detail/debugging.hpp

@@ -1,30 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#ifndef BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP
-#define BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP
-
-#include <iostream>
-/// \cond DOXYGEN_HIDE
-
-namespace boost { namespace algorithm { namespace detail {
-
-//  Debugging support
-    template <typename Iter>
-    void PrintTable ( Iter first, Iter last ) {
-        std::cout << std::distance ( first, last ) << ": { ";
-        for ( Iter iter = first; iter != last; ++iter )
-            std::cout << *iter << " ";
-        std::cout << "}" << std::endl;
-        }
-    
-}}}
-/// \endcond
-
-#endif  //  BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP

include/boost/algorithm/searching/knuth_morris_pratt.hpp

@@ -1,200 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2010-2012.
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-*/
-
-#ifndef BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP
-#define BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP
-
-#include <vector>
-#include <iterator>     // for std::iterator_traits
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/algorithm/searching/detail/debugging.hpp>
-
-// #define  BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_DEBUG
-
-namespace boost { namespace algorithm {
-
-// #define  NEW_KMP
-
-/*
-    A templated version of the Knuth-Morris-Pratt searching algorithm.
-    
-    Requirements:
-        * Random-access iterators
-        * The two iterator types (I1 and I2) must "point to" the same underlying type.
-
-    http://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm
-    http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm
-*/
-
-    template <typename patIter>
-    class knuth_morris_pratt {
-        typedef typename std::iterator_traits<patIter>::difference_type difference_type;
-    public:
-        knuth_morris_pratt ( patIter first, patIter last ) 
-                : pat_first ( first ), pat_last ( last ), 
-                  k_pattern_length ( std::distance ( pat_first, pat_last )),
-                  skip_ ( k_pattern_length + 1 ) {
-#ifdef NEW_KMP
-            preKmp ( pat_first, pat_last );
-#else
-            init_skip_table ( pat_first, pat_last );
-#endif
-#ifdef BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_DEBUG
-            detail::PrintTable ( skip_.begin (), skip_.end ());
-#endif
-            }
-            
-        ~knuth_morris_pratt () {}
-        
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        /// \param p            A predicate used for the search comparisons.
-        ///
-        template <typename corpusIter>
-        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
-            BOOST_STATIC_ASSERT (( boost::is_same<
-                typename std::iterator_traits<patIter>::value_type, 
-                typename std::iterator_traits<corpusIter>::value_type>::value ));
-            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
-            if ( pat_first == pat_last )       return corpus_first; // empty pattern matches at start
-
-            const difference_type k_corpus_length = std::distance ( corpus_first, corpus_last );
-        //  If the pattern is larger than the corpus, we can't find it!
-            if ( k_corpus_length < k_pattern_length ) 
-                return corpus_last;
-
-            return do_search   ( corpus_first, corpus_last, k_corpus_length );
-            }
-    
-    private:
-/// \cond DOXYGEN_HIDE
-        patIter pat_first, pat_last;
-        const difference_type k_pattern_length;
-        std::vector <difference_type> skip_;
-
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p )
-        /// \brief Searches the corpus for the pattern that was passed into the constructor
-        /// 
-        /// \param corpus_first The start of the data to search (Random Access Iterator)
-        /// \param corpus_last  One past the end of the data to search
-        /// \param p            A predicate used for the search comparisons.
-        ///
-        template <typename corpusIter>
-        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last, 
-                                                difference_type k_corpus_length ) const {
-            difference_type match_start = 0;  // position in the corpus that we're matching
-            
-#ifdef NEW_KMP
-            int patternIdx = 0;
-            while ( match_start < k_corpus_length ) {
-                while ( patternIdx > -1 && pat_first[patternIdx] != corpus_first [match_start] )
-                    patternIdx = skip_ [patternIdx]; //<--- Shifting the pattern on mismatch
-
-                patternIdx++;
-                match_start++; //<--- corpus is always increased by 1
-
-                if ( patternIdx >= (int) k_pattern_length )
-                    return corpus_first + match_start - patternIdx;
-                }
-            
-#else
-//  At this point, we know:
-//          k_pattern_length <= k_corpus_length
-//          for all elements of skip, it holds -1 .. k_pattern_length
-//      
-//          In the loop, we have the following invariants
-//              idx is in the range 0 .. k_pattern_length
-//              match_start is in the range 0 .. k_corpus_length - k_pattern_length + 1
-
-            const difference_type last_match = k_corpus_length - k_pattern_length;
-            difference_type idx = 0;          // position in the pattern we're comparing
-
-            while ( match_start <= last_match ) {
-                while ( pat_first [ idx ] == corpus_first [ match_start + idx ] ) {
-                    if ( ++idx == k_pattern_length )
-                        return corpus_first + match_start;
-                    }
-            //  Figure out where to start searching again
-           //   assert ( idx - skip_ [ idx ] > 0 ); // we're always moving forward
-                match_start += idx - skip_ [ idx ];
-                idx = skip_ [ idx ] >= 0 ? skip_ [ idx ] : 0;
-           //   assert ( idx >= 0 && idx < k_pattern_length );
-                }
-#endif
-                
-        //  We didn't find anything
-            return corpus_last;
-            }
-    
-
-        void preKmp ( patIter first, patIter last ) {
-           const /*std::size_t*/ int count = std::distance ( first, last );
-        
-           int i, j;
-        
-           i = 0;
-           j = skip_[0] = -1;
-           while (i < count) {
-              while (j > -1 && first[i] != first[j])
-                 j = skip_[j];
-              i++;
-              j++;
-              if (first[i] == first[j])
-                 skip_[i] = skip_[j];
-              else
-                 skip_[i] = j;
-           }
-        }
-
-
-        void init_skip_table ( patIter first, patIter last ) {
-            const difference_type count = std::distance ( first, last );
-    
-            int j;
-            skip_ [ 0 ] = -1;
-            for ( int i = 1; i <= count; ++i ) {
-                j = skip_ [ i - 1 ];
-                while ( j >= 0 ) {
-                    if ( first [ j ] == first [ i - 1 ] )
-                        break;
-                    j = skip_ [ j ];
-                    }
-                skip_ [ i ] = j + 1;
-                }
-            }
-// \endcond
-        };
-
-
-/// \fn knuth_morris_pratt_search ( corpusIter corpus_first, corpusIter corpus_last, 
-///       patIter pat_first, patIter pat_last )
-/// \brief Searches the corpus for the pattern.
-/// 
-/// \param corpus_first The start of the data to search (Random Access Iterator)
-/// \param corpus_last  One past the end of the data to search
-/// \param pat_first    The start of the pattern to search for (Random Access Iterator)
-/// \param pat_last     One past the end of the data to search for
-///
-    template <typename patIter, typename corpusIter>
-    corpusIter knuth_morris_pratt_search ( 
-            corpusIter corpus_first, corpusIter corpus_last, 
-            patIter pat_first, patIter pat_last ) {
-        knuth_morris_pratt<patIter> kmp ( pat_first, pat_last );
-        return kmp ( corpus_first, corpus_last );
-        }
-}}
-
-#endif  // BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP

include/boost/algorithm/string.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library string_algo.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2004.
+//  Copyright Pavol Droba 2002-2004. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ALGO_HPP
 #define BOOST_STRING_ALGO_HPP
@@ -21,7 +20,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/find.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/classification.hpp>

include/boost/algorithm/string/case_conv.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library case_conv.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CASE_CONV_HPP
 #define BOOST_STRING_CASE_CONV_HPP
@@ -16,7 +15,6 @@
 #include <locale>
 #include <boost/iterator/transform_iterator.hpp>
 
-#include <boost/range/as_literal.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
@@ -57,10 +55,11 @@ namespace boost {
             const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::detail::transform_range_copy( 
+            return std::transform( 
-               Output,
+                begin(Input), 
-               ::boost::as_literal(Input),
+                end(Input), 
-               ::boost::algorithm::detail::to_lowerF<
+                Output,
+                ::boost::algorithm::detail::to_lowerF<
                     typename range_value<RangeT>::type >(Loc));
         }
 
@@ -73,10 +72,15 @@ namespace boost {
             const SequenceT& Input, 
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+            return SequenceT(
-                Input,
+                make_transform_iterator(
-                ::boost::algorithm::detail::to_lowerF<
+                    begin(Input),
-                    typename range_value<SequenceT>::type >(Loc));
+                    ::boost::algorithm::detail::to_lowerF<
+                        typename range_value<SequenceT>::type >(Loc)),
+                make_transform_iterator(
+                    end(Input), 
+                    ::boost::algorithm::detail::to_lowerF<
+                        typename range_value<SequenceT>::type >(Loc)));
         }
 
         //! Convert to lower case
@@ -92,8 +96,10 @@ namespace boost {
             WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::detail::transform_range(
+            std::transform( 
-                ::boost::as_literal(Input),
+                begin(Input), 
+                end(Input), 
+                begin(Input), 
                 ::boost::algorithm::detail::to_lowerF<
                     typename range_value<WritableRangeT>::type >(Loc));
         }
@@ -122,10 +128,11 @@ namespace boost {
             const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::detail::transform_range_copy( 
+            return std::transform( 
-               Output,
+                begin(Input), 
-               ::boost::as_literal(Input),
+                end(Input), 
-               ::boost::algorithm::detail::to_upperF<
+                Output,
+                ::boost::algorithm::detail::to_upperF<
                     typename range_value<RangeT>::type >(Loc));
         }
 
@@ -138,10 +145,16 @@ namespace boost {
             const SequenceT& Input, 
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+            return SequenceT(
-                Input,
+                make_transform_iterator(
-                ::boost::algorithm::detail::to_upperF<
+                    begin(Input),
-                    typename range_value<SequenceT>::type >(Loc));
+                    ::boost::algorithm::detail::to_upperF<
+                        typename range_value<SequenceT>::type >(Loc)),
+                make_transform_iterator(
+                    end(Input), 
+                    ::boost::algorithm::detail::to_upperF<
+                        typename range_value<SequenceT>::type >(Loc)));
+
         }
 
         //! Convert to upper case
@@ -157,8 +170,10 @@ namespace boost {
             WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::detail::transform_range(
+            std::transform( 
-                ::boost::as_literal(Input),
+                begin(Input), 
+                end(Input), 
+                begin(Input), 
                 ::boost::algorithm::detail::to_upperF<
                     typename range_value<WritableRangeT>::type >(Loc));
         }

include/boost/algorithm/string/classification.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library classification.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CLASSIFICATION_HPP
 #define BOOST_STRING_CLASSIFICATION_HPP
@@ -14,11 +13,9 @@
 #include <algorithm>
 #include <locale>
 #include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.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 
     some more convenience when using algorithms like \c trim() and \c all(). 
@@ -202,8 +199,8 @@ namespace boost {
             BOOST_STRING_TYPENAME range_value<RangeT>::type> 
         is_any_of( const RangeT& Set )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
+            return detail::is_any_ofF<
-            return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); 
+                BOOST_STRING_TYPENAME range_value<RangeT>::type>(Set); 
         }
 
         //! is_from_range predicate

include/boost/algorithm/string/compare.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library compare.hpp header file  -------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_COMPARE_HPP
 #define BOOST_STRING_COMPARE_HPP
@@ -38,7 +37,7 @@ namespace boost {
                 Compare two operands for equality
             */
             template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+                bool operator ()( const T1& Arg1, const T2& Arg2 ) const
             {
                 return Arg1==Arg2;
             }
@@ -63,12 +62,12 @@ namespace boost {
                 Compare two operands. Case is ignored.
             */
             template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
+                bool operator ()( const T1& Arg1, const T2& Arg2 ) const
             {
                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)==std::toupper(Arg2);
                 #else
-                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
+                    return std::toupper(Arg1,m_Loc)==std::toupper(Arg2,m_Loc);
                 #endif
             }
 
@@ -76,122 +75,11 @@ namespace boost {
             std::locale m_Loc;
         };
 
-        //  is_less functor  -----------------------------------------------//
-
-        //! is_less functor
-        /*!
-            Convenient version of standard std::less. Operation is templated, therefore it is 
-            not required to specify the exact types upon the construction
-         */
-        struct is_less
-        {
-            //! Functor operation
-            /*!
-                Compare two operands using > operator
-             */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                return Arg1<Arg2;
-            }
-        };
-
-
-        //! case insensitive version of is_less
-        /*!
-            Case insensitive comparison predicate. Comparison is done using
-            specified locales.
-        */
-        struct is_iless
-        {
-            //! Constructor
-            /*!
-                \param Loc locales used for comparison
-            */
-            is_iless( const std::locale& Loc=std::locale() ) :
-                m_Loc( Loc ) {}
-
-            //! Function operator
-            /*!
-                Compare two operands. Case is ignored.
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                    return std::toupper(Arg1)<std::toupper(Arg2);
-                #else
-                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
-                #endif
-            }
-
-        private:
-            std::locale m_Loc;
-        };
-
-        //  is_not_greater functor  -----------------------------------------------//
-
-        //! is_not_greater functor
-        /*!
-            Convenient version of standard std::not_greater_to. Operation is templated, therefore it is 
-            not required to specify the exact types upon the construction
-         */
-        struct is_not_greater
-        {
-            //! Functor operation
-            /*!
-                Compare two operands using > operator
-             */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                return Arg1<=Arg2;
-            }
-        };
-
-
-        //! case insensitive version of is_not_greater
-        /*!
-            Case insensitive comparison predicate. Comparison is done using
-            specified locales.
-        */
-        struct is_not_igreater
-        {
-            //! Constructor
-            /*!
-                \param Loc locales used for comparison
-            */
-            is_not_igreater( const std::locale& Loc=std::locale() ) :
-                m_Loc( Loc ) {}
-
-            //! Function operator
-            /*!
-                Compare two operands. Case is ignored.
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                    return std::toupper(Arg1)<=std::toupper(Arg2);
-                #else
-                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
-                #endif
-            }
-
-        private:
-            std::locale m_Loc;
-        };
-
-
     } // namespace algorithm
 
     // pull names to the boost namespace
     using algorithm::is_equal;
     using algorithm::is_iequal;
-    using algorithm::is_less;
-    using algorithm::is_iless;
-    using algorithm::is_not_greater;
-    using algorithm::is_not_igreater;
 
 } // namespace boost
 

include/boost/algorithm/string/concept.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library concept.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CONCEPT_HPP
 #define BOOST_STRING_CONCEPT_HPP
@@ -65,8 +64,8 @@ namespace boost {
             void constraints()
             {
                 // Operation
-                ::boost::begin((*pFo)( (*pF)(i,i) ));
+                begin((*pFo)( (*pF)(i,i) ));
-                ::boost::end((*pFo)( (*pF)(i,i) ));
+                end((*pFo)( (*pF)(i,i) ));
             }
         private:
             IteratorT i;

include/boost/algorithm/string/config.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library config.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CONFIG_HPP
 #define BOOST_STRING_CONFIG_HPP

include/boost/algorithm/string/constants.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library constants.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CONSTANTS_HPP
 #define BOOST_STRING_CONSTANTS_HPP

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library string_funct.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CASE_CONV_DETAIL_HPP
 #define BOOST_STRING_CASE_CONV_DETAIL_HPP
@@ -15,37 +14,30 @@
 #include <locale>
 #include <functional>
 
-#include <boost/type_traits/make_unsigned.hpp>
-
 namespace boost {
     namespace algorithm {
         namespace detail {
 
 //  case conversion functors -----------------------------------------------//
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
             // a tolower functor
             template<typename CharT>
             struct to_lowerF : public std::unary_function<CharT, CharT>
             {
                 // Constructor
-                to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
+                to_lowerF( const std::locale& Loc ) : m_Loc( Loc ) {}
 
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
+                        return std::tolower( Ch);
                     #else
-                        return std::tolower<CharT>( Ch, *m_Loc );
+                        return std::tolower( Ch, m_Loc );
                     #endif
                 }
             private:
-                const std::locale* m_Loc;
+                const std::locale& m_Loc;
             };
 
             // a toupper functor
@@ -53,68 +45,21 @@ namespace boost {
             struct to_upperF : public std::unary_function<CharT, CharT>
             {
                 // Constructor
-                to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
+                to_upperF( const std::locale& Loc ) : m_Loc( Loc ) {}
 
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
+                        return std::toupper( Ch);
                     #else
-                        return std::toupper<CharT>( Ch, *m_Loc );
+                        return std::toupper( Ch, m_Loc );
                     #endif
                 }
             private:
-                const std::locale* m_Loc;
+                const std::locale& m_Loc;
             };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-// algorithm implementation -------------------------------------------------------------------------
-
-            // Transform a range
-            template<typename OutputIteratorT, typename RangeT, typename FunctorT>
-            OutputIteratorT transform_range_copy(
-                OutputIteratorT Output,
-                const RangeT& Input,
-                FunctorT Functor)
-            {
-                return std::transform( 
-                    ::boost::begin(Input), 
-                    ::boost::end(Input), 
-                    Output,
-                    Functor);
-            }
-
-            // Transform a range (in-place)
-            template<typename RangeT, typename FunctorT>
-            void transform_range(
-                const RangeT& Input,
-                FunctorT Functor)
-            {
-                std::transform( 
-                    ::boost::begin(Input), 
-                    ::boost::end(Input), 
-                    ::boost::begin(Input),
-                    Functor);
-            }
-
-            template<typename SequenceT, typename RangeT, typename FunctorT>
-            inline SequenceT transform_range_copy( 
-                const RangeT& Input, 
-                FunctorT Functor)
-            {
-                return SequenceT(
-                    ::boost::make_transform_iterator(
-                        ::boost::begin(Input),
-                        Functor),
-                    ::boost::make_transform_iterator(
-                        ::boost::end(Input), 
-                        Functor));
-            }
-
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library classification.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-// 
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
 #define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
@@ -15,6 +14,7 @@
 #include <algorithm>
 #include <functional>
 #include <locale>
+#include <set>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -28,16 +28,17 @@ namespace boost {
 
 //  classification functors -----------------------------------------------//
 
-   // is_classified functor
+            // is_classified functor
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
             {
-                // Boost.ResultOf support
+                // Boost.Lambda support
-                typedef bool result_type;
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor from a locale
                 is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                     m_Type(Type), m_Locale(Loc) {}
+
                 // Operation
                 template<typename CharT>
                 bool operator()( CharT Ch ) const
@@ -45,7 +46,7 @@ namespace boost {
                     return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                 }
 
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                     template<>
                     bool operator()( char const Ch ) const
                     {
@@ -54,11 +55,10 @@ namespace boost {
                 #endif
 
             private:
-                std::ctype_base::mask m_Type;
+                const std::ctype_base::mask m_Type;
-                std::locale m_Locale;
+                const std::locale m_Locale;
             };
 
-
             // is_any_of functor
             /*
                 returns true if the value is from the specified set
@@ -67,181 +67,25 @@ namespace boost {
             struct is_any_ofF :
                 public predicate_facade<is_any_ofF<CharT> >
             {
-            private:
+                // Boost.Lambda support
-                // set cannot operate on const value-type
+                template <class Args> struct sig { typedef bool type; };
-                typedef typename ::boost::remove_const<CharT>::type set_value_type;
-
-            public:     
-                // Boost.ResultOf support
-                typedef bool result_type;
 
                 // Constructor
                 template<typename RangeT>
-                is_any_ofF( const RangeT& Range ) : m_Size(0)
+                is_any_ofF( const RangeT& Range ) :
-                {
+                    m_Set( begin(Range), end(Range) ) {}
-                    // Prepare storage
-                    m_Storage.m_dynSet=0;
-
-                    std::size_t Size=::boost::distance(Range);
-                    m_Size=Size;
-                    set_value_type* Storage=0;
-
-                    if(use_fixed_storage(m_Size))
-                    {
-                        // Use fixed storage
-                        Storage=&m_Storage.m_fixSet[0];
-                    }
-                    else
-                    {
-                        // Use dynamic storage
-                        m_Storage.m_dynSet=new set_value_type[m_Size];
-                        Storage=m_Storage.m_dynSet;
-                    }
-
-                    // Use fixed storage
-                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
-                    ::std::sort(Storage, Storage+m_Size);
-                }
-
-                // Copy constructor
-                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
-                {
-                    // Prepare storage
-                    m_Storage.m_dynSet=0;               
-                    const set_value_type* SrcStorage=0;
-                    set_value_type* DestStorage=0;
-
-                    if(use_fixed_storage(m_Size))
-                    {
-                        // Use fixed storage
-                        DestStorage=&m_Storage.m_fixSet[0];
-                        SrcStorage=&Other.m_Storage.m_fixSet[0];
-                    }
-                    else
-                    {
-                        // Use dynamic storage
-                        m_Storage.m_dynSet=new set_value_type[m_Size];
-                        DestStorage=m_Storage.m_dynSet;
-                        SrcStorage=Other.m_Storage.m_dynSet;
-                    }
-
-                    // Use fixed storage
-                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-                }
-
-                // Destructor
-                ~is_any_ofF()
-                {
-                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
-                    {
-                        delete [] m_Storage.m_dynSet;
-                    }
-                }
-
-                // Assignment
-                is_any_ofF& operator=(const is_any_ofF& Other)
-                {
-                    // Handle self assignment
-                    if(this==&Other) return *this;
-
-                    // Prepare storage             
-                    const set_value_type* SrcStorage;
-                    set_value_type* DestStorage;
-
-                    if(use_fixed_storage(Other.m_Size))
-                    {
-                        // Use fixed storage
-                        DestStorage=&m_Storage.m_fixSet[0];
-                        SrcStorage=&Other.m_Storage.m_fixSet[0];
-
-                        // Delete old storage if was present
-                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
-                        {
-                            delete [] m_Storage.m_dynSet;
-                        }
-
-                        // Set new size
-                        m_Size=Other.m_Size;
-                    }
-                    else
-                    {
-                        // Other uses dynamic storage
-                        SrcStorage=Other.m_Storage.m_dynSet;
-
-                        // Check what kind of storage are we using right now
-                        if(use_fixed_storage(m_Size))
-                        {
-                            // Using fixed storage, allocate new
-                            set_value_type* pTemp=new set_value_type[Other.m_Size];
-                            DestStorage=pTemp;
-                            m_Storage.m_dynSet=pTemp;
-                            m_Size=Other.m_Size;
-                        }
-                        else
-                        {
-                            // Using dynamic storage, check if can reuse
-                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
-                            {
-                                // Reuse the current storage
-                                DestStorage=m_Storage.m_dynSet;
-                                m_Size=Other.m_Size;
-                            }
-                            else
-                            {
-                                // Allocate the new one
-                                set_value_type* pTemp=new set_value_type[Other.m_Size];
-                                DestStorage=pTemp;
-                        
-                                // Delete old storage if necessary
-                                if(m_Storage.m_dynSet!=0)
-                                {
-                                    delete [] m_Storage.m_dynSet;
-                                }
-                                // Store the new storage
-                                m_Storage.m_dynSet=pTemp;
-                                // Set new size
-                                m_Size=Other.m_Size;
-                            }
-                        }
-                    }
-
-                    // Copy the data
-                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-
-                    return *this;
-                }
 
                 // Operation
                 template<typename Char2T>
                 bool operator()( Char2T Ch ) const
                 {
-                    const set_value_type* Storage=
+                    return m_Set.find(Ch)!=m_Set.end();
-                        (use_fixed_storage(m_Size))
-                        ? &m_Storage.m_fixSet[0]
-                        : m_Storage.m_dynSet;
-
-                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
-                }
-            private:
-                // check if the size is eligible for fixed storage
-                static bool use_fixed_storage(std::size_t size)
-                {
-                    return size<=sizeof(set_value_type*)*2;
                 }
 
-
             private:
-                // storage
+                // set cannot operate on const value-type
-                // The actual used storage is selected on the type
+                typedef typename remove_const<CharT>::type set_value_type;
-                union
+                std::set<set_value_type> m_Set;
-                {
-                    set_value_type* m_dynSet;
-                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
-                } 
-                m_Storage;
-        
-                // storage size
-                ::std::size_t m_Size;
             };
 
             // is_from_range functor
@@ -253,8 +97,8 @@ namespace boost {
             struct is_from_rangeF :
                 public predicate_facade< is_from_rangeF<CharT> >
             {
-                // Boost.ResultOf support
+                // Boost.Lambda support
-                typedef bool result_type;
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
@@ -278,8 +122,8 @@ namespace boost {
             {
             public:
 
-                // Boost.ResultOf support
+                // Boost.Lambda support
-                typedef bool result_type;
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -303,8 +147,8 @@ namespace boost {
                 public predicate_facade< pred_orF<Pred1T,Pred2T> >
             {
             public:
-                // Boost.ResultOf support
+                // Boost.Lambda support
-                typedef bool result_type;
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -328,8 +172,8 @@ namespace boost {
                 public predicate_facade< pred_notF<PredT> >
             {
             public:
-                // Boost.ResultOf support
+                // Boost.Lambda support
-                typedef bool result_type;
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_notF( PredT Pred ) : m_Pred(Pred) {}

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_format.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-// 
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_FORMAT_DETAIL_HPP
 #define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
@@ -24,15 +23,39 @@ namespace boost {
 
 // find_format_copy (iterator variant) implementation -------------------------------//
 
-           template< 
+            template< 
                 typename OutputIteratorT,
                 typename InputT,
+                typename FinderT,
+                typename FormatterT,
+                typename FindResultT >
+            inline OutputIteratorT find_format_copy_impl(
+                OutputIteratorT Output,
+                const InputT& Input,
+                FinderT Finder,
+                FormatterT Formatter,
+                const FindResultT& FindResult )
+            {       
+                return find_format_copy_impl2( 
+                    Output,
+                    Input,
+                    Finder,
+                    Formatter,
+                    FindResult,
+                    Formatter(FindResult) );
+            }
+
+            template< 
+                typename OutputIteratorT,
+                typename InputT,
+                typename FinderT,
                 typename FormatterT,
                 typename FindResultT,
                 typename FormatResultT >
             inline OutputIteratorT find_format_copy_impl2(
                 OutputIteratorT Output,
                 const InputT& Input,
+                FinderT Finder,
                 FormatterT Formatter,
                 const FindResultT& FindResult,
                 const FormatResultT& FormatResult )
@@ -49,54 +72,51 @@ namespace boost {
                 if ( !M )
                 {
                     // Match not found - return original sequence
-                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
+                    std::copy( begin(Input), end(Input), Output );
                     return Output;
                 }
 
                 // Copy the beginning of the sequence
-                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
+                std::copy( begin(Input), begin(M), Output );
                 // Format find result
                 // Copy formated result
-                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+                std::copy( begin(M.format_result()), end(M.format_result()), Output );
                 // Copy the rest of the sequence
-                Output = std::copy( M.end(), ::boost::end(Input), Output );
+                std::copy( M.end(), end(Input), Output );
 
                 return Output;
             }
 
-            template< 
-                typename OutputIteratorT,
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT >
-            inline OutputIteratorT find_format_copy_impl(
-                OutputIteratorT Output,
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult )
-            {   
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_copy_impl2( 
-                        Output,
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-                }
-            }
-
- 
 // find_format_copy implementation --------------------------------------------------//
 
-           template< 
+            template< 
                 typename InputT, 
+                typename FinderT,
+                typename FormatterT,
+                typename FindResultT >
+            inline InputT find_format_copy_impl(
+                const InputT& Input,
+                FinderT Finder,
+                FormatterT Formatter,
+                const FindResultT& FindResult)
+            {
+                return find_format_copy_impl2(
+                    Input,
+                    Finder,
+                    Formatter,
+                    FindResult,
+                    Formatter(FindResult) );
+            }
+
+            template< 
+                typename InputT, 
+                typename FinderT,
                 typename FormatterT,
                 typename FindResultT,
                 typename FormatResultT >
             inline InputT find_format_copy_impl2(
                 const InputT& Input,
+                FinderT Finder,
                 FormatterT Formatter,
                 const FindResultT& FindResult,
                 const FormatResultT& FormatResult)
@@ -118,44 +138,45 @@ namespace boost {
 
                 InputT Output;
                 // Copy the beginning of the sequence
-                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
+                insert( Output, end(Output), begin(Input), M.begin() );
                 // Copy formated result
-                insert( Output, ::boost::end(Output), M.format_result() );
+                insert( Output, end(Output), M.format_result() );
                 // Copy the rest of the sequence
-                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
+                insert( Output, end(Output), M.end(), end(Input) );
 
                 return Output;
             }
 
-            template< 
+// replace implementation ----------------------------------------------------//
-                typename InputT, 
-                typename FormatterT,
-                typename FindResultT >
-            inline InputT find_format_copy_impl(
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_copy_impl2(
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return Input;
-                }
-            }
-
- // replace implementation ----------------------------------------------------//
         
             template<
                 typename InputT,
+                typename FinderT,
+                typename FormatterT,
+                typename FindResultT >
+            inline void find_format_impl( 
+                InputT& Input,
+                FinderT Finder,
+                FormatterT Formatter,
+                const FindResultT& FindResult)
+            {
+                find_format_impl2(
+                    Input,
+                    Finder,
+                    Formatter,
+                    FindResult,
+                    Formatter(FindResult) );
+            }
+
+            template<
+                typename InputT,
+                typename FinderT,
                 typename FormatterT,
                 typename FindResultT,
                 typename FormatResultT >
             inline void find_format_impl2( 
                 InputT& Input,
+                FinderT,
                 FormatterT Formatter,
                 const FindResultT& FindResult,
                 const FormatResultT& FormatResult)
@@ -176,25 +197,7 @@ namespace boost {
                 }
 
                 // Replace match
-                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
+                replace( Input, M.begin(), M.end(), M.format_result() );
-            }
-
-            template<
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT >
-            inline void find_format_impl( 
-                InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    ::boost::algorithm::detail::find_format_impl2(
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                }
             }
 
         } // namespace detail

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_format_all.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
 #define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
@@ -24,7 +23,29 @@ namespace boost {
 
 // find_format_all_copy (iterator variant) implementation ---------------------------//
 
-           template< 
+            template< 
+                typename OutputIteratorT,
+                typename InputT,
+                typename FinderT,
+                typename FormatterT,
+                typename FindResultT >
+            inline OutputIteratorT find_format_all_copy_impl(
+                OutputIteratorT Output,
+                const InputT& Input,
+                FinderT Finder,
+                FormatterT Formatter,
+                const FindResultT& FindResult )
+            {       
+                return find_format_all_copy_impl2( 
+                    Output,
+                    Input,
+                    Finder,
+                    Formatter,
+                    FindResult,
+                    Formatter(FindResult) );
+            }
+
+            template< 
                 typename OutputIteratorT,
                 typename InputT,
                 typename FinderT,
@@ -51,56 +72,49 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=::boost::begin(Input);
+                input_iterator_type LastMatch=begin(Input);
 
                 // Iterate through all matches
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    Output = std::copy( LastMatch, M.begin(), Output );
+                    std::copy( LastMatch, M.begin(), Output );
                     // Copy formated result
-                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+                    std::copy( begin(M.format_result()), end(M.format_result()), Output );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, ::boost::end(Input) );
+                    M=Finder( LastMatch, end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                Output = std::copy( LastMatch, ::boost::end(Input), Output );
+                std::copy( LastMatch, end(Input), Output );
 
                 return Output;
             }
 
+// find_format_all_copy implementation ----------------------------------------------//
+
             template< 
-                typename OutputIteratorT,
+                typename InputT, 
-                typename InputT,
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline OutputIteratorT find_format_all_copy_impl(
+            inline InputT find_format_all_copy_impl(
-                OutputIteratorT Output,
                 const InputT& Input,
                 FinderT Finder,
                 FormatterT Formatter,
-                const FindResultT& FindResult )
+                const FindResultT& FindResult)
-            {   
+            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
+                return find_format_all_copy_impl2(
-                    return ::boost::algorithm::detail::find_format_all_copy_impl2( 
+                    Input,
-                        Output,
+                    Finder,
-                        Input,
+                    Formatter,
-                        Finder,
+                    FindResult,
-                        Formatter,
+                    Formatter(FindResult) );
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-                }
             }
 
- // find_format_all_copy implementation ----------------------------------------------//
+            template< 
-
-           template< 
                 typename InputT, 
                 typename FinderT,
                 typename FormatterT,
@@ -125,7 +139,7 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=::boost::begin(Input);
+                input_iterator_type LastMatch=begin(Input);
 
                 // Output temporary
                 InputT Output;
@@ -134,46 +148,42 @@ namespace boost {
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    insert( Output, ::boost::end(Output), LastMatch, M.begin() );
+                    insert( Output, end(Output), LastMatch, M.begin() );
                     // Copy formated result
-                    insert( Output, ::boost::end(Output), M.format_result() );
+                    insert( Output, end(Output), M.format_result() );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, ::boost::end(Input) );
+                    M=Finder( LastMatch, end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
+                insert( Output, end(Output), LastMatch, end(Input) );
 
                 return Output;
             }
 
-            template< 
+// find_format_all implementation ------------------------------------------------//
-                typename InputT, 
+        
+            template<
+                typename InputT,
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline InputT find_format_all_copy_impl(
+            inline void find_format_all_impl( 
-                const InputT& Input,
+                InputT& Input,
                 FinderT Finder,
                 FormatterT Formatter,
-                const FindResultT& FindResult)
+                FindResultT FindResult)
             {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
+                find_format_all_impl2(
-                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
+                    Input,
-                        Input,
+                    Finder,
-                        Finder,
+                    Formatter,
-                        Formatter,
+                    FindResult,
-                        FindResult,
+                    Formatter(FindResult) );
-                        Formatter(FindResult) );
-                } else {
-                    return Input;
-                }
             }
 
- // find_format_all implementation ------------------------------------------------//
-        
             template<
                 typename InputT,
                 typename FinderT,
@@ -202,8 +212,8 @@ namespace boost {
                     BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
 
                 // Initialize replacement iterators
-                input_iterator_type InsertIt=::boost::begin(Input);
+                input_iterator_type InsertIt=begin(Input);
-                input_iterator_type SearchIt=::boost::begin(Input);
+                input_iterator_type SearchIt=begin(Input);
                 
                 while( M )
                 {
@@ -219,50 +229,29 @@ namespace boost {
                     SearchIt=M.end();
 
                     // Copy formated replace to the storage
-                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
+                    copy_to_storage( Storage, M.format_result() );
 
                     // Find range for a next match
-                    M=Finder( SearchIt, ::boost::end(Input) );
+                    M=Finder( SearchIt, end(Input) );
                 }
 
                 // process the last segment
-                InsertIt=::boost::algorithm::detail::process_segment( 
+                InsertIt=process_segment( 
                     Storage,
                     Input,
                     InsertIt,
                     SearchIt,
-                    ::boost::end(Input) );
+                    end(Input) );
                 
                 if ( Storage.empty() )
                 {
                     // Truncate input
-                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
+                    erase( Input, InsertIt, end(Input) );
                 }
                 else
                 {
                     // Copy remaining data to the end of input
-                    ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
+                    insert( Input, end(Input), Storage.begin(), Storage.end() );
-                }
-            }
-
-            template<
-                typename InputT,
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT >
-            inline void find_format_all_impl( 
-                InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                FindResultT FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    ::boost::algorithm::detail::find_format_all_impl2(
-                        Input,
-                        Finder,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
                 }
             }
 

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_format_store.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
 #define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
@@ -20,10 +19,6 @@ namespace boost {
 
 //  temporary format and find result storage --------------------------------//
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
             template< 
                 typename ForwardIteratorT,
                 typename FormatterT,
@@ -52,9 +47,7 @@ namespace boost {
                 find_format_store& operator=( FindResultT FindResult )
                 {
                     iterator_range<ForwardIteratorT>::operator=(FindResult);
-                    if( !this->empty() ) {
+                    m_FormatResult=m_Formatter(FindResult);
-                        m_FormatResult=m_Formatter(FindResult);
-                    }
                     
                     return *this;
                 }
@@ -70,18 +63,6 @@ namespace boost {
                 const formatter_type& m_Formatter;
             };
 
-            template<typename InputT, typename FindResultT>
-            bool check_find_result(InputT&, FindResultT& FindResult)
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    range_const_iterator<InputT>::type input_iterator_type; 
-                iterator_range<input_iterator_type> ResultRange(FindResult);
-                return !ResultRange.empty();
-            }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_iterator.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
 #define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library finder.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FINDER_DETAIL_HPP
 #define BOOST_STRING_FINDER_DETAIL_HPP
@@ -19,7 +18,6 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/empty.hpp>
-#include <boost/range/as_literal.hpp>
 
 namespace boost {
     namespace algorithm {
@@ -41,7 +39,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 first_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
+                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
                 first_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -92,7 +90,7 @@ namespace boost {
 
 //  find last functor -----------------------------------------------//
 
-            // find the last match a subseqeunce in the sequence ( functor )
+            // find the last match a subsequnce in the sequence ( functor )
             /*
                 Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, returns <End,End>
@@ -108,7 +106,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 last_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
+                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
                 last_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -154,7 +152,7 @@ namespace boost {
                     while( M )
                     {
                         Last=M;
-                        M=first_finder( ::boost::end(M), End );
+                        M=first_finder( end(M), End );
                     }
 
                     return Last;
@@ -202,7 +200,7 @@ namespace boost {
 
 //  find n-th functor -----------------------------------------------//
 
-            // find the n-th match of a subsequence in the sequence ( functor )
+            // find the n-th match of a subsequnce in the sequence ( functor )
             /*
                 Returns a pair <begin,end> marking the subsequence in the sequence.
                 If the find fails, returns <End,End>
@@ -214,23 +212,20 @@ namespace boost {
                 typedef first_finderF<
                     search_iterator_type,
                     PredicateT> first_finder_type;
-                typedef last_finderF<
-                    search_iterator_type,
-                    PredicateT> last_finder_type;
 
                 // Construction
                 template< typename SearchT >
                 nth_finderF(
                         const SearchT& Search,
-                        int Nth,
+                        unsigned int Nth,
                         PredicateT Comp) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)),
+                    m_Search(begin(Search), end(Search)),
                     m_Nth(Nth),
                     m_Comp(Comp) {}
                 nth_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
-                        int Nth,
+                        unsigned int Nth,
                         PredicateT Comp) :
                     m_Search(SearchBegin, SearchEnd),
                     m_Nth(Nth),
@@ -242,26 +237,6 @@ namespace boost {
                 operator()(
                     ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
-                {
-                    if(m_Nth>=0)
-                    {
-                        return find_forward(Begin, End, m_Nth);
-                    }
-                    else
-                    {
-                        return find_backward(Begin, End, -m_Nth);
-                    }
-
-                }
-
-            private:
-                // Implementation helpers
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                find_forward(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    unsigned int N) const
                 {
                     typedef ForwardIteratorT input_iterator_type;
                     typedef iterator_range<ForwardIteratorT> result_type;
@@ -270,16 +245,16 @@ namespace boost {
                     if( boost::empty(m_Search) )
                         return result_type( End, End );
 
-                    // Instantiate find functor
+                    // 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<=N; ++n )
+                    for( unsigned int n=0; n<=m_Nth; ++n )
                     {
                         // find next match
-                        M=first_finder( ::boost::end(M), End );
+                        M=first_finder( end(M), End );
 
                         if ( !M )
                         {
@@ -291,179 +266,14 @@ namespace boost {
                     return M;
                 }
 
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                find_backward(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    unsigned int N) const
-                {
-                    typedef ForwardIteratorT input_iterator_type;
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    // Sanity check
-                    if( boost::empty(m_Search) )
-                        return result_type( End, End );
-
-                    // Instantiate find functor
-                    last_finder_type last_finder(
-                        m_Search.begin(), m_Search.end(), m_Comp );
-
-                    result_type M( End, End );
-
-                    for( unsigned int n=1; n<=N; ++n )
-                    {
-                        // find next match
-                        M=last_finder( Begin, ::boost::begin(M) );
-
-                        if ( !M )
-                        {
-                            // Subsequence not found, return
-                            return M;
-                        }
-                    }
-
-                    return M;
-                }
-
-
             private:
                 iterator_range<search_iterator_type> m_Search;
-                int m_Nth;
+                unsigned int m_Nth;
                 PredicateT m_Comp;
             };
 
-//  find head/tail implementation helpers ---------------------------//
-
-            template<typename ForwardIteratorT>
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::forward_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                input_iterator_type It=Begin;
-                for(
-                    unsigned int Index=0;
-                    Index<N && It!=End; ++Index,++It ) {};
-
-                return result_type( Begin, It );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::random_access_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
-                    return result_type( Begin, End );
-
-                return result_type(Begin,Begin+N);
-            }
-
-            // Find head implementation
-            template<typename ForwardIteratorT>
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::forward_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                unsigned int Index=0;
-                input_iterator_type It=Begin;
-                input_iterator_type It2=Begin;
-
-                // Advance It2 by N increments
-                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
-
-                // Advance It, It2 to the end
-                for(; It2!=End; ++It,++It2 ) {};
-
-                return result_type( It, It2 );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::bidirectional_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                input_iterator_type It=End;
-                for(
-                    unsigned int Index=0;
-                    Index<N && It!=Begin; ++Index,--It ) {};
-
-                return result_type( It, End );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::random_access_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
-                    return result_type( Begin, End );
-
-                return result_type( End-N, End );
-            }
-
-                        // Operation
-            template< typename ForwardIteratorT >
-            iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
-            }
-
-
-
 //  find head functor -----------------------------------------------//
 
-
             // find a head in the sequence ( functor )
             /*
                 This functor find a head of the specified range. For
@@ -473,7 +283,7 @@ namespace boost {
             struct head_finderF
             {
                 // Construction
-                head_finderF( int N ) : m_N(N) {}
+                head_finderF( unsigned int N ) : m_N(N) {}
 
                 // Operation
                 template< typename ForwardIteratorT >
@@ -482,26 +292,54 @@ namespace boost {
                     ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
-                    if(m_N>=0)
+                    typedef BOOST_STRING_TYPENAME boost::detail::
-                    {
+                        iterator_traits<ForwardIteratorT>::iterator_category category;
-                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
-                    }
-                    else
-                    {
-                        iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
 
-                        return ::boost::make_iterator_range(Begin, Res.begin());
+                    return findit( Begin, End, category() );
-                    }
                 }
 
             private:
-                int m_N;
+                // Find operation implementation
+                template< typename ForwardIteratorT >
+                    iterator_range<ForwardIteratorT>
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
+                    std::forward_iterator_tag ) const
+                {
+                    typedef ForwardIteratorT input_iterator_type;
+                    typedef iterator_range<ForwardIteratorT> result_type;
+
+                    input_iterator_type It=Begin;
+                    for(
+                        unsigned int Index=0;
+                        Index<m_N && It!=End; ++Index,++It ) {};
+
+                    return result_type( Begin, It );
+                }
+
+                template< typename ForwardIteratorT >
+                    iterator_range<ForwardIteratorT>
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
+                    std::random_access_iterator_tag ) const
+                {
+                    typedef ForwardIteratorT input_iterator_type;
+                    typedef iterator_range<ForwardIteratorT> result_type;
+
+                    if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < m_N ) )
+                        return result_type( Begin, End );
+
+                    return result_type(Begin,Begin+m_N);
+                }
+
+            private:
+                unsigned int m_N;
             };
 
 //  find tail functor -----------------------------------------------//
 
-
             // find a tail in the sequence ( functor )
             /*
                 This functor find a tail of the specified range. For
@@ -511,7 +349,7 @@ namespace boost {
             struct tail_finderF
             {
                 // Construction
-                tail_finderF( int N ) : m_N(N) {}
+                tail_finderF( unsigned int N ) : m_N(N) {}
 
                 // Operation
                 template< typename ForwardIteratorT >
@@ -520,21 +358,74 @@ namespace boost {
                     ForwardIteratorT Begin,
                     ForwardIteratorT End ) const
                 {
-                    if(m_N>=0)
+                    typedef BOOST_STRING_TYPENAME boost::detail::
-                    {
+                        iterator_traits<ForwardIteratorT>::iterator_category category;
-                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
-                    }
-                    else
-                    {
-                        iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
 
-                        return ::boost::make_iterator_range(Res.end(), End);
+                    return findit( Begin, End, category() );
-                    }
                 }
 
             private:
-                int m_N;
+                // Find operation implementation
+                template< typename ForwardIteratorT >
+                    iterator_range<ForwardIteratorT>
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
+                    std::forward_iterator_tag ) const
+                {
+                    typedef ForwardIteratorT input_iterator_type;
+                    typedef iterator_range<ForwardIteratorT> result_type;
+
+                    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 ) {};
+
+                    // Advance It, It2 to the end
+                    for(; It2!=End; ++It,++It2 ) {};
+
+                    return result_type( It, It2 );
+                }
+
+                template< typename ForwardIteratorT >
+                    iterator_range<ForwardIteratorT>
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
+                    std::bidirectional_iterator_tag ) const
+                {
+                    typedef ForwardIteratorT input_iterator_type;
+                    typedef iterator_range<ForwardIteratorT> result_type;
+
+                    input_iterator_type It=End;
+                    for(
+                        unsigned int Index=0;
+                        Index<m_N && It!=Begin; ++Index,--It ) {};
+
+                    return result_type( It, End );
+                }
+
+                template< typename ForwardIteratorT >
+                    iterator_range<ForwardIteratorT>
+                findit(
+                    ForwardIteratorT Begin,
+                    ForwardIteratorT End,
+                    std::random_access_iterator_tag ) const
+                {
+                    typedef ForwardIteratorT input_iterator_type;
+                    typedef iterator_range<ForwardIteratorT> result_type;
+
+                    if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < m_N ) )
+                        return result_type( Begin, End );
+
+                    return result_type( End-m_N, End );
+                }
+
+
+            private:
+                unsigned int m_N;
             };
 
 //  find token functor -----------------------------------------------//
@@ -584,7 +475,7 @@ namespace boost {
                         }
                         else
                         {
-                            // Advance by one position
+                            // Advance by one possition
                             ++It2;
                         }
 

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FINDER_REGEX_DETAIL_HPP
 #define BOOST_STRING_FINDER_REGEX_DETAIL_HPP
@@ -98,7 +97,7 @@ namespace boost {
                     // instantiate match result
                     match_results<input_iterator_type> result;
                     // search for a match
-                    if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
+                    if ( regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
                     {
                         // construct a result
                         return result_type( result );

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

@@ -1,10 +1,9 @@
 //  Boost string_algo library formatter.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
@@ -39,7 +38,7 @@ namespace boost {
             public:
                 // Construction
                 const_formatF(const RangeT& Format) :
-                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}
+                    m_Format(begin(Format), end(Format)) {}
 
                 // Operation
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -70,7 +69,7 @@ namespace boost {
                 template< typename Range2T >
                 const RangeT& operator()(const Range2T& Replace) const
                 {
-                    return RangeT(::boost::begin(Replace), ::boost::end(Replace));
+                    return RangeT(begin(Replace), end(Replace));
                 }
             };
 
@@ -87,31 +86,6 @@ namespace boost {
                 }
             };
 
-//  dissect format functor ----------------------------------------------------//
-
-            // dissect format functor
-            template<typename FinderT>
-            struct dissect_formatF
-            {
-            public:
-                // Construction
-                dissect_formatF(FinderT Finder) :
-                  m_Finder(Finder) {}
-
-                  // Operation
-                  template<typename RangeT>
-                  inline iterator_range< 
-                      BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
-                  operator()(const RangeT& Replace) const
-                  {
-                      return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
-                  }
-
-            private:
-                FinderT m_Finder;
-            };
-
-
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library formatter_regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FORMATTER_REGEX_DETAIL_HPP
 #define BOOST_STRING_FORMATTER_REGEX_DETAIL_HPP

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library predicate.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_PREDICATE_DETAIL_HPP
 #define BOOST_STRING_PREDICATE_DETAIL_HPP
@@ -63,7 +62,7 @@ namespace boost {
 
                 iterator_range<ForwardIterator1T> Result
                     =last_finder( 
-                        ::boost::make_iterator_range(SubBegin, SubEnd),
+                        make_iterator_range(SubBegin, SubEnd),
                         Comp)(Begin, End);
 
                 return !Result.empty() && Result.end()==End;

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library replace_storage.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
 #define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
@@ -46,7 +45,7 @@ namespace boost {
                 StorageT& Storage,
                 const WhatT& What )
             {
-                Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
+                Storage.insert( Storage.end(), begin(What), end(What) );
             }
 
 
@@ -68,7 +67,7 @@ namespace boost {
                     ForwardIteratorT SegmentEnd )
                 {
                     // Copy data from the storage until the beginning of the segment
-                    ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
+                    ForwardIteratorT It=move_from_storage( Storage, InsertIt, SegmentBegin );
 
                     // 3 cases are possible :
                     //   a) Storage is empty, It==SegmentBegin
@@ -125,7 +124,7 @@ namespace boost {
 
                 {
                     // Call replace to do the job
-                    ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
+                    replace( Input, InsertIt, SegmentBegin, Storage );
                     // Empty the storage
                     Storage.clear();
                     // Iterators were not changed, simply return the end of segment

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library sequence.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_DETAIL_SEQUENCE_HPP
 #define BOOST_STRING_DETAIL_SEQUENCE_HPP
@@ -41,7 +40,7 @@ namespace boost {
                 BOOST_STRING_TYPENAME InputT::iterator At,
                 const InsertT& Insert )
             {
-                ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
+                insert( Input, At, begin(Insert), end(Insert) );
             }
            
 //  erase helper  ---------------------------------------------------//
@@ -184,11 +183,11 @@ namespace boost {
             {
                 if(From!=To)
                 {
-                    ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
+                    replace( Input, From, To, begin(Insert), end(Insert) );
                 }
                 else
                 {
-                    ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
+                    insert( Input, From, begin(Insert), end(Insert) );
                 }
             }
 

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library trim.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_TRIM_DETAIL_HPP
 #define BOOST_STRING_TRIM_DETAIL_HPP
@@ -20,6 +19,36 @@ namespace boost {
 
 //  trim iterator helper -----------------------------------------------//
 
+            // Search for first non matching character from the beginning of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_begin( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                ForwardIteratorT It=InBegin;
+                for(; It!=InEnd; ++It )
+                {
+                    if (!IsSpace(*It))
+                        return It;
+                }
+
+                return It;
+            }
+
+            // Search for first non matching character from the end of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_end( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;
+
+                return trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
+            }
+
             template< typename ForwardIteratorT, typename PredicateT >
             inline ForwardIteratorT trim_end_iter_select( 
                 ForwardIteratorT InBegin, 
@@ -56,36 +85,6 @@ namespace boost {
 
                 return InBegin;
             }
-   // Search for first non matching character from the beginning of the sequence
-            template< typename ForwardIteratorT, typename PredicateT >
-            inline ForwardIteratorT trim_begin( 
-                ForwardIteratorT InBegin, 
-                ForwardIteratorT InEnd, 
-                PredicateT IsSpace )
-            {
-                ForwardIteratorT It=InBegin;
-                for(; It!=InEnd; ++It )
-                {
-                    if (!IsSpace(*It))
-                        return It;
-                }
-
-                return It;
-            }
-
-            // Search for first non matching character from the end of the sequence
-            template< typename ForwardIteratorT, typename PredicateT >
-            inline ForwardIteratorT trim_end( 
-                ForwardIteratorT InBegin, 
-                ForwardIteratorT InEnd, 
-                PredicateT IsSpace )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
-            }
-
 
         } // namespace detail
     } // namespace algorithm

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library util.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_UTIL_DETAIL_HPP
 #define BOOST_STRING_UTIL_DETAIL_HPP

include/boost/algorithm/string/erase.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library erase.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ERASE_HPP
 #define BOOST_STRING_ERASE_HPP
@@ -54,11 +53,11 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<RangeT>::type>& SearchRange )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -72,10 +71,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<SequenceT>::type>& SearchRange )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -93,10 +92,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_iterator<SequenceT>::type>& SearchRange )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_first  --------------------------------------------------------//
@@ -124,11 +123,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -140,10 +139,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -159,10 +158,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_first ( case insensitive ) ------------------------------------//
@@ -193,11 +192,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -210,10 +209,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -231,10 +230,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_last  --------------------------------------------------------//
@@ -262,11 +261,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -278,10 +277,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -297,10 +296,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_last ( case insensitive ) ------------------------------------//
@@ -331,11 +330,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -348,10 +347,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -369,10 +368,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_nth --------------------------------------------------------------------//
@@ -388,7 +387,6 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \return An output iterator pointing just after the last inserted character or
                 a modified copy of the input
 
@@ -402,13 +400,13 @@ namespace boost {
             OutputIteratorT Output,
             const Range1T& Input,
             const Range2T& Search,
-            int Nth )
+            unsigned int Nth )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -419,12 +417,12 @@ namespace boost {
         inline SequenceT erase_nth_copy( 
             const SequenceT& Input,
             const RangeT& Search,
-            int Nth )
+            unsigned int Nth )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -435,18 +433,17 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
         */
         template<typename SequenceT, typename RangeT>
         inline void erase_nth( 
             SequenceT& Input,
             const RangeT& Search,
-            int Nth )
+            unsigned int Nth )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_nth ( case insensitive ) ---------------------------------------------//
@@ -462,7 +459,6 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \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
@@ -477,14 +473,14 @@ namespace boost {
             OutputIteratorT Output,
             const Range1T& Input,
             const Range2T& Search,
-            int Nth,
+            unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -495,12 +491,12 @@ namespace boost {
         inline SequenceT ierase_nth_copy( 
             const SequenceT& Input,
             const RangeT& Search,
-            int Nth,
+            unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
                 empty_formatter(Input) );
         }
 
@@ -512,20 +508,19 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \param Loc A locale used for case insensitive comparison
         */
         template<typename SequenceT, typename RangeT>
         inline void ierase_nth( 
             SequenceT& Input,
             const RangeT& Search,
-            int Nth,
+            unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 
@@ -555,11 +550,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -571,10 +566,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -590,10 +585,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_all ( case insensitive ) ------------------------------------//
@@ -624,11 +619,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -641,10 +636,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -662,10 +657,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_head --------------------------------------------------------------------//
@@ -680,9 +675,7 @@ namespace boost {
 
             \param Output An output iterator to which the result will be copied
             \param Input An input string
-            \param N Length of the head.
+            \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \return An output iterator pointing just after the last inserted character or
                 a modified copy of the input
 
@@ -694,13 +687,13 @@ namespace boost {
         inline OutputIteratorT erase_head_copy(
             OutputIteratorT Output,
             const RangeT& Input,
-            int N )
+            unsigned int N )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -710,12 +703,12 @@ namespace boost {
         template<typename SequenceT>
         inline SequenceT erase_head_copy( 
             const SequenceT& Input,
-            int N )
+            unsigned int N )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -726,18 +719,16 @@ namespace boost {
 
             \param Input An input string
             \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
         */
         template<typename SequenceT>
         inline void erase_head( 
             SequenceT& Input,
-            int N )
+            unsigned int N )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  erase_tail --------------------------------------------------------------------//
@@ -752,9 +743,7 @@ namespace boost {
 
             \param Output An output iterator to which the result will be copied
             \param Input An input string
-            \param N Length of the tail.                 
+            \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \return An output iterator pointing just after the last inserted character or
                 a modified copy of the input
             
@@ -766,13 +755,13 @@ namespace boost {
         inline OutputIteratorT erase_tail_copy(
             OutputIteratorT Output,
             const RangeT& Input,
-            int N )
+            unsigned int N )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -782,12 +771,12 @@ namespace boost {
         template<typename SequenceT>
         inline SequenceT erase_tail_copy( 
             const SequenceT& Input,
-            int N )
+            unsigned int N )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -797,19 +786,17 @@ namespace boost {
             considered to be the tail. The input sequence is modified in-place.
 
             \param Input An input string
-            \param N Length of the tail
+            \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
         */
         template<typename SequenceT>
         inline void erase_tail( 
             SequenceT& Input,
-            int N )
+            unsigned int N )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library find.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_HPP
 #define BOOST_STRING_FIND_HPP
@@ -17,7 +16,8 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/iterator.hpp>
-#include <boost/range/as_literal.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>
@@ -48,21 +48,19 @@ namespace boost {
         */
         template<typename RangeT, typename FinderT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find( 
             RangeT& Input, 
-            const FinderT& Finder)
+            FinderT Finder)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            return Finder(begin(Input),end(Input));
-
-            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
         }
 
 //  find_first  -----------------------------------------------//
 
         //! Find first algorithm
         /*!
-            Search for the first occurrence of the substring in the input. 
+            Search for the first occurence of the substring in the input. 
             
             \param Input A string which will be searched.
             \param Search A substring to be searched for.
@@ -76,12 +74,13 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_first( 
             Range1T& Input, 
             const Range2T& Search)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
+            return first_finder(Search)(
+                begin(Input),end(Input));
         }
 
         //! Find first algorithm ( case insensitive )
@@ -102,20 +101,21 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_first( 
             Range1T& Input, 
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
+            return first_finder(Search,is_iequal(Loc))(
+                begin(Input),end(Input));
         }
 
 //  find_last  -----------------------------------------------//
 
         //! Find last algorithm
         /*!
-            Search for the last occurrence of the substring in the input. 
+            Search for the last occurence of the substring in the input. 
             
             \param Input A string which will be searched.
             \param Search A substring to be searched for.
@@ -129,12 +129,13 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_last( 
             Range1T& Input, 
             const Range2T& Search)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
+            return last_finder(Search)(
+                begin(Input),end(Input));
         }
 
         //! Find last algorithm ( case insensitive )
@@ -155,26 +156,26 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_last( 
             Range1T& Input, 
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
+            return last_finder(Search, is_iequal(Loc))(
+                begin(Input),end(Input));
         }
 
 //  find_nth ----------------------------------------------------------------------//
 
         //! Find n-th algorithm 
         /*!
-            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            Search for the n-th (zero-indexed) occurence of the substring in the 
             input.         
             
             \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.
-                For negative N, the matches are counted from the end of string.
             \return 
                 An \c iterator_range delimiting the match. 
                 Returned iterator is either \c Range1T::iterator or 
@@ -183,24 +184,24 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_nth( 
             Range1T& Input, 
             const Range2T& Search,
-            int Nth)
+            unsigned int Nth)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
+            return nth_finder(Search,Nth)(
+                begin(Input),end(Input));
         }
 
         //! Find n-th algorithm ( case insensitive ).
         /*!
-            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            Search for the n-th (zero-indexed) occurence of the substring in the 
             input. Searching is case insensitive.
             
             \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 Nth An index (zero-indexed) of the match to be found.
-                For negative N, the matches are counted from the end of string.
             \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
@@ -213,14 +214,15 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_nth( 
             Range1T& Input, 
             const Range2T& Search,
-            int Nth,
+            unsigned int Nth,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
+            return nth_finder(Search,Nth,is_iequal(Loc))(
+                begin(Input),end(Input));
         }
 
 //  find_head ----------------------------------------------------------------------//
@@ -233,8 +235,6 @@ namespace boost {
 
             \param Input An input string
             \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \return 
                 An \c iterator_range delimiting the match. 
                 Returned iterator is either \c Range1T::iterator or 
@@ -245,26 +245,25 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_head( 
             RangeT& Input, 
-            int N)
+            unsigned int N)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
+            return head_finder(N)(
+                begin(Input),end(Input));      
         }
 
 //  find_tail ----------------------------------------------------------------------//
 
         //! Find tail algorithm
         /*!
-            Get the tail of the input. Tail is a suffix of the string of the 
+            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 An input string
-            \param N Length of the tail. 
+            \param N Length of the tail
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \return 
                 An \c iterator_range delimiting the match. 
                 Returned iterator is either \c RangeT::iterator or 
@@ -276,12 +275,13 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_tail( 
             RangeT& Input, 
-            int N)
+            unsigned int N)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
+            return tail_finder(N)(
+                begin(Input),end(Input));      
         }
 
 //  find_token --------------------------------------------------------------------//
@@ -305,13 +305,14 @@ namespace boost {
         */
         template<typename RangeT, typename PredicateT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_token( 
             RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
+            return token_finder(Pred, eCompress)(
+                begin(Input),end(Input));       
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find_format.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library find_format.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_FORMAT_HPP
 #define BOOST_STRING_FIND_FORMAT_HPP
@@ -17,7 +16,6 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/concept.hpp>
 #include <boost/algorithm/string/detail/find_format.hpp>
@@ -62,24 +60,20 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                ));
-
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
 
             return detail::find_format_copy_impl(
                 Output,
-                lit_input,
+                Input,
+                Finder,
                 Formatter,
-                Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
+                Finder( begin(Input), end(Input) ) );
         }
 
         //! Generic replace algorithm
@@ -96,21 +90,19 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             return detail::find_format_copy_impl(
                 Input,
+                Finder,
                 Formatter,
-                Finder(::boost::begin(Input), ::boost::end(Input)));
+                Finder(begin(Input), end(Input)));
         }
 
         //! Generic replace algorithm
@@ -132,21 +124,19 @@ namespace boost {
             FormatterT Formatter)
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT(( 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             detail::find_format_impl(
                 Input,
+                Finder,
                 Formatter,
-                Finder(::boost::begin(Input), ::boost::end(Input)));
+                Finder(begin(Input), end(Input)));
         }
 
 
@@ -181,25 +171,20 @@ namespace boost {
             FormatterT Formatter)
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT(( 
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT(( 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                ));
-
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
 
             return detail::find_format_all_copy_impl(
                 Output,
-                lit_input,
+                Input,
                 Finder,
                 Formatter,
-                Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
+                Finder(begin(Input), end(Input)));
         }
 
         //! Generic replace all algorithm
@@ -216,22 +201,19 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             return detail::find_format_all_copy_impl(
                 Input,
                 Finder,
                 Formatter,
-                Finder( ::boost::begin(Input), ::boost::end(Input) ) );
+                Finder( begin(Input), end(Input) ) );
         }
 
         //! Generic replace all algorithm
@@ -254,22 +236,19 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             detail::find_format_all_impl(
                 Input,
                 Finder,
                 Formatter,
-                Finder(::boost::begin(Input), ::boost::end(Input)));
+                Finder(begin(Input), end(Input)));
 
         }
 

include/boost/algorithm/string/find_iterator.hpp

@@ -1,12 +1,10 @@
 //  Boost string_algo library find_iterator.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2004.
+//  Copyright Pavol Droba 2002-2004. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
+//  See http://www.boost.org for updates, documentation, and revision history.
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_ITERATOR_HPP
 #define BOOST_STRING_FIND_ITERATOR_HPP
@@ -18,13 +16,12 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
+#include <boost/range/result_iterator.hpp>
-#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/detail/find_iterator.hpp>
 
 /*! \file
-    Defines find iterator classes. Find iterator repeatedly applies a Finder
+    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.
@@ -58,6 +55,12 @@ namespace boost {
             // facade support
             friend class ::boost::iterator_core_access;
 
+            // base type
+            typedef iterator_facade<
+                find_iterator<IteratorT>,
+                const iterator_range<IteratorT>,
+                forward_traversal_tag> facade_type;
+
         private:
         // typedefs
 
@@ -111,12 +114,10 @@ namespace boost {
             find_iterator(
                     RangeT& Col,
                     FinderT Finder ) :
-                detail::find_iterator_base<IteratorT>(Finder,0)
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(begin(Col),begin(Col)),
+                m_End(end(Col))
             {
-                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
-                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
-                m_End=::boost::end(lit_col);
-
                 increment();
             }
 
@@ -179,13 +180,13 @@ namespace boost {
          */
         template<typename RangeT, typename FinderT>
         inline find_iterator< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_find_iterator(
             RangeT& Collection,
             FinderT Finder)
         {
-            return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+            return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
-                Collection, Finder);
+                begin(Collection), end(Collection), Finder);
         }
 
 //  split iterator -----------------------------------------------//
@@ -214,6 +215,12 @@ namespace boost {
             // facade support
             friend class ::boost::iterator_core_access;
 
+            // base type
+            typedef iterator_facade<
+                find_iterator<IteratorT>,
+                iterator_range<IteratorT>,
+                forward_traversal_tag> facade_type;
+
         private:
         // typedefs
 
@@ -240,7 +247,7 @@ namespace boost {
                 m_Match(Other.m_Match),
                 m_Next(Other.m_Next),
                 m_End(Other.m_End),
-                m_bEof(Other.m_bEof)
+                m_bEof(false)
             {}
 
             //! Constructor
@@ -259,11 +266,7 @@ namespace boost {
                 m_End(End),
                 m_bEof(false)
             {
-                // force the correct behavior for empty sequences and yield at least one token
+                increment();
-                if(Begin!=End)
-                {
-                    increment();
-                }
             }
             //! Constructor
             /*!
@@ -275,18 +278,12 @@ namespace boost {
                     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)
             {
-                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                increment();
-                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
-                m_Next=::boost::begin(lit_col);
-                m_End=::boost::end(lit_col);
-
-                // force the correct behavior for empty sequences and yield at least one token
-                if(m_Next!=m_End)
-                {
-                    increment();
-                }
             }
 
 
@@ -359,13 +356,13 @@ namespace boost {
          */
         template<typename RangeT, typename FinderT>
         inline split_iterator< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_split_iterator(
             RangeT& Collection,
             FinderT Finder)
         {
-            return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+            return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
-                Collection, Finder);
+                begin(Collection), end(Collection), Finder);
         }
 
 

include/boost/algorithm/string/finder.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library finder.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FINDER_HPP
 #define BOOST_STRING_FINDER_HPP
@@ -46,35 +45,35 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c first_finder object
         */
-        template<typename RangeT>
+        template<typename ContainerT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
-        first_finder( const RangeT& Search )
+        first_finder( const ContainerT& Search )
         {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                        is_equal>( ::boost::as_literal(Search), is_equal() ) ;
+                    is_equal>( Search, is_equal() ) ;
         }
 
         //! "First" finder
         /*!
             \overload
         */
-        template<typename RangeT,typename PredicateT>
+        template<typename ContainerT,typename PredicateT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
         first_finder( 
-            const RangeT& Search, PredicateT Comp )
+            const ContainerT& Search, PredicateT Comp )
         {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Comp );
+                    PredicateT>( Search, Comp );
         }
 
         //! "Last" finder
@@ -87,33 +86,33 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c last_finder object
         */
-        template<typename RangeT>
+        template<typename ContainerT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
-        last_finder( const RangeT& Search )
+        last_finder( const ContainerT& Search )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                    is_equal>( ::boost::as_literal(Search), is_equal() );
+                    is_equal>( Search, is_equal() );
         }
         //! "Last" finder
         /*!
             \overload
         */
-        template<typename RangeT, typename PredicateT>
+        template<typename ContainerT, typename PredicateT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
-        last_finder( const RangeT& Search, PredicateT Comp )
+        last_finder( const ContainerT& Search, PredicateT Comp )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Comp ) ;
+                    PredicateT>( Search, Comp ) ;
         }
 
         //! "Nth" finder
@@ -127,38 +126,38 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c nth_finder object
         */
-        template<typename RangeT>
+        template<typename ContainerT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             is_equal>
         nth_finder( 
-            const RangeT& Search, 
+            const ContainerT& Search, 
-            int Nth)
+            unsigned int Nth)
         {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                    is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
+                    is_equal>( Search, Nth, is_equal() ) ;
         }
         //! "Nth" finder
         /*!
             \overload
         */
-        template<typename RangeT, typename PredicateT>
+        template<typename ContainerT, typename PredicateT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
             PredicateT>
         nth_finder( 
-            const RangeT& Search, 
+            const ContainerT& Search, 
-            int Nth, 
+            unsigned int Nth, 
             PredicateT Comp )
         {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<RangeT>::type,
+                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Nth, Comp );
+                    PredicateT>( Search, Nth, Comp );
         }
 
         //! "Head" finder
@@ -173,7 +172,7 @@ namespace boost {
             \return An instance of the \c head_finder object
         */
         inline detail::head_finderF
-        head_finder( int N )
+        head_finder( unsigned int N )
         {
             return detail::head_finderF(N);
         }
@@ -190,7 +189,7 @@ namespace boost {
             \return An instance of the \c tail_finder object
         */
         inline detail::tail_finderF
-        tail_finder( int N )
+        tail_finder( unsigned int N )
         {
             return detail::tail_finderF(N);
         }

include/boost/algorithm/string/formatter.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library formatter.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FORMATTER_HPP
 #define BOOST_STRING_FORMATTER_HPP
@@ -14,7 +13,6 @@
 #include <boost/detail/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/iterator_range.hpp>
-#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/detail/formatter.hpp>
 
@@ -36,44 +34,36 @@ namespace boost {
 
         //! Constant formatter
         /*!
-            Constructs a \c const_formatter. Const formatter always returns
+            Construct the \c const_formatter. Const formatter always returns
             the same value, regardless of the parameter.
 
             \param Format A predefined value used as a result for formating
             \return An instance of the \c const_formatter object.
         */
         template<typename RangeT>
-        inline detail::const_formatF<
+        inline detail::const_formatF<RangeT>
-            iterator_range<
-                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
         const_formatter(const RangeT& Format)
         {
-            return detail::const_formatF<
+            return detail::const_formatF<RangeT>(Format);
-                iterator_range<
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
         }
 
         //! Identity formatter
         /*!
-            Constructs an \c identity_formatter. Identity formatter always returns
+            Construct the \c identity_formatter. Identity formatter always returns
             the parameter.
 
             \return An instance of the \c identity_formatter object.
         */
         template<typename RangeT>
-        inline detail::identity_formatF<
+        inline detail::identity_formatF<RangeT>
-            iterator_range<
-                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
         identity_formatter()
         {
-            return detail::identity_formatF<
+            return detail::identity_formatF<RangeT>();
-                iterator_range<
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
         }
 
         //! Empty formatter
         /*!
-            Constructs an \c empty_formatter. Empty formatter 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
@@ -89,22 +79,6 @@ namespace boost {
                 BOOST_STRING_TYPENAME range_value<RangeT>::type>();
         }
 
-        //! Empty formatter
-        /*!
-            Constructs a \c dissect_formatter. Dissect formatter uses a specified finder
-            to extract a portion of the formatted sequence. The first finder's match is returned 
-            as a result
-
-            \param Finder a finder used to select a portion of the formated sequence
-            \return An instance of the \c dissect_formatter object.
-        */
-        template<typename FinderT>
-        inline detail::dissect_formatF< FinderT >
-        dissect_formatter(const FinderT& Finder)
-        {
-            return detail::dissect_formatF<FinderT>(Finder);
-        }
-
 
     } // namespace algorithm
 
@@ -112,7 +86,6 @@ namespace boost {
     using algorithm::const_formatter;
     using algorithm::identity_formatter;
     using algorithm::empty_formatter;
-    using algorithm::dissect_formatter;
 
 } // namespace boost
 

include/boost/algorithm/string/iter_find.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library iter_find.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ITER_FIND_HPP
 #define BOOST_STRING_ITER_FIND_HPP
@@ -19,9 +18,8 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
+#include <boost/range/result_iterator.hpp>
 #include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/concept.hpp>
 #include <boost/algorithm/string/find_iterator.hpp>
@@ -74,34 +72,30 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
-                    BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
-                ));
-
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
-                range_iterator<RangeT>::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 
                     range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
-            input_iterator_type InputEnd=::boost::end(lit_input);
+            input_iterator_type InputEnd=end(Input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
-                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
+                    find_iterator_type( begin(Input), InputEnd, Finder ),
                     copy_range_type());
             
             transform_iter_type itEnd=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type());
 
@@ -145,33 +139,30 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
-                ));
-
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
-                range_iterator<RangeT>::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 
                     range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
-            input_iterator_type InputEnd=::boost::end(lit_input);
+            input_iterator_type InputEnd=end(Input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
-                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
+                    find_iterator_type( begin(Input), InputEnd, Finder ),
                     copy_range_type() );
 
             transform_iter_type itEnd=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type() );
             

include/boost/algorithm/string/join.hpp

@@ -1,145 +0,0 @@
-//  Boost string_algo library join.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_JOIN_HPP
-#define BOOST_STRING_JOIN_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/detail/sequence.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
-
-/*! \file
-    Defines join algorithm. 
-
-    Join algorithm is a counterpart to split algorithms.
-    It joins strings from a 'list' by adding user defined separator.
-    Additionally there is a version that allows simple filtering
-    by providing a predicate.
-*/
-
-namespace boost {
-    namespace algorithm {
-
-//  join --------------------------------------------------------------//
-
-        //! Join algorithm
-        /*!
-            This algorithm joins all strings in a 'list' into one long string.
-            Segments are concatenated by given separator.
-
-            \param Input A container that holds the input strings. It must be a container-of-containers.
-            \param Separator A string that will separate the joined segments.
-            \return Concatenated string.
-
-            \note This function provides the strong exception-safety guarantee
-        */
-        template< typename SequenceSequenceT, typename Range1T>
-        inline typename range_value<SequenceSequenceT>::type 
-        join(
-            const SequenceSequenceT& Input,
-            const Range1T& Separator)
-        {
-            // Define working types
-            typedef typename range_value<SequenceSequenceT>::type ResultT;
-            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
-            // Parse input
-            InputIteratorT itBegin=::boost::begin(Input);
-            InputIteratorT itEnd=::boost::end(Input);
-
-            // Construct container to hold the result
-            ResultT Result;
-            
-            // Append first element
-            if(itBegin!=itEnd)
-            {
-                detail::insert(Result, ::boost::end(Result), *itBegin);
-                ++itBegin;
-            }
-
-            for(;itBegin!=itEnd; ++itBegin)
-            {
-                // Add separator
-                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
-                // Add element
-                detail::insert(Result, ::boost::end(Result), *itBegin);
-            }
-
-            return Result;
-        }
-
-// join_if ----------------------------------------------------------//
-
-        //! Conditional join algorithm
-        /*!
-            This algorithm joins all strings in a 'list' into one long string.
-            Segments are concatenated by given separator. Only segments that
-            satisfy the predicate will be added to the result.
-
-            \param Input A container that holds the input strings. It must be a container-of-containers.
-            \param Separator A string that will separate the joined segments.
-            \param Pred A segment selection predicate
-            \return Concatenated string.
-
-            \note This function provides the strong exception-safety guarantee
-        */
-        template< typename SequenceSequenceT, typename Range1T, typename PredicateT>
-        inline typename range_value<SequenceSequenceT>::type 
-        join_if(
-            const SequenceSequenceT& Input,
-            const Range1T& Separator,
-            PredicateT Pred)
-        {
-            // Define working types
-            typedef typename range_value<SequenceSequenceT>::type ResultT;
-            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
-            // Parse input
-            InputIteratorT itBegin=::boost::begin(Input);
-            InputIteratorT itEnd=::boost::end(Input);
-
-            // Construct container to hold the result
-            ResultT Result;
-
-            // Roll to the first element that will be added
-            while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin;
-            // Add this element
-            if(itBegin!=itEnd)
-            {
-                detail::insert(Result, ::boost::end(Result), *itBegin);
-                ++itBegin;
-            }
-
-            for(;itBegin!=itEnd; ++itBegin)
-            {
-                if(Pred(*itBegin))
-                {
-                    // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
-                    // Add element
-                    detail::insert(Result, ::boost::end(Result), *itBegin);
-                }
-            }
-
-            return Result;
-        }
-
-    } // namespace algorithm
-
-    // pull names to the boost namespace
-    using algorithm::join;
-    using algorithm::join_if;
-
-} // namespace boost
-
-
-#endif  // BOOST_STRING_JOIN_HPP
-

include/boost/algorithm/string/predicate.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library predicate.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_PREDICATE_HPP
 #define BOOST_STRING_PREDICATE_HPP
@@ -16,8 +15,6 @@
 #include <boost/range/end.hpp>
 #include <boost/range/iterator.hpp>
 #include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/range/iterator_range.hpp>
 
 #include <boost/algorithm/string/compare.hpp>
 #include <boost/algorithm/string/find.hpp>
@@ -59,19 +56,16 @@ namespace boost {
             const Range2T& Test,
             PredicateT Comp)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range2T>::type Iterator2T;
 
-            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator1T InputEnd=end(Input);
-            Iterator2T TestEnd=::boost::end(lit_test);
+            Iterator2T TestEnd=end(Test);
 
-            Iterator1T it=::boost::begin(lit_input);
+            Iterator1T it=begin(Input);
-            Iterator2T pit=::boost::begin(lit_test);
+            Iterator2T pit=begin(Test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -92,7 +86,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::starts_with(Input, Test, is_equal());
+            return starts_with(Input, Test, is_equal());
         }
 
         //! 'Starts with' predicate ( case insensitive )
@@ -114,7 +108,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
+            return starts_with(Input, Test, is_iequal(Loc));
         }
 
 
@@ -141,9 +135,6 @@ namespace boost {
             const Range2T& Test,
             PredicateT Comp)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME boost::detail::
@@ -151,10 +142,10 @@ namespace boost {
 
             return detail::
                 ends_with_iter_select( 
-                    ::boost::begin(lit_input), 
+                    begin(Input), 
-                    ::boost::end(lit_input), 
+                    end(Input), 
-                    ::boost::begin(lit_test), 
+                    begin(Test), 
-                    ::boost::end(lit_test), 
+                    end(Test), 
                     Comp,
                     category());
         }
@@ -169,7 +160,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::ends_with(Input, Test, is_equal());
+            return ends_with(Input, Test, is_equal());
         }
 
         //! 'Ends with' predicate ( case insensitive )
@@ -191,7 +182,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
+            return ends_with(Input, Test, is_iequal(Loc));
         }
 
 //  contains predicate  -----------------------------------------------//
@@ -215,17 +206,14 @@ namespace boost {
             const Range2T& Test,
             PredicateT Comp)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
+            if (empty(Test))
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
-            if (::boost::empty(lit_test))
             {
                 // Empty range is contained always
                 return true;
             }
             
             // Use the temporary variable to make VACPP happy
-            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
+            bool bResult=(first_finder(Test,Comp)(begin(Input), end(Input)));
             return bResult;
         }
 
@@ -238,7 +226,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::contains(Input, Test, is_equal());
+            return contains(Input, Test, is_equal());
         }
 
         //! 'Contains' predicate ( case insensitive )
@@ -259,7 +247,7 @@ namespace boost {
             const Range2T& Test, 
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
+            return contains(Input, Test, is_iequal(Loc));
         }
 
 //  equals predicate  -----------------------------------------------//
@@ -286,19 +274,16 @@ namespace boost {
             const Range2T& Test,
             PredicateT Comp)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range2T>::type Iterator2T;
                 
-            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator1T InputEnd=end(Input);
-            Iterator2T TestEnd=::boost::end(lit_test);
+            Iterator2T TestEnd=end(Test);
 
-            Iterator1T it=::boost::begin(lit_input);
+            Iterator1T it=begin(Input);
-            Iterator2T pit=::boost::begin(lit_test);
+            Iterator2T pit=begin(Test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -319,10 +304,10 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::equals(Input, Test, is_equal());
+            return equals(Input, Test, is_equal());
         }
 
-        //! 'Equals' predicate ( case insensitive )
+        //! 'Equals' predicate ( casa insensitive )
         /*!
             This predicate holds when the test container is equal to the
             input container i.e. all elements in both containers are same.
@@ -343,84 +328,9 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
+            return equals(Input, Test, is_iequal(Loc));
         }
 
-// lexicographical_compare predicate -----------------------------//
-
-        //! Lexicographical compare predicate
-        /*!
-             This predicate is an overload of std::lexicographical_compare
-             for range arguments
-
-             It check whether the first argument is lexicographically less
-             then the second one.
-
-             If the optional predicate is specified, it is used for character-wise
-             comparison
-
-             \param Arg1 First argument 
-             \param Arg2 Second argument
-             \param Pred Comparison predicate
-             \return The result of the test
-
-             \note This function provides the strong exception-safety guarantee
-         */
-        template<typename Range1T, typename Range2T, typename PredicateT>
-        inline bool lexicographical_compare(
-            const Range1T& Arg1,
-            const Range2T& Arg2,
-            PredicateT Pred)
-        {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));
-
-            return std::lexicographical_compare(
-                ::boost::begin(lit_arg1),
-                ::boost::end(lit_arg1),
-                ::boost::begin(lit_arg2),
-                ::boost::end(lit_arg2),
-                Pred);
-        }
-
-        //! Lexicographical compare predicate
-        /*!
-            \overload
-         */
-        template<typename Range1T, typename Range2T>
-            inline bool lexicographical_compare(
-            const Range1T& Arg1,
-            const Range2T& Arg2)
-        {
-            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
-        }
-
-        //! Lexicographical compare predicate (case-insensitive)
-        /*!
-            This predicate is an overload of std::lexicographical_compare
-            for range arguments.
-            It check whether the first argument is lexicographically less
-            then the second one.
-            Elements are compared case insensitively
-
-
-             \param Arg1 First argument 
-             \param Arg2 Second argument
-             \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 Range1T, typename Range2T>
-        inline bool ilexicographical_compare(
-            const Range1T& Arg1,
-            const Range2T& Arg2,
-            const std::locale& Loc=std::locale())
-        {
-            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
-        }
-        
-
 //  all predicate  -----------------------------------------------//
 
         //! 'All' predicate
@@ -439,13 +349,11 @@ namespace boost {
             const RangeT& Input, 
             PredicateT Pred)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type Iterator1T;
 
-            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator1T InputEnd=end(Input);
-            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
+            for( Iterator1T It=begin(Input); It!=InputEnd; ++It)
             {
                 if (!Pred(*It))
                     return false;
@@ -466,8 +374,6 @@ namespace boost {
     using algorithm::equals;
     using algorithm::iequals;
     using algorithm::all;
-    using algorithm::lexicographical_compare;
-    using algorithm::ilexicographical_compare;
 
 } // namespace boost
 

include/boost/algorithm/string/predicate_facade.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library predicate_facade.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  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/regex.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REGEX_HPP
 #define BOOST_STRING_REGEX_HPP
@@ -17,8 +16,7 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
+#include <boost/range/result_iterator.hpp>
-#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/regex_find_format.hpp>
@@ -54,16 +52,14 @@ namespace boost {
             typename CharT, 
             typename RegexTraitsT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_iterator<RangeT>::type >
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
         find_regex( 
             RangeT& Input, 
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            return regex_finder(Rx,Flags)(
-
+                begin(Input), end(Input) );
-            return ::boost::algorithm::regex_finder(Rx,Flags)(
-                ::boost::begin(lit_input), ::boost::end(lit_input) );
         }
 
 //  replace_regex --------------------------------------------------------------------//
@@ -98,11 +94,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -120,10 +116,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -147,10 +143,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
 //  replace_all_regex --------------------------------------------------------------------//
@@ -184,11 +180,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -206,10 +202,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -233,10 +229,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
 //  erase_regex --------------------------------------------------------------------//
@@ -267,11 +263,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -287,10 +283,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -311,10 +307,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  erase_all_regex --------------------------------------------------------------------//
@@ -346,11 +342,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -366,10 +362,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -390,10 +386,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  find_all_regex ------------------------------------------------------------------//
@@ -431,10 +427,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::regex_finder(Rx,Flags) );         
+                regex_finder(Rx,Flags) );         
         }
 
 //  split_regex ------------------------------------------------------------------//
@@ -472,153 +468,12 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::iter_split(
+            return iter_split(
                 Result,
                 Input,
-                ::boost::algorithm::regex_finder(Rx,Flags) );         
+                regex_finder(Rx,Flags) );         
         }
 
-//  join_if ------------------------------------------------------------------//
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-        //! Conditional join algorithm
-        /*!
-            This algorithm joins all strings in a 'list' into one long string.
-            Segments are concatenated by given separator. Only segments that
-            match the given regular expression will be added to the result
-
-            This is a specialization of join_if algorithm.
-
-            \param Input A container that holds the input strings. It must be a container-of-containers.
-            \param Separator A string that will separate the joined segments.
-            \param Rx A regular expression
-            \param Flags Regex options
-            \return Concatenated string.
-
-            \note This function provides the strong exception-safety guarantee
-        */
-        template< 
-            typename SequenceSequenceT, 
-            typename Range1T,             
-            typename CharT, 
-            typename RegexTraitsT >
-        inline typename range_value<SequenceSequenceT>::type 
-        join_if(
-            const SequenceSequenceT& Input,
-            const Range1T& Separator,
-            const basic_regex<CharT, RegexTraitsT>& Rx,
-            match_flag_type Flags=match_default )
-        {
-            // Define working types
-            typedef typename range_value<SequenceSequenceT>::type ResultT;
-            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
-            // Parse input
-            InputIteratorT itBegin=::boost::begin(Input);
-            InputIteratorT itEnd=::boost::end(Input);
-
-            // Construct container to hold the result
-            ResultT Result;
-
-
-            // Roll to the first element that will be added
-            while(
-                itBegin!=itEnd && 
-                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
-
-            // Add this element
-            if(itBegin!=itEnd)
-            {
-                detail::insert(Result, ::boost::end(Result), *itBegin);
-                ++itBegin;
-            }
-
-            for(;itBegin!=itEnd; ++itBegin)
-            {
-                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
-                {
-                    // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
-                    // Add element
-                    detail::insert(Result, ::boost::end(Result), *itBegin);
-                }
-            }
-
-            return Result;
-        }
-
-#else  // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-                //! Conditional join algorithm
-        /*!
-            This algorithm joins all strings in a 'list' into one long string.
-            Segments are concatenated by given separator. Only segments that
-            match the given regular expression will be added to the result
-
-            This is a specialization of join_if algorithm.
-
-            \param Input A container that holds the input strings. It must be a container-of-containers.
-            \param Separator A string that will separate the joined segments.
-            \param Rx A regular expression
-            \param Flags Regex options
-            \return Concatenated string.
-
-            \note This function provides the strong exception-safety guarantee
-        */
-        template< 
-            typename SequenceSequenceT, 
-            typename Range1T,             
-            typename CharT, 
-            typename RegexTraitsT >
-        inline typename range_value<SequenceSequenceT>::type 
-        join_if_regex(
-            const SequenceSequenceT& Input,
-            const Range1T& Separator,
-            const basic_regex<CharT, RegexTraitsT>& Rx,
-            match_flag_type Flags=match_default )
-        {
-            // Define working types
-            typedef typename range_value<SequenceSequenceT>::type ResultT;
-            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
-            // Parse input
-            InputIteratorT itBegin=::boost::begin(Input);
-            InputIteratorT itEnd=::boost::end(Input);
-
-            // Construct container to hold the result
-            ResultT Result;
-
-
-            // Roll to the first element that will be added
-            while(
-                itBegin!=itEnd && 
-                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
-
-            // Add this element
-            if(itBegin!=itEnd)
-            {
-                detail::insert(Result, ::boost::end(Result), *itBegin);
-                ++itBegin;
-            }
-
-            for(;itBegin!=itEnd; ++itBegin)
-            {
-                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
-                {
-                    // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
-                    // Add element
-                    detail::insert(Result, ::boost::end(Result), *itBegin);
-                }
-            }
-
-            return Result;
-        }
-
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
     } // namespace algorithm
 
     // pull names into the boost namespace
@@ -634,12 +489,6 @@ namespace boost {
     using algorithm::find_all_regex;
     using algorithm::split_regex;
 
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    using algorithm::join_if;
-#else  // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    using algorithm::join_if_regex;
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
 } // namespace boost
 
 

include/boost/algorithm/string/regex_find_format.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library regex_find_format.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REGEX_FIND_FORMAT_HPP
 #define BOOST_STRING_REGEX_FIND_FORMAT_HPP

include/boost/algorithm/string/replace.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library replace.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REPLACE_HPP
 #define BOOST_STRING_REPLACE_HPP
@@ -61,11 +60,11 @@ namespace boost {
                     range_const_iterator<Range1T>::type>& SearchRange,
             const Range2T& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -80,10 +79,10 @@ namespace boost {
                     range_const_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -103,10 +102,10 @@ namespace boost {
                     range_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            ::boost::algorithm::find_format(
+            find_format(
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
 //  replace_first --------------------------------------------------------------------//
@@ -138,11 +137,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -155,10 +154,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -176,10 +175,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_first ( case insensitive ) ---------------------------------------------//
@@ -214,11 +213,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -232,10 +231,10 @@ namespace boost {
             const Range1T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -256,10 +255,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_last --------------------------------------------------------------------//
@@ -291,11 +290,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -308,10 +307,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -329,10 +328,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_last ( case insensitive ) -----------------------------------------------//
@@ -367,11 +366,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -385,10 +384,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -410,10 +409,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_nth --------------------------------------------------------------------//
@@ -429,7 +428,6 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \param Format A substitute string
             \return An output iterator pointing just after the last inserted character or
                 a modified copy of the input
@@ -445,14 +443,14 @@ namespace boost {
             OutputIteratorT Output,
             const Range1T& Input,
             const Range2T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -463,13 +461,13 @@ namespace boost {
         inline SequenceT replace_nth_copy( 
             const SequenceT& Input,
             const Range1T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -480,20 +478,19 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \param Format A substitute string
         */
         template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_nth( 
             SequenceT& Input,
             const Range1T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_nth ( case insensitive ) -----------------------------------------------//
@@ -510,7 +507,6 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
             \return An output iterator pointing just after the last inserted character or
@@ -527,15 +523,15 @@ namespace boost {
             OutputIteratorT Output,
             const Range1T& Input,
             const Range2T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
+                nth_finder(Search, Nth, is_iequal(Loc) ),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -546,14 +542,14 @@ namespace boost {
         inline SequenceT ireplace_nth_copy( 
             const SequenceT& Input,
             const Range1T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -565,7 +561,6 @@ namespace boost {
             \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.
-                For negative N, matches are counted from the end of string.
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
         */
@@ -573,14 +568,14 @@ namespace boost {
         inline void ireplace_nth( 
             SequenceT& Input,
             const Range1T& Search,
-            int Nth,
+            unsigned int Nth,
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_all --------------------------------------------------------------------//
@@ -612,11 +607,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -629,10 +624,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -651,10 +646,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
         
 //  replace_all ( case insensitive ) -----------------------------------------------//
@@ -689,11 +684,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -707,10 +702,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -731,10 +726,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
         
 //  replace_head --------------------------------------------------------------------//
@@ -750,9 +745,7 @@ namespace boost {
             
             \param Output An output iterator to which the result will be copied
             \param Input An input string
-            \param N Length of the head.
+            \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \param Format A substitute string
             \return An output iterator pointing just after the last inserted character or
                 a modified copy of the input  
@@ -766,14 +759,14 @@ namespace boost {
         inline OutputIteratorT replace_head_copy(
             OutputIteratorT Output,
             const Range1T& Input,
-            int N,
+            unsigned int N,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -783,13 +776,13 @@ namespace boost {
         template<typename SequenceT, typename RangeT>
         inline SequenceT replace_head_copy( 
             const SequenceT& Input,
-            int N,
+            unsigned int N,
             const RangeT& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -800,21 +793,19 @@ namespace boost {
             considered to be the head. The input sequence is modified in-place.
 
             \param Input An input string
-            \param N Length of the head.
+            \param N Length of the head
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \param Format A substitute string
         */
         template<typename SequenceT, typename RangeT>
         inline void replace_head( 
             SequenceT& Input,
-            int N,
+            unsigned int N,
             const RangeT& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_tail --------------------------------------------------------------------//
@@ -830,9 +821,7 @@ namespace boost {
 
             \param Output An output iterator to which the result will be copied
             \param Input An input string
-            \param N Length of the tail.
+            \param N Length of the tail
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \param Format A substitute string
             \return An output iterator pointing just after the last inserted character or
                     a modified copy of the input   
@@ -846,14 +835,14 @@ namespace boost {
         inline OutputIteratorT replace_tail_copy(
             OutputIteratorT Output,
             const Range1T& Input,
-            int N,
+            unsigned int N,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -863,13 +852,13 @@ namespace boost {
         template<typename SequenceT, typename RangeT>
         inline SequenceT replace_tail_copy( 
             const SequenceT& Input,
-            int N,
+            unsigned int N,
             const RangeT& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -880,21 +869,19 @@ namespace boost {
             considered to be the tail. The input sequence is modified in-place.
 
             \param Input An input string
-            \param N Length of the tail.
+            \param N Length of the tail
-                For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
             \param Format A substitute string
         */
         template<typename SequenceT, typename RangeT>
         inline void replace_tail( 
             SequenceT& Input,
-            int N,
+            unsigned int N,
             const RangeT& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/sequence_traits.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library sequence_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP
 #define BOOST_STRING_SEQUENCE_TRAITS_HPP

include/boost/algorithm/string/split.hpp

@@ -1,12 +1,11 @@
-//  Boost string_algo library split.hpp header file  ---------------------------//
+//  Boost string_algo library find.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_SPLIT_HPP
 #define BOOST_STRING_SPLIT_HPP
@@ -56,7 +55,7 @@ namespace boost {
 
             \note Prior content of the result will be overwritten.
 
-            \note This function provides the strong exception-safety guarantee
+               \note This function provides the strong exception-safety guarantee
         */
         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& find_all(
@@ -64,10 +63,10 @@ namespace boost {
             Range1T& Input,
             const Range2T& Search)
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::first_finder(Search) );        
+                first_finder(Search) );        
         }
 
         //! Find all algorithm ( case insensitive ) 
@@ -91,7 +90,7 @@ namespace boost {
 
             \note Prior content of the result will be overwritten.
 
-            \note This function provides the strong exception-safety guarantee
+              \note This function provides the strong exception-safety guarantee
         */
         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& ifind_all(
@@ -100,10 +99,10 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );        
+                first_finder(Search, is_iequal(Loc) ) );        
         }
 
 
@@ -143,10 +142,10 @@ namespace boost {
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {
-            return ::boost::algorithm::iter_split(
+            return iter_split(
                 Result,
                 Input,
-                ::boost::algorithm::token_finder( Pred, eCompress ) );         
+                token_finder( Pred, eCompress ) );         
         }
 
     } // namespace algorithm

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library list_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_STD_LIST_TRAITS_HPP
 #define BOOST_STRING_STD_LIST_TRAITS_HPP

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library string_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_STD_ROPE_TRAITS_HPP
 #define BOOST_STRING_STD_ROPE_TRAITS_HPP

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

@@ -1,19 +1,18 @@
 //  Boost string_algo library slist_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. 
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #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 BOOST_SLIST_HEADER 
+#include <slist>
 #include <boost/algorithm/string/sequence_traits.hpp>
 
 namespace boost {

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

@@ -1,12 +1,11 @@
 //  Boost string_algo library string_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_STD_STRING_TRAITS_HPP
 #define BOOST_STRING_STD_STRING_TRAITS_HPP

include/boost/algorithm/string/std_containers_traits.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library std_containers_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
 #define BOOST_STRING_STD_CONTAINERS_TRAITS_HPP

include/boost/algorithm/string/trim.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library trim.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_TRIM_HPP
 #define BOOST_STRING_TRIM_HPP
@@ -16,8 +15,6 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/range/iterator_range.hpp>
 
 #include <boost/algorithm/string/detail/trim.hpp>
 #include <boost/algorithm/string/classification.hpp>
@@ -63,14 +60,12 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-
             std::copy( 
                 ::boost::algorithm::detail::trim_begin( 
-                    ::boost::begin(lit_range), 
+                    begin(Input), 
-                    ::boost::end(lit_range), 
+                    end(Input), 
                     IsSpace ),
-                ::boost::end(lit_range),
+                end(Input),
                 Output);
 
             return Output;
@@ -85,10 +80,10 @@ namespace boost {
         {
             return SequenceT( 
                 ::boost::algorithm::detail::trim_begin( 
-                    ::boost::begin(Input), 
+                    begin(Input), 
-                    ::boost::end(Input), 
+                    end(Input), 
                     IsSpace ),
-                ::boost::end(Input));
+                end(Input));
         }
 
         //! Left trim - parametric
@@ -106,7 +101,7 @@ namespace boost {
         inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
         {
             return            
-                ::boost::algorithm::trim_left_copy_if(
+                trim_left_copy_if(
                     Input, 
                     is_space(Loc));
         }
@@ -124,10 +119,10 @@ namespace boost {
         inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
         {
             Input.erase( 
-                ::boost::begin(Input),
+                begin(Input),
                 ::boost::algorithm::detail::trim_begin( 
-                    ::boost::begin(Input), 
+                    begin(Input), 
-                    ::boost::end(Input), 
+                    end(Input), 
                     IsSpace));
         }
 
@@ -142,7 +137,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_left_if( 
+            trim_left_if( 
                 Input, 
                 is_space(Loc));
         }
@@ -171,13 +166,11 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-         
             std::copy( 
-                ::boost::begin(lit_range),
+                begin(Input),
                 ::boost::algorithm::detail::trim_end( 
-                    ::boost::begin(lit_range), 
+                    begin(Input), 
-                    ::boost::end(lit_range), 
+                    end(Input), 
                     IsSpace ),
                 Output );
 
@@ -192,10 +185,10 @@ namespace boost {
         inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
         {
             return SequenceT( 
-                ::boost::begin(Input),
+                begin(Input),
                 ::boost::algorithm::detail::trim_end( 
-                    ::boost::begin(Input), 
+                    begin(Input), 
-                    ::boost::end(Input), 
+                    end(Input), 
                     IsSpace)
                 );
         }
@@ -215,7 +208,7 @@ namespace boost {
         inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
         {
             return 
-                ::boost::algorithm::trim_right_copy_if( 
+                trim_right_copy_if( 
                     Input, 
                     is_space(Loc));
         }
@@ -235,10 +228,10 @@ namespace boost {
         {
             Input.erase(
                 ::boost::algorithm::detail::trim_end( 
-                    ::boost::begin(Input), 
+                    begin(Input), 
-                    ::boost::end(Input), 
+                    end(Input), 
                     IsSpace ),
-                ::boost::end(Input)
+                end(Input)
                 );
         }
 
@@ -254,7 +247,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_right_if(
+            trim_right_if(
                 Input, 
                 is_space(Loc) );
         }
@@ -283,18 +276,16 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-
             BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type TrimEnd=
                 ::boost::algorithm::detail::trim_end( 
-                    ::boost::begin(lit_range), 
+                    begin(Input), 
-                    ::boost::end(lit_range), 
+                    end(Input), 
                     IsSpace);
 
             std::copy( 
                 detail::trim_begin( 
-                    ::boost::begin(lit_range), TrimEnd, IsSpace),
+                    begin(Input), TrimEnd, IsSpace),
                 TrimEnd,
                 Output
                 );
@@ -312,13 +303,13 @@ namespace boost {
             BOOST_STRING_TYPENAME 
                 range_const_iterator<SequenceT>::type TrimEnd=
                     ::boost::algorithm::detail::trim_end( 
-                        ::boost::begin(Input), 
+                        begin(Input), 
-                        ::boost::end(Input), 
+                        end(Input), 
                         IsSpace);
 
             return SequenceT( 
                 detail::trim_begin( 
-                    ::boost::begin(Input), 
+                    begin(Input), 
                     TrimEnd, 
                     IsSpace),
                 TrimEnd
@@ -340,7 +331,7 @@ namespace boost {
         inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
         {
             return
-                ::boost::algorithm::trim_copy_if(
+                trim_copy_if(
                     Input, 
                     is_space(Loc) );
         }
@@ -357,8 +348,8 @@ namespace boost {
         template<typename SequenceT, typename PredicateT>
         inline void trim_if(SequenceT& Input, PredicateT IsSpace)
         {
-            ::boost::algorithm::trim_right_if( Input, IsSpace );
+            trim_right_if( Input, IsSpace );
-            ::boost::algorithm::trim_left_if( Input, IsSpace );
+            trim_left_if( Input, IsSpace );
         }
 
         //! Trim
@@ -372,7 +363,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_if(
+            trim_if(
                 Input, 
                 is_space( Loc ) );
         }

include/boost/algorithm/string/trim_all.hpp

@@ -1,217 +0,0 @@
-//  Boost string_algo library trim.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_TRIM_ALL_HPP
-#define BOOST_STRING_TRIM_ALL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <locale>
-
-/*! \file
-    Defines trim_all algorithms.
-    
-    Just like \c trim, \c trim_all removes all trailing and leading spaces from a 
-    sequence (string). In addition, spaces in the middle of the sequence are truncated
-    to just one character. Space is recognized using given locales.
-
-    \c trim_fill acts as trim_all, but the spaces in the middle are replaces with 
-    a user-define sequence of character.
-
-    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 
-    whether a character is a space. Common predicates are provided in classification.hpp header.
-
-*/
-
-namespace boost {
-    namespace algorithm {
-
-        // multi line trim  ----------------------------------------------- //
-
-        //! Trim All - parametric
-        /*!
-            Remove all leading and trailing spaces from the input and
-            compress all other spaces to a single character.
-            The result is a trimmed copy of the input
-
-            \param Input An input sequence
-             \param IsSpace An unary predicate identifying spaces
-            \return A trimmed copy of the input
-        */
-        template<typename SequenceT, typename PredicateT>
-        inline SequenceT trim_all_copy_if(const SequenceT& Input, PredicateT IsSpace)
-        {
-            return 
-                ::boost::find_format_all_copy(      
-                    ::boost::trim_copy_if(Input, IsSpace),
-                    ::boost::token_finder(IsSpace, ::boost::token_compress_on),
-                    ::boost::dissect_formatter(::boost::head_finder(1)));
-        }
-
-
-        //! Trim All
-        /*!
-            Remove all leading and trailing spaces from the input and
-            compress all other spaces to a single character.
-            The input sequence is modified in-place.
-
-            \param Input An input sequence
-            \param IsSpace An unary predicate identifying spaces
-        */
-        template<typename SequenceT, typename PredicateT>
-        inline void trim_all_if(SequenceT& Input, PredicateT IsSpace)
-        {
-            ::boost::trim_if(Input, IsSpace);
-            ::boost::find_format_all(       
-                Input,          
-                ::boost::token_finder(IsSpace, ::boost::token_compress_on),
-                ::boost::dissect_formatter(::boost::head_finder(1)));
-        }
-
-
-        //! Trim All
-        /*!
-            Remove all leading and trailing spaces from the input and
-            compress all other spaces to a single character.
-            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 of the input
-        */
-        template<typename SequenceT>
-        inline SequenceT trim_all_copy(const SequenceT& Input, const std::locale& Loc =std::locale())
-        {
-            return trim_all_copy_if(Input, ::boost::is_space(Loc));
-        }
-
-
-        //! Trim All
-        /*!
-            Remove all leading and trailing spaces from the input and
-            compress all other spaces to a single character.
-            The input sequence is modified in-place.
-
-            \param Input An input sequence
-            \param Loc A locale used for 'space' classification
-            \return A trimmed copy of the input
-        */
-        template<typename SequenceT>
-        inline void trim_all(SequenceT& Input, const std::locale& Loc =std::locale())
-        {
-            trim_all_if(Input, ::boost::is_space(Loc));
-        }
-
-
-        //! Trim Fill - parametric
-        /*!
-            Remove all leading and trailing spaces from the input and
-            replace all every block of consecutive spaces with a fill string
-            defined by user.
-            The result is a trimmed copy of the input
-
-            \param Input An input sequence
-            \param Fill A string used to fill the inner spaces
-            \param IsSpace An unary predicate identifying spaces
-            \return A trimmed copy of the input
-        */
-        template<typename SequenceT, typename RangeT, typename PredicateT>
-        inline SequenceT trim_fill_copy_if(const SequenceT& Input, const RangeT& Fill, PredicateT IsSpace)
-        {
-            return 
-                ::boost::find_format_all_copy(      
-                    ::boost::trim_copy_if(Input, IsSpace),
-                    ::boost::token_finder(IsSpace, ::boost::token_compress_on),
-                    ::boost::const_formatter(::boost::as_literal(Fill)));
-        }
-
-
-        //! Trim Fill
-        /*!
-            Remove all leading and trailing spaces from the input and
-            replace all every block of consecutive spaces with a fill string
-            defined by user.
-            The input sequence is modified in-place.
-
-            \param Input An input sequence
-            \param Fill A string used to fill the inner spaces
-            \param IsSpace An unary predicate identifying spaces
-        */
-        template<typename SequenceT, typename RangeT, typename PredicateT>
-        inline void trim_fill_if(SequenceT& Input, const RangeT& Fill, PredicateT IsSpace)
-        {
-            ::boost::trim_if(Input, IsSpace);
-            ::boost::find_format_all(       
-                Input,          
-                ::boost::token_finder(IsSpace, ::boost::token_compress_on),
-                ::boost::const_formatter(::boost::as_literal(Fill)));
-        }
-
-
-        //! Trim Fill
-        /*!
-            Remove all leading and trailing spaces from the input and
-            replace all every block of consecutive spaces with a fill string
-            defined by user.
-            The result is a trimmed copy of the input
-
-            \param Input An input sequence
-            \param Fill A string used to fill the inner spaces
-            \param Loc A locale used for 'space' classification
-            \return A trimmed copy of the input
-        */
-        template<typename SequenceT, typename RangeT>
-        inline SequenceT trim_fill_copy(const SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale())
-        {
-            return trim_fill_copy_if(Input, Fill, ::boost::is_space(Loc));
-        }
-
-
-        //! Trim Fill
-        /*!
-            Remove all leading and trailing spaces from the input and
-            replace all every block of consecutive spaces with a fill string
-            defined by user.
-            The input sequence is modified in-place.
-
-            \param Input An input sequence
-            \param Fill A string used to fill the inner spaces
-            \param Loc A locale used for 'space' classification
-            \return A trimmed copy of the input
-        */
-        template<typename SequenceT, typename RangeT>
-        inline void trim_fill(SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale())
-        {
-            trim_fill_if(Input, Fill, ::boost::is_space(Loc));
-        }
-
-
-    } // namespace algorithm    
-
-    // pull names to the boost namespace
-    using algorithm::trim_all;
-    using algorithm::trim_all_if;
-    using algorithm::trim_all_copy;
-    using algorithm::trim_all_copy_if;
-    using algorithm::trim_fill;
-    using algorithm::trim_fill_if;
-    using algorithm::trim_fill_copy;
-    using algorithm::trim_fill_copy_if;
-
-} // namespace boost
-
-#endif  // BOOST_STRING_TRIM_ALL_HPP

include/boost/algorithm/string/yes_no_type.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library yes_no_type.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003.
+//  Copyright Pavol Droba 2002-2003. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
 #define BOOST_STRING_YES_NO_TYPE_DETAIL_HPP

include/boost/algorithm/string_regex.hpp

@@ -1,12 +1,11 @@
 //  Boost string_algo library string_regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2004.
+//  Copyright Pavol Droba 2002-2004. Use, modification and
-//
+//  distribution is subject to the Boost Software License, Version
-// Distributed under the Boost Software License, Version 1.0.
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
-//          http://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/ for updates, documentation, and revision history.
+//  See http://www.boost.org for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ALGO_REGEX_HPP
 #define BOOST_STRING_ALGO_REGEX_HPP

minmax/doc/minmax_benchs.html

@@ -35,7 +35,7 @@ means that all the elements are distinct and in increasing order, <i>decrea</i>s
 is the reverse, and <i>random</i> is produced by random_shuffle.
 <br>
 The program that created these tables is included in the distribution,
-under <a href="../example/minmax_timer.cpp">minmax_timer.cpp</a>
+under <a href=""../example/minmax_timer.cpp"">minmax_timer.cpp</a>
 <br> 
 <center><table BORDER NOSAVE >
 <tr NOSAVE>

minmax/example/Jamfile

@@ -7,6 +7,8 @@
 # http://www.boost.org/LICENSE_1_0.txt)
 #
 
+subproject libs/algorithm/minmax/example ;
+
 exe minmax_ex : minmax_ex.cpp ;
 exe minmax_timer : minmax_timer.cpp ;
 

minmax/index.html

@@ -56,7 +56,7 @@ be enough. The present library solves both problems.</p>
 <tt>minmax</tt>
 as straightforward extensions of the C++
 standard. As it returns a pair of <tt>const&amp;</tt>, we must use the <a
-href="../../tuple/index.html">Boost.tuple</a> library to construct such
+href=:../../tuple/index.html>Boost.tuple</a> library to construct such
 pairs. (Please note: the intent is not to fix the known defaults of
 <tt>std::min</tt>
 and <tt>std::max</tt>, but to add one more algorithms that combines both; see the
@@ -92,11 +92,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax.hpp></tt></h3>
 namespace boost {
 
   template &lt;class T>
-  tuple&lt;T const&amp;, T const&amp;>
+  tuple&lt;T const&amp;, T const&amp;> >
   minmax(const T&amp; a, const T&amp; b);
 
   template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
-  tuple&lt;T const&amp;, T const&amp;>
+  tuple&lt;T const&amp;, T const&amp;> >
   minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);
 
 }
@@ -158,9 +158,9 @@ identical to
 that they return the last instance of the largest element (and not the
 first, as <tt>first_min_element</tt> and <tt>last_max_element</tt> would).
 <p>The family of algorithms comprising <tt>first_min_first_max_element</tt>,
-<tt>first_min_last_max_element</tt>,
+<tt>first_min_first_max_element</tt>,
-<tt>last_min_first_max_element</tt>,
+<tt>first_min_first_max_element</tt>,
-and <tt>last_min_last_max_element</tt> can be described generically as
+and <tt>first_min_first_max_element</tt> can be described generically as
 follows (using <i><tt>which</tt></i> and
 <i><tt>what</tt></i> for <tt>first</tt>
 or <tt>last</tt>): <tt><i>which</i>_min_<i>what</i>_max_element</tt> finds
@@ -243,7 +243,7 @@ range
 
 <a name="complexity">
 <h3>
-Complexity</h3>
+<a NAME="Complexity"></a>Complexity</h3>
 Minmax performs a single comparison and is otherwise of constant complexity.
 The use of <tt>boost::tuple&lt;T const&amp;></tt> prevents copy
 constructors in case the arguments are passed by reference.
@@ -338,7 +338,7 @@ most</i> instead of <i>exactly</i> in the odd case.
 <b>Rationale:</b></h3>
 
 <a name="two_headers">
-<h4><b>Why not a single header <tt>&lt;boost/algorithm/minmax.hpp></tt>?</b></h4>
+<h4><b>Why not a single header <tt>&amp;boost/algorithm/minmax.hpp></tt>?</b></h4>
 <p>This was the design originally proposed and approved in the formal
 review. As the need for Boost.tuple became clear (due to the limitations
 of <tt>std::pair</tt>), it became also annoying to require another
@@ -350,7 +350,8 @@ separation into two header files.</p>
 std::max.</b></h4>
 <p>I am aware of the problems with std::min and
 std::max, and all the debate that has been going on (please consult
-<a href="http://www.cuj.com/documents/s=7996/cujcexp1904alexandr/alexandr.htm">Alexandrescu's paper</a> and the links therein). But I don't see the purpose of this
+<a href="http://www.cuj.com/experts/1904/alexandr.htm?topic=experts&topic=experts">Alexandrescu's
+paper</a> and the links therein). But I don't see the purpose of this
 library as fixing something that is part of the C++ standard. I humbly
 think it's beyond the scope of this library. Rather, I am
 following the way of the standard in simply providing one more function
@@ -438,7 +439,7 @@ comparisons).</p>
 slower than
 <tt>first_min_element</tt> alone, still much less than <tt>first_min_element</tt>
 and
-<tt>last_max_element</tt> called separately.  <a href="#Note2">[2]</a>
+<tt>last_max_element</tt> called separately.  <a href="#Performance">[2]</a>
 
 <h4><b>Why algorithms and not accumulators?</b></h4>
 <p>The minmax algorithms are useful in computing the extent of a range.

minmax/test/Jamfile

@@ -0,0 +1,33 @@
+# Boost.Minmax Library Test Jamfile
+#
+# Copyright (C) 2002--2004, Herve Bronnimann
+#
+# 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)
+#
+
+subproject libs/algorithm/minmax/test ;
+
+# bring in rules for testing
+import testing ;
+
+# Make tests run by default.
+DEPENDS all : test ;
+
+{
+  test-suite algorithm/minmax
+        : [ run
+                minmax_element_test.cpp
+              : :
+                :
+                : minmax_element
+            ]
+          [ run
+                minmax_test.cpp
+              : :
+                :
+                : minmax
+            ]
+  ;
+}

minmax/test/minmax_test.cpp

@@ -54,23 +54,23 @@ void test(BOOST_EXPLICIT_TEMPLATE_TYPE(Value))
   less_count<Value> lc(counter);
 
   // Test functionality
-  tuple<Value const&, Value const&> result1 = boost::minmax(zero, one);
+  tuple<Value const&, Value const&> result1 = minmax(zero, one);
   BOOST_CHECK_EQUAL( get<0>(result1), zero );
   BOOST_CHECK_EQUAL( get<1>(result1), one );
 
-  tuple<Value const&, Value const&> result2 = boost::minmax(one, zero);
+  tuple<Value const&, Value const&> result2 = minmax(one, zero);
   BOOST_CHECK_EQUAL( get<0>(result2), zero );
   BOOST_CHECK_EQUAL( get<1>(result2), one );
   
   // Test functionality and number of comparisons
   lc.reset();
-  tuple<Value const&, Value const&> result3 = boost::minmax(zero, one, lc );
+  tuple<Value const&, Value const&> result3 = minmax(zero, one, lc );
   BOOST_CHECK_EQUAL( get<0>(result3), zero );
   BOOST_CHECK_EQUAL( get<1>(result3), one );
   BOOST_CHECK_EQUAL( counter, 1 );
 
   lc.reset();
-  tuple<Value const&, Value const&> result4 = boost::minmax(one, zero, lc );
+  tuple<Value const&, Value const&> result4 = minmax(one, zero, lc );
   BOOST_CHECK_EQUAL( get<0>(result4), zero );
   BOOST_CHECK_EQUAL( get<1>(result4), one );
   BOOST_CHECK_EQUAL( counter, 1);

string/doc/Jamfile.v2

@@ -10,11 +10,7 @@
 import toolset ;
 toolset.using doxygen ;
 
-boostbook string_algo : string_algo.xml autodoc 
+boostbook string_algo : string_algo.xml ;
-	:
-        <xsl:param>boost.root=../../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-	;
 
 doxygen autodoc
     :   
@@ -35,15 +31,12 @@ doxygen autodoc
     [ glob ../../../../boost/algorithm/string/trim.hpp ]
     [ glob ../../../../boost/algorithm/string/predicate.hpp ]
     [ glob ../../../../boost/algorithm/string/split.hpp ]
-    [ glob ../../../../boost/algorithm/string/iter_find.hpp ]
     [ glob ../../../../boost/algorithm/string/erase.hpp ]
-    [ glob ../../../../boost/algorithm/string/join.hpp ]
     [ glob ../../../../boost/algorithm/string/replace.hpp ]
     [ glob ../../../../boost/algorithm/string/find_format.hpp ]
     [ glob ../../../../boost/algorithm/string/formatter.hpp ]
     [ glob ../../../../boost/algorithm/string/regex.hpp ]
     [ glob ../../../../boost/algorithm/string/regex_find_format.hpp ]
-    [ glob ../../../../boost/algorithm/string/trim_all.hpp ]
     :
     <doxygen:param>HIDE_UNDOC_MEMBERS=YES
     <doxygen:param>EXTRACT_PRIVATE=NO

string/doc/concept.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.concept" last-revision="$Date$">
     <title>Concepts</title>
 
@@ -102,7 +96,7 @@
 struct simple_finder
 {
     template&lt;typename ForwardIteratorT&gt;
-    boost::iterator_range&lt;ForwardIteratorT&gt; operator()(
+    boost::iterator_range&lt;ForwardIterator&gt; operator()(
         ForwardIteratorT Begin,
         ForwardIteratorT End )
     {

string/doc/credits.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.credits" last-revision="$Date$">
     <title>Credits</title>
     <section id="string_algo.ack">

string/doc/design.xml

@@ -1,13 +1,6 @@
 <?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">
-
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.design" last-revision="$Date$">
     <title>Design Topics</title>
 
@@ -25,7 +18,7 @@
         </para>
         <para>
             <emphasis role="bold">Definition:</emphasis> A string is a 
-            <ulink url="../../libs/range/index.html">range</ulink> of characters accessible in sequential
+            <ulink url="../../libs/range/doc/range.html">range</ulink> of characters accessible in sequential
             ordered fashion. Character is any value type with "cheap" copying and assignment.                
         </para>
         <para>
@@ -217,7 +210,7 @@
         </para>
         <para>
             For more information about the exception safety topics, follow this 
-            <ulink url="http://www.boost.org/more/generic_exception_safety.html">link</ulink>
+            <ulink url="../../more/generic_exception_safety.html">link</ulink>
         </para>        
     </section>
 </section>

string/doc/environment.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.env" last-revision="$Date$">
     <title>Environment</title>
     <section>

string/doc/external_concepts.html

@@ -32,9 +32,7 @@
             free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
                 int bar( T& ); <br>
              foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
-<br>Use, modification and distribution is subject to the Boost
+    Permission to copy, use, modify, sell and distribute this software is granted provided this copyright notice appears
- Software License, Version 1.0. (See accompanying file
+     in all copies. This software is provided "as is" without express or implied warranty, and with no
- <code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+         claim as to its suitability for any purpose.</p><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br></body></html>
-</br>
+ <!-- Copyright Dezide Aps 2003-2004 -->
-</p>
- <!-- Copyright Dezide Aps 2003-2004 -->

string/doc/intro.xml

@@ -1,13 +1,6 @@
 <?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">
-
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.intro" last-revision="$Date$">
     <title>Introduction</title>
 

string/doc/quickref.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.quickref" last-revision="$Date$">
     <title>Quick Reference</title>
 
@@ -149,16 +143,6 @@
                             <functionname>iequals()</functionname>
                         </entry>
                     </row>
-                    <row>
-                        <entry><code>lexicographical_compare</code></entry>
-                        <entry>Check if a string is lexicographically less then another one</entry>
-                        <entry>
-                            <functionname>lexicographical_compare()</functionname>
-                            <sbr/>
-                            <functionname>ilexicographical_compare()</functionname>
-                        </entry>
-                    </row>
-
                     <row>
                         <entry><code>all</code></entry>
                         <entry>Check if all elements of a string satisfy the given predicate</entry>
@@ -434,55 +418,13 @@
                             <functionname>find_all_regex()</functionname>
                         </entry>
                     </row>
-                    <row>
+                        <row>
                         <entry>split</entry>
                         <entry>Split input into parts</entry>
                         <entry>
                             <functionname>split()</functionname>
                             <sbr/>
                             <functionname>split_regex()</functionname>
-                        </entry>
-					</row>
-					<row>
-						<entry>iter_find</entry>
-						<entry>Iteratively apply the finder to the input to find all matching substrings</entry>
-						<entry>
-							<functionname>iter_find()</functionname>
-						</entry>
-					</row>
-					<row>
-						<entry>iter_split</entry>
-						<entry>Use the finder to find matching substrings in the input and use them as separators to split the input into parts</entry>
-						<entry>
-							<functionname>iter_split()</functionname>
-						</entry>
-					</row>
-                </tbody>
-            </tgroup>
-        </table>
-        <table>
-            <title>Join</title>
-            <tgroup cols="3" align="left">
-                <thead>
-                    <row>
-                        <entry>Algorithm name</entry>
-                        <entry>Description</entry>
-                        <entry>Functions</entry>
-                    </row>
-                </thead>
-                <tbody>
-                    <row>
-                        <entry>join</entry>
-                        <entry>Join all elements in a container into a single string</entry>
-                        <entry>
-                            <functionname>join</functionname>
-                        </entry>
-                    </row>
-                        <row>
-                        <entry>join_if</entry>
-                        <entry>Join all elements in a container that satisfies the condition into a single string</entry>
-                        <entry>
-                            <functionname>join_if()</functionname>
                         </entry>
                    </row>
                 </tbody>
@@ -737,20 +679,6 @@
                             <functionname>is_xdigit()</functionname>
                         </entry>
                     </row>
-                    <row>
-                        <entry>is_any_of</entry>
-                        <entry>Recognize any of a sequence of characters</entry>
-                        <entry>
-                            <functionname>is_any_of()</functionname>
-                        </entry>
-                    </row>
-                    <row>
-                        <entry>is_from_range</entry>
-                        <entry>Recognize characters inside a min..max range</entry>
-                        <entry>
-                            <functionname>is_from_range()</functionname>
-                        </entry>
-                    </row>
                 </tbody>
             </tgroup>
         </table>

string/doc/rationale.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.rationale" last-revision="$Date$">
     <title>Rationale</title>
 

string/doc/release_notes.xml

@@ -1,17 +1,7 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <section id="string_algo.release_notes" last-revision="$Date$">
-
-    <using-namespace name="boost"/>
-    <using-namespace name="boost::algorithm"/>
-
     <title>Release Notes</title>
 
     <itemizedlist>
@@ -23,23 +13,5 @@
             <para><emphasis role="bold">1.33</emphasis></para>
             <para>Internal version of collection traits removed, library adapted to Boost.Range</para>
         </listitem>
-        <listitem>
-            <para><emphasis role="bold">1.34</emphasis></para>
-            <itemizedlist>
-                <listitem>
-                    <functionname>lexicographical_compare()</functionname>
-                </listitem>
-                <listitem>
-                    <functionname>join()</functionname> and <functionname>join_if()</functionname> 
-                </listitem>
-                <listitem>
-                    New comparison predicates <code>is_less</code>, <code>is_not_greater</code>
-                </listitem>
-                <listitem>
-                     Negative indexes support (like Perl) in various algorihtms
-                     (<code>*_head/tail</code>, <code>*_nth</code>).
-                </listitem>                                      
-            </itemizedlist>
-        </listitem>
     </itemizedlist>
 </section>

string/doc/string_algo.xml

@@ -1,12 +1,6 @@
 <?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">
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
 <library name="String Algorithms" dirname="algorithm/string" xmlns:xi="http://www.w3.org/2001/XInclude" 
     id="string_algo" last-revision="$Date$">
     <libraryinfo>
@@ -33,7 +27,7 @@
         <librarypurpose>
             A set of generic string-related algorithms and utilities
         </librarypurpose> 
-        <librarycategory name="category:algorithms"/>
+        <librarycategory name="category:algoritms"/>
         <librarycategory name="category:string-text"/>
     </libraryinfo>
 
@@ -44,7 +38,7 @@
     <xi:include href="quickref.xml"/>
     <xi:include href="design.xml"/>
     <xi:include href="concept.xml"/>
-    <xi:include href="autodoc.xml"/>
+    <xi:include href="autodoc.boostbook"/>
     <xi:include href="rationale.xml"/>
     <xi:include href="environment.xml"/>
     <xi:include href="credits.xml"/>

string/doc/usage.xml

@@ -1,14 +1,6 @@
 <?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">
-
-
-<!-- Copyright (c) 2002-2006 Pavol Droba.
-     Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
--->
-
-
 <section id="string_algo.usage" last-revision="$Date$">
     <title>Usage</title>
 
@@ -57,7 +49,7 @@
                     The magic of <ulink url="../../libs/range/index.html">Boost.Range</ulink> 
                     provides a uniform way of handling different string types. 
                     If there is a need to pass a pair of iterators, 
-                    <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
+                    <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>
                     can be used to package iterators into a structure with a compatible interface.
                 </para>
             </listitem>
@@ -130,7 +122,7 @@
     string str1("command.com");
     cout 
         &lt;&lt; str1
-        &lt;&lt; (is_executable("command.com")? "is": "is not") 
+        &lt;&lt; is_executable("command.com")? "is": "is not" 
         &lt;&lt; "an executable" 
         &lt;&lt; endl; // prints "command.com is an executable"
     
@@ -138,7 +130,7 @@
     char text1[]="hello world!";
     cout 
         &lt;&lt; text1 
-        &lt;&lt; (all( text1, is_lower() )? "is": "is not")
+        &lt;&lt; all( text1, is_lower() )? "is": "is not"
         &lt;&lt; " written in the lower case" 
         &lt;&lt; endl; // prints "hello world! is written in the lower case"
         </programlisting>
@@ -169,7 +161,7 @@
         <programlisting>
     string str1="     hello world!     ";
     string str2=trim_left_copy(str1);   // str2 == "hello world!     "
-    string str3=trim_right_copy(str1);  // str3 == "     hello world!"
+    string str3=trim_right_copy(str2);  // str3 == "     hello world!"
     trim(str1);                         // str1 == "hello world!"
 
     string phone="00423333444";
@@ -208,16 +200,16 @@
         </programlisting>
         <para>
             We have used <functionname>find_last()</functionname> to search the <code>text</code> for "ll".
-            The result is given in the <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>. 
+            The result is given in the <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>. 
             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 
-            <ulink url="../../libs/range/index.html">Boost.Range</ulink>.
+            <ulink linkend="../../libs/range/doc/index.html">Boost.Range</ulink>.
 
             The following lines transform the result. Notice that 
-            <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> has familiar 
+            <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> has familiar 
             <code>begin()</code> and <code>end()</code> methods, so it can be used like any other STL container.
             Also it is convertible to bool therefore it is easy to use find algorithms for a simple containment checking.
         </para>
@@ -264,7 +256,7 @@
             the find iterator allows us to iterate over the substrings matching the specified criteria.
             This facility is using the <link linkend="string_algo.finder_concept">Finder</link> to incrementally
             search the string. 
-            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> 
+            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> 
             object, that delimits the current match.
         </para>
         <para>
@@ -291,9 +283,9 @@
     // aBC
     
     typedef split_iterator&lt;string::iterator&gt; string_split_iterator;
-    for(string_split_iterator It=
+    for(string_find_iterator It=
         make_split_iterator(str1, first_finder("-*-", is_iequal()));
-        It!=string_split_iterator();
+        It!=string_find_iterator();
         ++It)
     {
         cout &lt;&lt; copy_range&lt;std::string&gt;(*It) &lt;&lt; endl;
@@ -339,7 +331,7 @@
     typedef vector&lt; string &gt; split_vector_type;
     
     split_vector_type SplitVec; // #2: Search for tokens
-    split( SplitVec, str1, is_any_of("-*"), token_compress_on ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
+    split( SplitVec, str1, is_any_of("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
         </programlisting>
         <para>
             <code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.                       

string/example/Jamfile

@@ -7,12 +7,69 @@
 #
 #  See http://www.boost.org for updates, documentation, and revision history.
 
+subproject libs/algorithm/string/example ;
 
-exe conv_example : conv_example.cpp ;
+exe conv_example
-exe predicate_example : predicate_example.cpp ;
+    :
-exe find_example : find_example.cpp ;
+    conv_example.cpp
-exe replace_example : replace_example.cpp ;
+    :
-exe rle_example : rle_example.cpp ;
+    <include>$(BOOST_ROOT)     
-exe trim_example : trim_example.cpp ;
+    :
-exe regex_example : regex_example.cpp /boost/regex//boost_regex ;
+    ;
-exe split_example : split_example.cpp ;
+
+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/rle_example.cpp

@@ -114,13 +114,10 @@ public:
     result_type operator()( const ReplaceT& Replace ) const
     {
         SeqT r;
-        if(!Replace.empty())
+        r.push_back( repeat_mark<value_type>() );
-        {
+        r.push_back( *(Replace.begin()) );
-            r.push_back( repeat_mark<value_type>() );
+        r.push_back( value_type( Replace.size() ) );
-            r.push_back( *(Replace.begin()) );
+        
-            r.push_back( value_type( Replace.size() ) );
-        }
-
         return r;
     }
 };
@@ -186,18 +183,14 @@ public:
     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 );
-        if(!Replace.empty())
-        {
-            // extract info
-            typename ReplaceT::const_iterator It=Replace.begin();
-
-            value_type Value=*(++It);
-            value_type Repeat=*(++It);
-
-            for( value_type Index=0; Index<Repeat; Index++ ) r.push_back( Value );
-        }
 
         return r;
     }

string/index.html

@@ -4,11 +4,6 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../../doc/html/string_algo.html">../../doc/html/string_algo.html</a> 
+<a href="../../../doc/html/string_algo.html">../../doc/html/string_algo.html</a>
-&nbsp;<hr>
-<p><EFBFBD> Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
-</html>
+</html>

string/test/Jamfile

@@ -0,0 +1,77 @@
+#  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 algorithm/string
+        : [ run 
+                trim_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : trim
+            ]
+          [ run 
+                conv_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : conv
+            ]
+          [ run 
+                predicate_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : predicate
+            ]
+          [ run 
+                find_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : find
+            ]
+          [ run
+                split_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : split
+            ]
+          [ run 
+                replace_test.cpp
+              : :
+                :
+                std::locale-support
+                std::facet-support
+                : replace
+            ]
+          [ run 
+                regex_test.cpp
+                <lib>../../../regex/build/boost_regex
+              : :
+                :   
+                : regex
+            ]
+        ;
+}
+

string/test/Jamfile.v2

@@ -40,12 +40,6 @@ test-suite algorithm/string
             :
             : split
         ]
-      [ run
-            join_test.cpp
-          : :
-            :
-            : join
-        ]
       [ run 
             replace_test.cpp
           : :
@@ -59,11 +53,5 @@ test-suite algorithm/string
             :   
             : regex
         ]
-      [ run 
-            find_format_test.cpp
-          : :
-            :   
-            : find_format
-        ]
     ;
 

string/test/find_format_test.cpp

@@ -1,163 +0,0 @@
-//  Boost string_algo library find_format_test.cpp file  ------------------//
-
-//  Copyright (c) 2009 Steven Watanabe
-//  Distributed under the Boost Software License, Version 1.0. (See
-//  accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <boost/test/test_tools.hpp>
-
-// We're only using const_formatter.
-template<class Formatter>
-struct formatter_result {
-    typedef boost::iterator_range<const char*> type;
-};
-
-template<class Formatter>
-struct checked_formatter {
-public:
-    checked_formatter(const Formatter& formatter) : formatter_(formatter) {}
-    template< typename T >
-    typename formatter_result<Formatter>::type operator()( const T & s ) const {
-        BOOST_CHECK( !s.empty() );
-        return formatter_(s);
-    }
-private:
-    Formatter formatter_;
-};
-
-template<class Formatter>
-checked_formatter<Formatter>
-make_checked_formatter(const Formatter& formatter) {
-    return checked_formatter<Formatter>(formatter);
-}
-
-void find_format_test()
-{
-    const std::string source = "$replace $replace";
-    std::string expected = "ok $replace";
-    std::string output(80, '\0');
-
-    std::string::iterator pos =
-        boost::find_format_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK(pos == output.begin() + expected.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, expected);
-
-    output =
-        boost::find_format_copy(
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-
-    // now try finding a string that doesn't exist
-    output.resize(80);
-    pos =
-        boost::find_format_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK(pos == output.begin() + source.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, source);
-
-    output =
-        boost::find_format_copy(
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-
-    // in place version
-    output = source;
-    boost::find_format(
-        output,
-        boost::first_finder("$replace"),
-        make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-    output = source;
-    boost::find_format(
-        output,
-        boost::first_finder("$noreplace"),
-        make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-}
-
-void find_format_all_test()
-{
-    const std::string source = "$replace $replace";
-    std::string expected = "ok ok";
-    std::string output(80, '\0');
-
-    std::string::iterator pos =
-        boost::find_format_all_copy(output.begin(),
-                                source,
-                                boost::first_finder("$replace"),
-                                boost::const_formatter("ok"));
-    BOOST_CHECK(pos == output.begin() + expected.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, expected);
-
-    output =
-        boost::find_format_all_copy(
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-
-    // now try finding a string that doesn't exist
-    output.resize(80);
-    pos =
-        boost::find_format_all_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK(pos == output.begin() + source.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, source);
-
-    output =
-        boost::find_format_all_copy(
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-
-    // in place version
-    output = source;
-    boost::find_format_all(
-        output,
-        boost::first_finder("$replace"),
-        make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-    output = source;
-    boost::find_format_all(
-        output,
-        boost::first_finder("$noreplace"),
-        make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-}
-
-int test_main( int, char*[] )
-{
-    find_format_test();
-    find_format_all_test();
-
-    return 0;
-}

string/test/find_test.cpp

@@ -93,33 +93,16 @@ void find_test()
         ( (nc_result.begin()-str1.begin()) == 9) &&
         ( (nc_result.end()-str1.begin()) == 12) );
 
-    nc_result=find_nth( str1, string("abc"), -1 );
-    BOOST_CHECK( 
-        ( (nc_result.begin()-str1.begin()) == 15) &&
-        ( (nc_result.end()-str1.begin()) == 18) );
-
-
     cv_result=find_nth( const_cast<const string&>(str1), str2, 1 );
     BOOST_CHECK( 
         ( (cv_result.begin()-str1.begin()) == 9) &&
         ( (cv_result.end()-str1.begin()) == 12) );
-
-    cv_result=find_nth( const_cast<const string&>(str1), str2, -1 );
-    BOOST_CHECK( 
-        ( (cv_result.begin()-str1.begin()) == 15) &&
-        ( (cv_result.end()-str1.begin()) == 18) );
         
     cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
     BOOST_CHECK( 
         ( (cv_result.begin()-str1.begin()) == 12) &&
         ( (cv_result.end()-str1.begin()) == 15) );
 
-    cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
-    BOOST_CHECK( 
-        ( (cv_result.begin()-str1.begin()) == 12) &&
-        ( (cv_result.end()-str1.begin()) == 15) );
-
-
     ch_result=find_nth( pch1, "abc", 1 );
     BOOST_CHECK(( (ch_result.begin() - pch1 ) == 9) && ( (ch_result.end() - pch1 ) == 12 ) );
 
@@ -131,11 +114,6 @@ void find_test()
         ( (nc_result.begin()-str1.begin()) == 0) &&
         ( (nc_result.end()-str1.begin()) == 6) );
 
-    nc_result=find_head( str1, -6 );
-    BOOST_CHECK( 
-        ( (nc_result.begin()-str1.begin()) == 0) &&
-        ( (str1.end()-nc_result.end()) == 6 ) );
-
     cv_result=find_head( const_cast<const string&>(str1), 6 );
     BOOST_CHECK( 
         ( (cv_result.begin()-str1.begin()) == 0) &&
@@ -152,12 +130,6 @@ void find_test()
         ( (nc_result.begin()-str1.begin()) == 15) &&
         ( (nc_result.end()-str1.begin()) == 21) );
 
-    nc_result=find_tail( str1, -6 );
-    BOOST_CHECK( 
-        ( (nc_result.begin()-str1.begin()) == 6) &&
-        ( (nc_result.end()-str1.begin()) == 21) );
-
-
     cv_result=find_tail( const_cast<const string&>(str1), 6 );
     BOOST_CHECK( 
         ( (cv_result.begin()-str1.begin()) == 15) &&

string/test/join_test.cpp

@@ -1,79 +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 <boost/algorithm/string/join.hpp>
-#include <boost/algorithm/string/classification.hpp>
-// equals predicate is used for result comparison
-#include <boost/algorithm/string/predicate.hpp>
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <string>
-#include <vector>
-#include <iostream>
-
-#include <boost/test/test_tools.hpp>
-
-
-using namespace std;
-using namespace boost;
-
-bool is_not_empty(const std::string& str)
-{
-    return !str.empty();
-}
-
-void join_test()
-{
-    // Prepare inputs
-    vector<string> tokens1;
-    tokens1.push_back("xx");
-    tokens1.push_back("abc");
-    tokens1.push_back("xx");
-
-    vector<string> tokens2;
-    tokens2.push_back("");
-    tokens2.push_back("xx");
-    tokens2.push_back("abc");
-    tokens2.push_back("");
-    tokens2.push_back("abc");
-    tokens2.push_back("xx");
-    tokens2.push_back("");
-
-    vector<string> tokens3;
-    tokens3.push_back("");
-    tokens3.push_back("");
-    tokens3.push_back("");
-
-    vector<string> empty_tokens;
-
-    vector<vector<int> > vtokens;
-    for(unsigned int n=0; n<tokens2.size(); ++n)
-    {
-        vtokens.push_back(vector<int>(tokens2[n].begin(), tokens2[n].end()));
-    }
-
-    BOOST_CHECK( equals(join(tokens1, "-"), "xx-abc-xx") );
-    BOOST_CHECK( equals(join(tokens2, "-"), "-xx-abc--abc-xx-") );
-    BOOST_CHECK( equals(join(vtokens, "-"), "-xx-abc--abc-xx-") );
-    BOOST_CHECK( equals(join(empty_tokens, "-"), "") );
-
-    BOOST_CHECK( equals(join_if(tokens2, "-", is_not_empty), "xx-abc-abc-xx") );
-    BOOST_CHECK( equals(join_if(empty_tokens, "-", is_not_empty), "") );
-    BOOST_CHECK( equals(join_if(tokens3, "-", is_not_empty), "") );
-}
-
-// test main 
-int test_main( int, char*[] )
-{
-    join_test();
-    
-    return 0;
-}

string/test/predicate_test.cpp

@@ -56,14 +56,6 @@ void predicate_test()
     BOOST_CHECK( iequals( "AbC", "abc" ) );
     BOOST_CHECK( !iequals( "aBc", "yyy" ) );
 
-    BOOST_CHECK( lexicographical_compare("abc", "abd") );
-    BOOST_CHECK( !lexicographical_compare("abc", "abc") );
-    BOOST_CHECK( lexicographical_compare("abc", "abd", is_less()) );
-
-    BOOST_CHECK( !ilexicographical_compare("aBD", "AbC") );
-    BOOST_CHECK( ilexicographical_compare("aBc", "AbD") );
-    BOOST_CHECK( lexicographical_compare("abC", "aBd", is_iless()) );
-
     // multi-type comparison test
     BOOST_CHECK( starts_with( vec1, string("123") ) );
     BOOST_CHECK( ends_with( vec1, string("321") ) );
@@ -93,32 +85,12 @@ void predicate_test()
     BOOST_CHECK( ends_with( "123xxx321", "321" ) );
     BOOST_CHECK( contains( "123xxx321", "xxx" ) );
     BOOST_CHECK( equals( "123xxx321", "123xxx321" ) );
-
-}
-
-template<typename Pred, typename Input>
-void test_pred(const Pred& pred, const Input& input, bool bYes)
-{
-    // test assignment operator
-    Pred pred1=pred;
-    pred1=pred;
-    pred1=pred1;
-    if(bYes)
-    {
-        BOOST_CHECK( all( input, pred ) );
-        BOOST_CHECK( all( input, pred1 ) );
-    }
-    else
-    {
-        BOOST_CHECK( !all( input, pred ) );
-        BOOST_CHECK( !all( input, pred1 ) );
-    }
 }
 
 #define TEST_CLASS( Pred, YesInput, NoInput )\
 {\
-    test_pred(Pred, YesInput, true); \
+    BOOST_CHECK( all( string(YesInput), Pred ) );\
-    test_pred(Pred, NoInput, false); \
+    BOOST_CHECK( !all( string(NoInput), Pred ) );\
 }
 
 void classification_test()
@@ -140,14 +112,6 @@ void classification_test()
 
     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" );
-
-    // is_any_of test
-//  TEST_CLASS( !is_any_of(""), "", "aaa" )
-    TEST_CLASS( is_any_of("a"), "a", "ab" )
-    TEST_CLASS( is_any_of("ba"), "ab", "abc" )
-    TEST_CLASS( is_any_of("cba"), "abc", "abcd" )
-    TEST_CLASS( is_any_of("hgfedcba"), "abcdefgh", "abcdefghi" )
-    TEST_CLASS( is_any_of("qponmlkjihgfedcba"), "abcdefghijklmnopq", "zzz" )
 }
 
 #undef TEST_CLASS

string/test/regex_test.cpp

@@ -8,11 +8,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/algorithm/string/regex.hpp>
-#include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/sequence_traits.hpp>
-// equals predicate is used for result comparison
-#include <boost/algorithm/string/predicate.hpp>
-
 
 // Include unit test framework
 #include <boost/test/included/test_exec_monitor.hpp>
@@ -87,23 +83,6 @@ static void find_test()
 
 }
 
-static void join_test()
-{
-    // Prepare inputs
-    vector<string> tokens1;
-    tokens1.push_back("xx");
-    tokens1.push_back("abc");
-    tokens1.push_back("xx");
-
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    BOOST_CHECK( equals(join_if(tokens1, "-", regex("x+")), "xx-xx") );
-    BOOST_CHECK( equals(join_if(tokens1, "-", regex("[abc]+")), "abc") );
-#else 
-    BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("x+")), "xx-xx") );
-    BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("[abc]+")), "abc") );
-#endif 
-}
-
 static void replace_test()
 {
     string str1("123a1cxxxa23cXXXa456c321");
@@ -152,7 +131,6 @@ static void replace_test()
 int test_main( int, char*[] )
 {
     find_test();
-    join_test();
     replace_test();
 
     return 0;

string/test/replace_test.cpp

@@ -11,9 +11,6 @@
 #include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/std/list_traits.hpp>
 #include <boost/algorithm/string/std/string_traits.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-#include <boost/algorithm/string/classification.hpp>
 
 // Include unit test framework
 #include <boost/test/included/test_exec_monitor.hpp>
@@ -123,7 +120,6 @@ void replace_all_test()
 {
     // replace all
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3YYY2") );
-    TEST_ALGO( replace_all, string("1abc3abc2"), "/" C_ "\\", string("1abc3abc2") );
     TEST_ALGO( ireplace_all, "1aBc3AbC2", "abC" C_ "YYY", string("1YYY3YYY2") );
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3Z2") );
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3XXXX2") );
@@ -140,27 +136,17 @@ void replace_nth_test()
 {
     // replace nth
     TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("YYY"), string("1YYY3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ -1 C_ string("YYY"), string("1abc3YYY2") );
     TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ 0 C_ "YYY", string("1YYY3abc2") );
-    TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ -1 C_ "YYY", string("1AbC3YYY2") );
     TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("Z"), string("1Z3abc2") );
     TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("XXXX"), string("1XXXX3abc2") );
     TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 0 C_ "XXXX", string("1XXXX3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 3 C_ "XXXX", string("1abc3abc2") );
-    TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ -3 C_ "XXXX", string("1abc3abc2") );
     TEST_ALGO( replace_nth, "1abc3abc2", string("") C_ 0 C_ string("XXXX"), string("1abc3abc2") );
     TEST_ALGO( replace_nth, "", string("") C_ 0 C_ string("XXXX"), string("") );
-    TEST_ALGO( replace_nth, "", string("") C_ -1 C_ string("XXXX"), string("") );
     TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ 0, string("13abc2") );
-    TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -1, string("1abc32") );
-    TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -3, string("1abc3abc2") );
     TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ 0, string("13aBc2") );
-    TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -1, string("1aBc32") );
-    TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -3, string("1aBc3aBc2") );
     TEST_ALGO( erase_nth, "1abc3abc2", "abc" C_ 0, string("13abc2") );
     TEST_ALGO( erase_nth, "1abc3abc2", string("") C_ 0, string("1abc3abc2") );
     TEST_ALGO( erase_nth, "", string("abc") C_ 0, string("") );
-    TEST_ALGO( erase_nth, "", string("abc") C_ -1, string("") );
     TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 1 C_ string("YYY"), string("1abc3YYY2") );
     TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 2 C_ string("YYY"), string("1abc3abc2") );
 }
@@ -169,37 +155,28 @@ void replace_head_test()
 {
     // replace head
     TEST_ALGO( replace_head, "abc3abc2", 3 C_ string("YYY"), string("YYY3abc2") );
-    TEST_ALGO( replace_head, "abc3abc2", -3 C_ string("YYY"), string("YYYbc2") );
     TEST_ALGO( replace_head, "abc3abc2", 3 C_ "YYY", string("YYY3abc2") );
     TEST_ALGO( replace_head, "abc", 3 C_ string("Z"), string("Z") );
     TEST_ALGO( replace_head, "abc", 6 C_ string("XXXX"), string("XXXX") );
-    TEST_ALGO( replace_head, "abc", -6 C_ string("XXXX"), string("abc") );
     TEST_ALGO( replace_head, "abc3abc2", 0 C_ string("XXXX"), string("abc3abc2") );
     TEST_ALGO( replace_head, "", 4 C_ string("XXXX"), string("") );
-    TEST_ALGO( replace_head, "", -4 C_ string("XXXX"), string("") );
     TEST_ALGO( erase_head, "abc3abc2", 3, string("3abc2") );
-    TEST_ALGO( erase_head, "abc3abc2", -3, string("bc2") );
     TEST_ALGO( erase_head, "abc3abc2", 0, string("abc3abc2") );
     TEST_ALGO( erase_head, "", 4, string("") );
-    TEST_ALGO( erase_head, "", -4, string("") );
 }
 
 void replace_tail_test()
 {
     // replace tail
     TEST_ALGO( replace_tail, "abc3abc", 3 C_ string("YYY"), string("abc3YYY") );
-    TEST_ALGO( replace_tail, "abc3abc", -3 C_ "YYY", string("abcYYY") );
+    TEST_ALGO( replace_tail, "abc3abc", 3 C_ "YYY", string("abc3YYY") );
     TEST_ALGO( replace_tail, "abc", 3 C_ string("Z"), string("Z") );
     TEST_ALGO( replace_tail, "abc", 6 C_ string("XXXX"), string("XXXX") );
-    TEST_ALGO( replace_tail, "abc", -6 C_ string("XXXX"), string("abc") );
     TEST_ALGO( replace_tail, "abc3abc", 0 C_ string("XXXX"), string("abc3abc") );
     TEST_ALGO( replace_tail, "", 4 C_ string("XXXX"), string("") );
-    TEST_ALGO( replace_tail, "", -4 C_ string("XXXX"), string("") );
     TEST_ALGO( erase_tail, "abc3abc", 3, string("abc3") );
-    TEST_ALGO( erase_tail, "abc3abc", -3, string("abc") );
     TEST_ALGO( erase_tail, "abc3abc", 0, string("abc3abc") );
     TEST_ALGO( erase_tail, "", 4, string("") );
-    TEST_ALGO( erase_tail, "", -4, string("") );
 }
 
 void replace_range_test()
@@ -288,23 +265,6 @@ void collection_comp_test()
     }   
 }
 
-void dissect_format_test()
-{
-    BOOST_CHECK(
-        find_format_all_copy(
-            string("aBc123Abc"), 
-            first_finder("abc", is_iequal()), 
-            dissect_formatter(token_finder(is_upper())))=="B123A");
-
-
-    BOOST_CHECK(
-        find_format_all_copy(
-            string("abc   123   abc"),
-            token_finder(is_space(), token_compress_on),
-            dissect_formatter(head_finder(1)))=="abc 123 abc");
-
-}
-
 // test main 
 int test_main( int, char*[] )
 {
@@ -317,7 +277,6 @@ int test_main( int, char*[] )
     replace_tail_test();
     replace_range_test();
     collection_comp_test();
-    dissect_format_test();
 
     return 0;
 }

string/test/split_test.cpp

@@ -40,7 +40,6 @@ void iterator_test()
     string str1("xx-abc--xx-abb");
     string str2("Xx-abc--xX-abb-xx");
     string str3("xx");
-    string strempty("");
     const char* pch1="xx-abc--xx-abb";
     vector<string> tokens;
     vector< vector<int> > vtokens;
@@ -123,45 +122,6 @@ void iterator_test()
     BOOST_CHECK( tokens[2]==string("") );
     BOOST_CHECK( tokens[3]==string("xx") );
     BOOST_CHECK( tokens[4]==string("abb") );
-
-    split(
-        tokens,
-        str3,
-        is_any_of(","),
-        token_compress_off);
-
-    BOOST_REQUIRE( tokens.size()==1 );
-    BOOST_CHECK( tokens[0]==string("xx") );
-
-    split(
-        tokens,
-        strempty,
-        is_punct(),
-        token_compress_off);
-
-    BOOST_REQUIRE( tokens.size()==1 );
-    BOOST_CHECK( tokens[0]==string("") );
-
-
-    find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
-    BOOST_CHECK(equals(*fiter, "xx"));
-    ++fiter;
-    BOOST_CHECK(equals(*fiter, "xx"));
-    ++fiter;
-    BOOST_CHECK(fiter==find_iterator<string::iterator>());
-
-    split_iterator<string::iterator> siter=make_split_iterator(str1, token_finder(is_any_of("-"), token_compress_on));
-    BOOST_CHECK(equals(*siter, "xx"));
-    ++siter;
-    BOOST_CHECK(equals(*siter, "abc"));
-    ++siter;
-    BOOST_CHECK(equals(*siter, "xx"));
-    ++siter;
-    BOOST_CHECK(equals(*siter, "abb"));
-    ++siter;
-    BOOST_CHECK(siter==split_iterator<string::iterator>(siter));
-    BOOST_CHECK(siter==split_iterator<string::iterator>());
-
 }
 
 // test main 

string/test/trim_test.cpp

@@ -8,7 +8,6 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <boost/algorithm/string/trim.hpp>
-#include <boost/algorithm/string/trim_all.hpp>
 
 // Include unit test framework
 #include <boost/test/included/test_exec_monitor.hpp>
@@ -110,95 +109,10 @@ void trim_test()
     BOOST_CHECK( trim_copy_if( string("<>abc<>"), is_any_of( "<<>>" ) )=="abc" );
 }
 
-void trim_all_test()
-{
-    string str1("     1x   x   x   x1     ");
-    string str2("+---...2x+--x--+x-+-x2...---+");
-    string str3("    ");
-
-    // *** value passing tests *** //
-
-    // general string test
-    BOOST_CHECK( trim_all_copy( str1 )=="1x x x x1" ) ;
-    BOOST_CHECK( trim_all_copy_if( str2, is_punct() )=="2x+x-x-x2" ) ;
-
-    // spaces-only string test
-    BOOST_CHECK( trim_all_copy( str3 )=="" );
-
-    // empty string check 
-    BOOST_CHECK( trim_all_copy( string("") )=="" );
-
-    // general string test
-    trim_all( str1 );
-    BOOST_CHECK( str1=="1x x x x1" ) ;
-    trim_all_if( str2, is_punct() );
-    BOOST_CHECK( str2=="2x+x-x-x2" ) ;
-    
-    // spaces-only string test
-    str3 = "    "; trim_all( str3 );
-    BOOST_CHECK( str3=="" );
-
-    // empty string check 
-    str3 = ""; trim_all( str3 );
-    BOOST_CHECK( str3=="" );
-    BOOST_CHECK( str3=="" );
-
-    // *** non-standard predicate tests *** //
-    BOOST_CHECK( 
-        trim_all_copy_if( 
-            string("123abc127deb456"), 
-            is_classified(std::ctype_base::digit) )=="abc1deb" );
-    BOOST_CHECK( trim_all_copy_if( string("<>abc<>def<>"), is_any_of( "<<>>" ) )=="abc<def" );
-}
-
-void trim_fill_test()
-{
-    string str1("     1x   x   x   x1     ");
-    string str2("+---...2x+--x--+x-+-x2...---+");
-    string str3("    ");
-
-    // *** value passing tests *** //
-
-    // general string test
-    BOOST_CHECK( trim_fill_copy( str1, "-" )=="1x-x-x-x1" ) ;
-    BOOST_CHECK( trim_fill_copy_if( str2, " ", is_punct() )=="2x x x x2" ) ;
-
-    // spaces-only string test
-    BOOST_CHECK( trim_fill_copy( str3, " " )=="" );
-
-    // empty string check 
-    BOOST_CHECK( trim_fill_copy( string(""), " " )=="" );
-
-    // general string test
-    trim_fill( str1, "-" );
-    BOOST_CHECK( str1=="1x-x-x-x1" ) ;
-    trim_fill_if( str2, "", is_punct() );
-    BOOST_CHECK( str2=="2xxxx2" ) ;
-
-    // spaces-only string test
-    str3 = "    "; trim_fill( str3, "" );
-    BOOST_CHECK( str3=="" );
-
-    // empty string check 
-    str3 = ""; trim_fill( str3, "" );
-    BOOST_CHECK( str3=="" );
-    BOOST_CHECK( str3=="" );
-
-    // *** non-standard predicate tests *** //
-    BOOST_CHECK( 
-        trim_fill_copy_if( 
-        string("123abc127deb456"), 
-        "+",
-        is_classified(std::ctype_base::digit) )=="abc+deb" );
-    BOOST_CHECK( trim_fill_copy_if( string("<>abc<>def<>"), "-", is_any_of( "<<>>" ) )=="abc-def" );
-}
-
 // test main 
 int test_main( int, char*[] )
 {
     trim_test();
-    trim_all_test();
+    
-    trim_fill_test();
-
     return 0;
 }