Release 1.48.0

[SVN r75495]

include/boost/algorithm/minmax.hpp

@@ -1,7 +1,7 @@
 //  (C) Copyright Herve Bronnimann 2004.
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// 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:

include/boost/algorithm/minmax_element.hpp

@@ -1,7 +1,7 @@
 //  (C) Copyright Herve Bronnimann 2004.
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// 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:

include/boost/algorithm/string.hpp

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

include/boost/algorithm/string/classification.hpp

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

include/boost/algorithm/string/compare.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library compare.hpp header file  -------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_COMPARE_HPP
 #define BOOST_STRING_COMPARE_HPP
@@ -67,7 +68,7 @@ namespace boost {
                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)==std::toupper(Arg2);
                 #else
-                    return std::toupper(Arg1,m_Loc)==std::toupper(Arg2,m_Loc);
+                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
                 #endif
             }
 
@@ -120,7 +121,7 @@ namespace boost {
                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<std::toupper(Arg2);
                 #else
-                    return std::toupper(Arg1,m_Loc)<std::toupper(Arg2,m_Loc);
+                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
                 #endif
             }
 
@@ -173,7 +174,7 @@ namespace boost {
                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<=std::toupper(Arg2);
                 #else
-                    return std::toupper(Arg1,m_Loc)<=std::toupper(Arg2,m_Loc);
+                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
                 #endif
             }
 

include/boost/algorithm/string/concept.hpp

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

include/boost/algorithm/string/config.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library config.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library constants.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library string_funct.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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
@@ -20,12 +21,17 @@ namespace boost {
 
 //  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
@@ -33,11 +39,11 @@ namespace boost {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::tolower( Ch);
                     #else
-                        return std::tolower( Ch, m_Loc );
+                        return std::tolower<CharT>( Ch, *m_Loc );
                     #endif
                 }
             private:
-                const std::locale& m_Loc;
+                const std::locale* m_Loc;
             };
 
             // a toupper functor
@@ -45,7 +51,7 @@ 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
@@ -53,13 +59,60 @@ namespace boost {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::toupper( Ch);
                     #else
-                        return std::toupper( Ch, m_Loc );
+                        return std::toupper<CharT>( 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,11 +1,12 @@
 //  Boost string_algo library classification.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
 #define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
@@ -14,7 +15,6 @@
 #include <algorithm>
 #include <functional>
 #include <locale>
-#include <set>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -28,17 +28,16 @@ namespace boost {
 
 //  classification functors -----------------------------------------------//
 
-            // is_classified functor
+   // is_classified functor
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
             {
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+                // Boost.ResultOf support
+                typedef bool result_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
@@ -46,7 +45,7 @@ namespace boost {
                     return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                 }
 
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
                     template<>
                     bool operator()( char const Ch ) const
                     {
@@ -55,10 +54,11 @@ namespace boost {
                 #endif
 
             private:
-                const std::ctype_base::mask m_Type;
-                const std::locale m_Locale;
+                std::ctype_base::mask m_Type;
+                std::locale m_Locale;
             };
 
+
             // is_any_of functor
             /*
                 returns true if the value is from the specified set
@@ -67,25 +67,181 @@ namespace boost {
             struct is_any_ofF :
                 public predicate_facade<is_any_ofF<CharT> >
             {
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+            private:
+                // set cannot operate on const value-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_Set( begin(Range), end(Range) ) {}
+                is_any_ofF( const RangeT& Range ) : m_Size(0)
+                {
+                    // 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
+                    ::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
+                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
+
+                    return *this;
+                }
 
                 // Operation
                 template<typename Char2T>
                 bool operator()( Char2T Ch ) const
                 {
-                    return m_Set.find(Ch)!=m_Set.end();
+                    const set_value_type* Storage=
+                        (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:
-                // set cannot operate on const value-type
-                typedef typename remove_const<CharT>::type set_value_type;
-                std::set<set_value_type> m_Set;
+                // storage
+                // The actual used storage is selected on the type
+                union
+                {
+                    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
@@ -97,8 +253,8 @@ namespace boost {
             struct is_from_rangeF :
                 public predicate_facade< is_from_rangeF<CharT> >
             {
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+                // Boost.ResultOf support
+                typedef bool result_type;
 
                 // Constructor
                 is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
@@ -122,8 +278,8 @@ namespace boost {
             {
             public:
 
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+                // Boost.ResultOf support
+                typedef bool result_type;
 
                 // Constructor
                 pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -147,8 +303,8 @@ namespace boost {
                 public predicate_facade< pred_orF<Pred1T,Pred2T> >
             {
             public:
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+                // Boost.ResultOf support
+                typedef bool result_type;
 
                 // Constructor
                 pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -172,8 +328,8 @@ namespace boost {
                 public predicate_facade< pred_notF<PredT> >
             {
             public:
-                // Boost.Lambda support
-                template <class Args> struct sig { typedef bool type; };
+                // Boost.ResultOf support
+                typedef bool result_type;
 
                 // Constructor
                 pred_notF( PredT Pred ) : m_Pred(Pred) {}

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

@@ -1,11 +1,12 @@
 //  Boost string_algo library find_format.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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
@@ -23,39 +24,15 @@ 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 )
@@ -72,51 +49,54 @@ namespace boost {
                 if ( !M )
                 {
                     // Match not found - return original sequence
-                    std::copy( begin(Input), end(Input), Output );
+                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                     return Output;
                 }
 
                 // Copy the beginning of the sequence
-                std::copy( begin(Input), begin(M), Output );
+                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
                 // Format find result
                 // Copy formated result
-                std::copy( begin(M.format_result()), end(M.format_result()), Output );
+                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
                 // Copy the rest of the sequence
-                std::copy( M.end(), end(Input), Output );
+                Output = std::copy( M.end(), ::boost::end(Input), Output );
 
                 return Output;
             }
 
-// find_format_copy implementation --------------------------------------------------//
-
             template< 
-                typename InputT, 
-                typename FinderT,
+                typename OutputIteratorT,
+                typename InputT,
                 typename FormatterT,
                 typename FindResultT >
-            inline InputT find_format_copy_impl(
+            inline OutputIteratorT find_format_copy_impl(
+                OutputIteratorT Output,
                 const InputT& Input,
-                FinderT Finder,
                 FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                return find_format_copy_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                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 );
+                }
             }
 
-            template< 
+ 
+// find_format_copy implementation --------------------------------------------------//
+
+           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)
@@ -138,45 +118,44 @@ namespace boost {
 
                 InputT Output;
                 // Copy the beginning of the sequence
-                insert( Output, end(Output), begin(Input), M.begin() );
+                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
                 // Copy formated result
-                insert( Output, end(Output), M.format_result() );
+                insert( Output, ::boost::end(Output), M.format_result() );
                 // Copy the rest of the sequence
-                insert( Output, end(Output), M.end(), end(Input) );
+                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
 
                 return Output;
             }
 
-// replace implementation ----------------------------------------------------//
-        
-            template<
-                typename InputT,
-                typename FinderT,
+            template< 
+                typename InputT, 
                 typename FormatterT,
                 typename FindResultT >
-            inline void find_format_impl( 
-                InputT& Input,
-                FinderT Finder,
+            inline InputT find_format_copy_impl(
+                const InputT& Input,
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                find_format_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(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,
                 typename FormatResultT >
             inline void find_format_impl2( 
                 InputT& Input,
-                FinderT,
                 FormatterT Formatter,
                 const FindResultT& FindResult,
                 const FormatResultT& FormatResult)
@@ -197,7 +176,25 @@ namespace boost {
                 }
 
                 // Replace match
-                replace( Input, M.begin(), M.end(), M.format_result() );
+                ::boost::algorithm::detail::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,11 +1,12 @@
 //  Boost string_algo library find_format_all.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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
@@ -23,29 +24,7 @@ namespace boost {
 
 // find_format_all_copy (iterator variant) implementation ---------------------------//
 
-            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< 
+           template< 
                 typename OutputIteratorT,
                 typename InputT,
                 typename FinderT,
@@ -72,49 +51,56 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=begin(Input);
+                input_iterator_type LastMatch=::boost::begin(Input);
 
                 // Iterate through all matches
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    std::copy( LastMatch, M.begin(), Output );
+                    Output = std::copy( LastMatch, M.begin(), Output );
                     // Copy formated result
-                    std::copy( begin(M.format_result()), end(M.format_result()), Output );
+                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, end(Input) );
+                    M=Finder( LastMatch, ::boost::end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                std::copy( LastMatch, end(Input), Output );
+                Output = std::copy( LastMatch, ::boost::end(Input), Output );
 
                 return Output;
             }
 
-// find_format_all_copy implementation ----------------------------------------------//
-
             template< 
-                typename InputT, 
+                typename OutputIteratorT,
+                typename InputT,
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline InputT find_format_all_copy_impl(
+            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(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                const FindResultT& FindResult )
+            {   
+                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
+                    return ::boost::algorithm::detail::find_format_all_copy_impl2( 
+                        Output,
+                        Input,
+                        Finder,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
+                } else {
+                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
+                }
             }
 
-            template< 
+ // find_format_all_copy implementation ----------------------------------------------//
+
+           template< 
                 typename InputT, 
                 typename FinderT,
                 typename FormatterT,
@@ -139,7 +125,7 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=begin(Input);
+                input_iterator_type LastMatch=::boost::begin(Input);
 
                 // Output temporary
                 InputT Output;
@@ -148,42 +134,46 @@ namespace boost {
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    insert( Output, end(Output), LastMatch, M.begin() );
+                    insert( Output, ::boost::end(Output), LastMatch, M.begin() );
                     // Copy formated result
-                    insert( Output, end(Output), M.format_result() );
+                    insert( Output, ::boost::end(Output), M.format_result() );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, end(Input) );
+                    M=Finder( LastMatch, ::boost::end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                insert( Output, end(Output), LastMatch, end(Input) );
+                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
 
                 return Output;
             }
 
-// find_format_all implementation ------------------------------------------------//
-        
-            template<
-                typename InputT,
+            template< 
+                typename InputT, 
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline void find_format_all_impl( 
-                InputT& Input,
+            inline InputT find_format_all_copy_impl(
+                const InputT& Input,
                 FinderT Finder,
                 FormatterT Formatter,
-                FindResultT FindResult)
+                const FindResultT& FindResult)
             {
-                find_format_all_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
+                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
+                        Input,
+                        Finder,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
+                } else {
+                    return Input;
+                }
             }
 
+ // find_format_all implementation ------------------------------------------------//
+        
             template<
                 typename InputT,
                 typename FinderT,
@@ -212,8 +202,8 @@ namespace boost {
                     BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
 
                 // Initialize replacement iterators
-                input_iterator_type InsertIt=begin(Input);
-                input_iterator_type SearchIt=begin(Input);
+                input_iterator_type InsertIt=::boost::begin(Input);
+                input_iterator_type SearchIt=::boost::begin(Input);
                 
                 while( M )
                 {
@@ -229,29 +219,50 @@ namespace boost {
                     SearchIt=M.end();
 
                     // Copy formated replace to the storage
-                    copy_to_storage( Storage, M.format_result() );
+                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
 
                     // Find range for a next match
-                    M=Finder( SearchIt, end(Input) );
+                    M=Finder( SearchIt, ::boost::end(Input) );
                 }
 
                 // process the last segment
-                InsertIt=process_segment( 
+                InsertIt=::boost::algorithm::detail::process_segment( 
                     Storage,
                     Input,
                     InsertIt,
                     SearchIt,
-                    end(Input) );
+                    ::boost::end(Input) );
                 
                 if ( Storage.empty() )
                 {
                     // Truncate input
-                    erase( Input, InsertIt, end(Input) );
+                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
                 }
                 else
                 {
                     // Copy remaining data to the end of input
-                    insert( Input, end(Input), Storage.begin(), Storage.end() );
+                    ::boost::algorithm::detail::insert( Input, ::boost::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,11 +1,12 @@
 //  Boost string_algo library find_format_store.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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
@@ -19,6 +20,10 @@ 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,
@@ -47,7 +52,9 @@ namespace boost {
                 find_format_store& operator=( FindResultT FindResult )
                 {
                     iterator_range<ForwardIteratorT>::operator=(FindResult);
-                    m_FormatResult=m_Formatter(FindResult);
+                    if( !this->empty() ) {
+                        m_FormatResult=m_Formatter(FindResult);
+                    }
                     
                     return *this;
                 }
@@ -63,6 +70,18 @@ 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,11 +1,12 @@
 //  Boost string_algo library find_iterator.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library finder.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FINDER_DETAIL_HPP
 #define BOOST_STRING_FINDER_DETAIL_HPP
@@ -18,6 +19,7 @@
 #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 {
@@ -39,7 +41,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 first_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
+                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                 first_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -106,7 +108,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 last_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
+                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                 last_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -152,7 +154,7 @@ namespace boost {
                     while( M )
                     {
                         Last=M;
-                        M=first_finder( end(M), End );
+                        M=first_finder( ::boost::end(M), End );
                     }
 
                     return Last;
@@ -222,7 +224,7 @@ namespace boost {
                         const SearchT& Search,
                         int Nth,
                         PredicateT Comp) :
-                    m_Search(begin(Search), end(Search)),
+                    m_Search(::boost::begin(Search), ::boost::end(Search)),
                     m_Nth(Nth),
                     m_Comp(Comp) {}
                 nth_finderF(
@@ -277,7 +279,7 @@ namespace boost {
                     for( unsigned int n=0; n<=N; ++n )
                     {
                         // find next match
-                        M=first_finder( end(M), End );
+                        M=first_finder( ::boost::end(M), End );
 
                         if ( !M )
                         {
@@ -312,7 +314,7 @@ namespace boost {
                     for( unsigned int n=1; n<=N; ++n )
                     {
                         // find next match
-                        M=last_finder( Begin, begin(M) );
+                        M=last_finder( Begin, ::boost::begin(M) );
 
                         if ( !M )
                         {
@@ -380,7 +382,7 @@ namespace boost {
                 typedef BOOST_STRING_TYPENAME boost::detail::
                     iterator_traits<ForwardIteratorT>::iterator_category category;
 
-                return find_head_impl( Begin, End, N, category() );
+                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
             }
 
             template< typename ForwardIteratorT >
@@ -454,7 +456,7 @@ namespace boost {
                 typedef BOOST_STRING_TYPENAME boost::detail::
                     iterator_traits<ForwardIteratorT>::iterator_category category;
 
-                return find_tail_impl( Begin, End, N, category() );
+                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
             }
 
 
@@ -482,14 +484,14 @@ namespace boost {
                 {
                     if(m_N>=0)
                     {
-                        return find_head_impl( Begin, End, m_N );
+                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
                     }
                     else
                     {
                         iterator_range<ForwardIteratorT> Res=
-                            find_tail_impl( Begin, End, -m_N );
+                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
 
-                        return make_iterator_range(Begin, Res.begin());
+                        return ::boost::make_iterator_range(Begin, Res.begin());
                     }
                 }
 
@@ -520,14 +522,14 @@ namespace boost {
                 {
                     if(m_N>=0)
                     {
-                        return find_tail_impl( Begin, End, m_N );
+                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
                     }
                     else
                     {
                         iterator_range<ForwardIteratorT> Res=
-                            find_head_impl( Begin, End, -m_N );
+                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
 
-                        return make_iterator_range(Res.end(), End);
+                        return ::boost::make_iterator_range(Res.end(), End);
                     }
                 }
 

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

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

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

@@ -1,9 +1,10 @@
 //  Boost string_algo library formatter.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
 
@@ -38,7 +39,7 @@ namespace boost {
             public:
                 // Construction
                 const_formatF(const RangeT& Format) :
-                    m_Format(begin(Format), end(Format)) {}
+                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}
 
                 // Operation
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -69,7 +70,7 @@ namespace boost {
                 template< typename Range2T >
                 const RangeT& operator()(const Range2T& Replace) const
                 {
-                    return RangeT(begin(Replace), end(Replace));
+                    return RangeT(::boost::begin(Replace), ::boost::end(Replace));
                 }
             };
 
@@ -86,6 +87,31 @@ 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,11 +1,12 @@
 //  Boost string_algo library formatter_regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library predicate.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_PREDICATE_DETAIL_HPP
 #define BOOST_STRING_PREDICATE_DETAIL_HPP
@@ -62,7 +63,7 @@ namespace boost {
 
                 iterator_range<ForwardIterator1T> Result
                     =last_finder( 
-                        make_iterator_range(SubBegin, SubEnd),
+                        ::boost::make_iterator_range(SubBegin, SubEnd),
                         Comp)(Begin, End);
 
                 return !Result.empty() && Result.end()==End;

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

@@ -1,11 +1,12 @@
 //  Boost string_algo library replace_storage.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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
@@ -45,7 +46,7 @@ namespace boost {
                 StorageT& Storage,
                 const WhatT& What )
             {
-                Storage.insert( Storage.end(), begin(What), end(What) );
+                Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
             }
 
 
@@ -67,7 +68,7 @@ namespace boost {
                     ForwardIteratorT SegmentEnd )
                 {
                     // Copy data from the storage until the beginning of the segment
-                    ForwardIteratorT It=move_from_storage( Storage, InsertIt, SegmentBegin );
+                    ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
 
                     // 3 cases are possible :
                     //   a) Storage is empty, It==SegmentBegin
@@ -124,7 +125,7 @@ namespace boost {
 
                 {
                     // Call replace to do the job
-                    replace( Input, InsertIt, SegmentBegin, Storage );
+                    ::boost::algorithm::detail::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,11 +1,12 @@
 //  Boost string_algo library sequence.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_DETAIL_SEQUENCE_HPP
 #define BOOST_STRING_DETAIL_SEQUENCE_HPP
@@ -40,7 +41,7 @@ namespace boost {
                 BOOST_STRING_TYPENAME InputT::iterator At,
                 const InsertT& Insert )
             {
-                insert( Input, At, begin(Insert), end(Insert) );
+                ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
             }
            
 //  erase helper  ---------------------------------------------------//
@@ -183,11 +184,11 @@ namespace boost {
             {
                 if(From!=To)
                 {
-                    replace( Input, From, To, begin(Insert), end(Insert) );
+                    ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
                 }
                 else
                 {
-                    insert( Input, From, begin(Insert), end(Insert) );
+                    ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
                 }
             }
 

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

@@ -1,11 +1,12 @@
 //  Boost string_algo library trim.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_TRIM_DETAIL_HPP
 #define BOOST_STRING_TRIM_DETAIL_HPP
@@ -19,36 +20,6 @@ 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, 
@@ -85,6 +56,36 @@ 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,11 +1,12 @@
 //  Boost string_algo library util.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library erase.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ERASE_HPP
 #define BOOST_STRING_ERASE_HPP
@@ -53,11 +54,11 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<RangeT>::type>& SearchRange )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                range_finder(SearchRange),
-                empty_formatter(Input) );
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -71,10 +72,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<SequenceT>::type>& SearchRange )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                range_finder(SearchRange),
-                empty_formatter(Input) );
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -92,10 +93,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_iterator<SequenceT>::type>& SearchRange )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                range_finder(SearchRange),
-                empty_formatter(Input) );
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_first  --------------------------------------------------------//
@@ -123,11 +124,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -139,10 +140,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -158,10 +159,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_first ( case insensitive ) ------------------------------------//
@@ -192,11 +193,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -209,10 +210,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -230,10 +231,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_last  --------------------------------------------------------//
@@ -261,11 +262,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                last_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -277,10 +278,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                last_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -296,10 +297,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                last_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_last ( case insensitive ) ------------------------------------//
@@ -330,11 +331,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                last_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -347,10 +348,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                last_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -368,10 +369,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                last_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_nth --------------------------------------------------------------------//
@@ -403,11 +404,11 @@ namespace boost {
             const Range2T& Search,
             int Nth )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                nth_finder(Search, Nth),
-                empty_formatter(Input) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -420,10 +421,10 @@ namespace boost {
             const RangeT& Search,
             int Nth )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                nth_finder(Search, Nth),
-                empty_formatter(Input) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -442,10 +443,10 @@ namespace boost {
             const RangeT& Search,
             int Nth )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                nth_finder(Search, Nth),
-                empty_formatter(Input) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_nth ( case insensitive ) ---------------------------------------------//
@@ -479,11 +480,11 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                nth_finder(Search, Nth, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -497,9 +498,9 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                nth_finder(Search, Nth, is_iequal(Loc)),
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                 empty_formatter(Input) );
         }
 
@@ -521,10 +522,10 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                nth_finder(Search, Nth, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 
@@ -554,11 +555,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return find_format_all_copy(
+            return ::boost::algorithm::find_format_all_copy(
                 Output,
                 Input,
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -570,10 +571,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input, 
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -589,10 +590,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input, 
-                first_finder(Search),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_all ( case insensitive ) ------------------------------------//
@@ -623,11 +624,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_all_copy(
+            return ::boost::algorithm::find_format_all_copy(
                 Output,
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -640,10 +641,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -661,10 +662,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                empty_formatter(Input) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::empty_formatter(Input) );
         }
 
 //  erase_head --------------------------------------------------------------------//
@@ -695,11 +696,11 @@ namespace boost {
             const RangeT& Input,
             int N )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                head_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -711,10 +712,10 @@ namespace boost {
             const SequenceT& Input,
             int N )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                head_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -733,10 +734,10 @@ namespace boost {
             SequenceT& Input,
             int N )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                head_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
 //  erase_tail --------------------------------------------------------------------//
@@ -751,7 +752,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 tail.                 
                 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
@@ -767,11 +768,11 @@ namespace boost {
             const RangeT& Input,
             int N )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                tail_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -783,10 +784,10 @@ namespace boost {
             const SequenceT& Input,
             int N )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                tail_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -796,7 +797,7 @@ namespace boost {
             considered to be the tail. The input sequence is modified in-place.
 
             \param Input An input string
-            \param N Length of the head
+            \param N Length of the tail
                 For N>=0, at most N characters are extracted.
                 For N<0, size(Input)-|N| characters are extracted.
         */
@@ -805,10 +806,10 @@ namespace boost {
             SequenceT& Input,
             int N )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                tail_finder(N),
-                empty_formatter( Input ) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library find.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FIND_HPP
 #define BOOST_STRING_FIND_HPP
@@ -16,8 +17,7 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/finder.hpp>
 #include <boost/algorithm/string/compare.hpp>
@@ -48,19 +48,21 @@ namespace boost {
         */
         template<typename RangeT, typename FinderT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find( 
             RangeT& Input, 
-            FinderT Finder)
+            const FinderT& Finder)
         {
-            return Finder(begin(Input),end(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
         }
 
 //  find_first  -----------------------------------------------//
 
         //! Find first algorithm
         /*!
-            Search for the first occurence of the substring in the input. 
+            Search for the first occurrence of the substring in the input. 
             
             \param Input A string which will be searched.
             \param Search A substring to be searched for.
@@ -74,13 +76,12 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_first( 
             Range1T& Input, 
             const Range2T& Search)
         {
-            return first_finder(Search)(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
         }
 
         //! Find first algorithm ( case insensitive )
@@ -101,21 +102,20 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_first( 
             Range1T& Input, 
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return first_finder(Search,is_iequal(Loc))(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
         }
 
 //  find_last  -----------------------------------------------//
 
         //! Find last algorithm
         /*!
-            Search for the last occurence of the substring in the input. 
+            Search for the last occurrence of the substring in the input. 
             
             \param Input A string which will be searched.
             \param Search A substring to be searched for.
@@ -129,13 +129,12 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_last( 
             Range1T& Input, 
             const Range2T& Search)
         {
-            return last_finder(Search)(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
         }
 
         //! Find last algorithm ( case insensitive )
@@ -156,21 +155,20 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_last( 
             Range1T& Input, 
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return last_finder(Search, is_iequal(Loc))(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
         }
 
 //  find_nth ----------------------------------------------------------------------//
 
         //! Find n-th algorithm 
         /*!
-            Search for the n-th (zero-indexed) occurence of the substring in the 
+            Search for the n-th (zero-indexed) occurrence of the substring in the 
             input.         
             
             \param Input A string which will be searched.
@@ -185,14 +183,13 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_nth( 
             Range1T& Input, 
             const Range2T& Search,
             int Nth)
         {
-            return nth_finder(Search,Nth)(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
         }
 
         //! Find n-th algorithm ( case insensitive ).
@@ -216,15 +213,14 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_nth( 
             Range1T& Input, 
             const Range2T& Search,
             int Nth,
             const std::locale& Loc=std::locale())
         {
-            return nth_finder(Search,Nth,is_iequal(Loc))(
-                begin(Input),end(Input));
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
         }
 
 //  find_head ----------------------------------------------------------------------//
@@ -249,20 +245,19 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_head( 
             RangeT& Input, 
             int N)
         {
-            return head_finder(N)(
-                begin(Input),end(Input));      
+            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
         }
 
 //  find_tail ----------------------------------------------------------------------//
 
         //! Find tail algorithm
         /*!
-            Get the head of the input. Head is a suffix of the string of the 
+            Get the tail of the input. Tail 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.
 
@@ -281,13 +276,12 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_tail( 
             RangeT& Input, 
             int N)
         {
-            return tail_finder(N)(
-                begin(Input),end(Input));      
+            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
         }
 
 //  find_token --------------------------------------------------------------------//
@@ -311,14 +305,13 @@ namespace boost {
         */
         template<typename RangeT, typename PredicateT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_token( 
             RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off)
         {
-            return token_finder(Pred, eCompress)(
-                begin(Input),end(Input));       
+            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find_format.hpp

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

include/boost/algorithm/string/find_iterator.hpp

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

include/boost/algorithm/string/finder.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library finder.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FINDER_HPP
 #define BOOST_STRING_FINDER_HPP
@@ -45,35 +46,35 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c first_finder object
         */
-        template<typename ContainerT>
+        template<typename RangeT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             is_equal>
-        first_finder( const ContainerT& Search )
+        first_finder( const RangeT& Search )
         {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    is_equal>( Search, is_equal() ) ;
+                        range_const_iterator<RangeT>::type,
+                        is_equal>( ::boost::as_literal(Search), is_equal() ) ;
         }
 
         //! "First" finder
         /*!
             \overload
         */
-        template<typename ContainerT,typename PredicateT>
+        template<typename RangeT,typename PredicateT>
         inline detail::first_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             PredicateT>
         first_finder( 
-            const ContainerT& Search, PredicateT Comp )
+            const RangeT& Search, PredicateT Comp )
         {
             return 
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( Search, Comp );
+                        range_const_iterator<RangeT>::type,
+                    PredicateT>( ::boost::as_literal(Search), Comp );
         }
 
         //! "Last" finder
@@ -86,33 +87,33 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c last_finder object
         */
-        template<typename ContainerT>
+        template<typename RangeT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             is_equal>
-        last_finder( const ContainerT& Search )
+        last_finder( const RangeT& Search )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    is_equal>( Search, is_equal() );
+                        range_const_iterator<RangeT>::type,
+                    is_equal>( ::boost::as_literal(Search), is_equal() );
         }
         //! "Last" finder
         /*!
             \overload
         */
-        template<typename ContainerT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline detail::last_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             PredicateT>
-        last_finder( const ContainerT& Search, PredicateT Comp )
+        last_finder( const RangeT& Search, PredicateT Comp )
         {
             return 
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( Search, Comp ) ;
+                        range_const_iterator<RangeT>::type,
+                    PredicateT>( ::boost::as_literal(Search), Comp ) ;
         }
 
         //! "Nth" finder
@@ -126,38 +127,38 @@ namespace boost {
             \param Comp An element comparison predicate
             \return An instance of the \c nth_finder object
         */
-        template<typename ContainerT>
+        template<typename RangeT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             is_equal>
         nth_finder( 
-            const ContainerT& Search, 
+            const RangeT& Search, 
             int Nth)
         {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    is_equal>( Search, Nth, is_equal() ) ;
+                        range_const_iterator<RangeT>::type,
+                    is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
         }
         //! "Nth" finder
         /*!
             \overload
         */
-        template<typename ContainerT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline detail::nth_finderF<
-            BOOST_STRING_TYPENAME range_const_iterator<ContainerT>::type,
+            BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
             PredicateT>
         nth_finder( 
-            const ContainerT& Search, 
+            const RangeT& Search, 
             int Nth, 
             PredicateT Comp )
         {
             return 
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
-                        range_const_iterator<ContainerT>::type,
-                    PredicateT>( Search, Nth, Comp );
+                        range_const_iterator<RangeT>::type,
+                    PredicateT>( ::boost::as_literal(Search), Nth, Comp );
         }
 
         //! "Head" finder

include/boost/algorithm/string/formatter.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library formatter.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_FORMATTER_HPP
 #define BOOST_STRING_FORMATTER_HPP
@@ -13,6 +14,7 @@
 #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>
 
@@ -34,36 +36,44 @@ namespace boost {
 
         //! Constant formatter
         /*!
-            Construct the \c const_formatter. Const formatter always returns
+            Constructs a \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<RangeT>
+        inline detail::const_formatF<
+            iterator_range<
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
         const_formatter(const RangeT& Format)
         {
-            return detail::const_formatF<RangeT>(Format);
+            return detail::const_formatF<
+                iterator_range<
+                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
         }
 
         //! Identity formatter
         /*!
-            Construct the \c identity_formatter. Identity formatter always returns
+            Constructs an \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<RangeT>
+        inline detail::identity_formatF<
+            iterator_range<
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
         identity_formatter()
         {
-            return detail::identity_formatF<RangeT>();
+            return detail::identity_formatF<
+                iterator_range<
+                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
         }
 
         //! Empty formatter
         /*!
-            Construct the \c empty_formatter. Empty formatter always returns an empty
+            Constructs an \c empty_formatter. Empty formatter always returns an empty
             sequence. 
 
             \param Input container used to select a correct value_type for the
@@ -79,6 +89,22 @@ 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
 
@@ -86,6 +112,7 @@ 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,11 +1,12 @@
 //  Boost string_algo library iter_find.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_ITER_FIND_HPP
 #define BOOST_STRING_ITER_FIND_HPP
@@ -18,8 +19,9 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/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>
@@ -72,30 +74,34 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            function_requires< 
-                FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
+            BOOST_CONCEPT_ASSERT((
+                FinderConcept<
+                    FinderT,
+                    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_result_iterator<RangeT>::type input_iterator_type;
+                range_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=end(Input);
+            input_iterator_type InputEnd=::boost::end(lit_input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                make_transform_iterator( 
-                    find_iterator_type( begin(Input), InputEnd, Finder ),
+                ::boost::make_transform_iterator( 
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type());
             
             transform_iter_type itEnd=
-                make_transform_iterator( 
+                ::boost::make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type());
 
@@ -139,30 +145,33 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            function_requires< 
+            BOOST_CONCEPT_ASSERT((
                 FinderConcept<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_result_iterator<RangeT>::type input_iterator_type;
+                range_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=end(Input);
+            input_iterator_type InputEnd=::boost::end(lit_input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                make_transform_iterator( 
-                    find_iterator_type( begin(Input), InputEnd, Finder ),
+                ::boost::make_transform_iterator( 
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type() );
 
             transform_iter_type itEnd=
-                make_transform_iterator( 
+                ::boost::make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type() );
             

include/boost/algorithm/string/join.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library join.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_JOIN_HPP
 #define BOOST_STRING_JOIN_HPP
@@ -13,7 +14,7 @@
 #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. 
@@ -44,15 +45,15 @@ namespace boost {
         inline typename range_value<SequenceSequenceT>::type 
         join(
             const SequenceSequenceT& Input,
-            Range1T& Separator)
+            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=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -60,16 +61,16 @@ namespace boost {
             // Append first element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
                 // Add separator
-                detail::insert(Result, end(Result), Separator);
+                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
                 // Add element
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
             }
 
             return Result;
@@ -94,7 +95,7 @@ namespace boost {
         inline typename range_value<SequenceSequenceT>::type 
         join_if(
             const SequenceSequenceT& Input,
-            Range1T& Separator,
+            const Range1T& Separator,
             PredicateT Pred)
         {
             // Define working types
@@ -102,8 +103,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -113,7 +114,7 @@ namespace boost {
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
@@ -122,9 +123,9 @@ namespace boost {
                 if(Pred(*itBegin))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), Separator);
+                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 

include/boost/algorithm/string/predicate.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library predicate.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_PREDICATE_HPP
 #define BOOST_STRING_PREDICATE_HPP
@@ -15,6 +16,8 @@
 #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>
@@ -56,16 +59,19 @@ 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=end(Input);
-            Iterator2T TestEnd=end(Test);
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
 
-            Iterator1T it=begin(Input);
-            Iterator2T pit=begin(Test);
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -86,7 +92,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return starts_with(Input, Test, is_equal());
+            return ::boost::algorithm::starts_with(Input, Test, is_equal());
         }
 
         //! 'Starts with' predicate ( case insensitive )
@@ -108,7 +114,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return starts_with(Input, Test, is_iequal(Loc));
+            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
         }
 
 
@@ -135,6 +141,9 @@ 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::
@@ -142,10 +151,10 @@ namespace boost {
 
             return detail::
                 ends_with_iter_select( 
-                    begin(Input), 
-                    end(Input), 
-                    begin(Test), 
-                    end(Test), 
+                    ::boost::begin(lit_input), 
+                    ::boost::end(lit_input), 
+                    ::boost::begin(lit_test), 
+                    ::boost::end(lit_test), 
                     Comp,
                     category());
         }
@@ -160,7 +169,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ends_with(Input, Test, is_equal());
+            return ::boost::algorithm::ends_with(Input, Test, is_equal());
         }
 
         //! 'Ends with' predicate ( case insensitive )
@@ -182,7 +191,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ends_with(Input, Test, is_iequal(Loc));
+            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
         }
 
 //  contains predicate  -----------------------------------------------//
@@ -206,14 +215,17 @@ namespace boost {
             const Range2T& Test,
             PredicateT Comp)
         {
-            if (empty(Test))
+            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));
+
+            if (::boost::empty(lit_test))
             {
                 // Empty range is contained always
                 return true;
             }
             
             // Use the temporary variable to make VACPP happy
-            bool bResult=(first_finder(Test,Comp)(begin(Input), end(Input)));
+            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
             return bResult;
         }
 
@@ -226,7 +238,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return contains(Input, Test, is_equal());
+            return ::boost::algorithm::contains(Input, Test, is_equal());
         }
 
         //! 'Contains' predicate ( case insensitive )
@@ -247,7 +259,7 @@ namespace boost {
             const Range2T& Test, 
             const std::locale& Loc=std::locale())
         {
-            return contains(Input, Test, is_iequal(Loc));
+            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
         }
 
 //  equals predicate  -----------------------------------------------//
@@ -274,16 +286,19 @@ 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=end(Input);
-            Iterator2T TestEnd=end(Test);
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
 
-            Iterator1T it=begin(Input);
-            Iterator2T pit=begin(Test);
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -304,7 +319,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return equals(Input, Test, is_equal());
+            return ::boost::algorithm::equals(Input, Test, is_equal());
         }
 
         //! 'Equals' predicate ( case insensitive )
@@ -328,7 +343,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return equals(Input, Test, is_iequal(Loc));
+            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
         }
 
 // lexicographical_compare predicate -----------------------------//
@@ -357,11 +372,14 @@ namespace boost {
             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(
-                begin(Arg1),
-                end(Arg1),
-                begin(Arg2),
-                end(Arg2),
+                ::boost::begin(lit_arg1),
+                ::boost::end(lit_arg1),
+                ::boost::begin(lit_arg2),
+                ::boost::end(lit_arg2),
                 Pred);
         }
 
@@ -374,12 +392,7 @@ namespace boost {
             const Range1T& Arg1,
             const Range2T& Arg2)
         {
-            return std::lexicographical_compare(
-                begin(Arg1),
-                end(Arg1),
-                begin(Arg2),
-                end(Arg2),
-                is_less());
+            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
         }
 
         //! Lexicographical compare predicate (case-insensitive)
@@ -393,6 +406,7 @@ namespace boost {
 
              \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
@@ -400,14 +414,10 @@ namespace boost {
         template<typename Range1T, typename Range2T>
         inline bool ilexicographical_compare(
             const Range1T& Arg1,
-            const Range2T& Arg2)
+            const Range2T& Arg2,
+            const std::locale& Loc=std::locale())
         {
-            return std::lexicographical_compare(
-                begin(Arg1),
-                end(Arg1),
-                begin(Arg2),
-                end(Arg2),
-                is_iless());
+            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
         }
         
 
@@ -429,11 +439,13 @@ 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=end(Input);
-            for( Iterator1T It=begin(Input); It!=InputEnd; ++It)
+            Iterator1T InputEnd=::boost::end(lit_input);
+            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
             {
                 if (!Pred(*It))
                     return false;

include/boost/algorithm/string/predicate_facade.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library predicate_facade.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library regex.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REGEX_HPP
 #define BOOST_STRING_REGEX_HPP
@@ -16,7 +17,8 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/regex_find_format.hpp>
@@ -52,14 +54,16 @@ namespace boost {
             typename CharT, 
             typename RegexTraitsT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type >
         find_regex( 
             RangeT& Input, 
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return regex_finder(Rx,Flags)(
-                begin(Input), end(Input) );
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            return ::boost::algorithm::regex_finder(Rx,Flags)(
+                ::boost::begin(lit_input), ::boost::end(lit_input) );
         }
 
 //  replace_regex --------------------------------------------------------------------//
@@ -94,11 +98,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Output,
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -116,10 +120,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -143,10 +147,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
 //  replace_all_regex --------------------------------------------------------------------//
@@ -180,11 +184,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Output,
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -202,10 +206,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -229,10 +233,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input,
-                regex_finder( Rx, Flags ),
-                regex_formatter( Format, Flags ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::regex_formatter( Format, Flags ) );
         }
 
 //  erase_regex --------------------------------------------------------------------//
@@ -263,11 +267,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -283,10 +287,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input, 
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -307,10 +311,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
 //  erase_all_regex --------------------------------------------------------------------//
@@ -342,11 +346,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return find_format_all_copy(
+            return ::boost::algorithm::find_format_all_copy(
                 Output,
                 Input,
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -362,10 +366,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input, 
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -386,10 +390,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input, 
-                regex_finder( Rx, Flags ),
-                empty_formatter( Input ) );
+                ::boost::algorithm::regex_finder( Rx, Flags ),
+                ::boost::algorithm::empty_formatter( Input ) );
         }
 
 //  find_all_regex ------------------------------------------------------------------//
@@ -427,10 +431,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return iter_find(
+            return ::boost::algorithm::iter_find(
                 Result,
                 Input,
-                regex_finder(Rx,Flags) );         
+                ::boost::algorithm::regex_finder(Rx,Flags) );         
         }
 
 //  split_regex ------------------------------------------------------------------//
@@ -468,10 +472,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return iter_split(
+            return ::boost::algorithm::iter_split(
                 Result,
                 Input,
-                regex_finder(Rx,Flags) );         
+                ::boost::algorithm::regex_finder(Rx,Flags) );         
         }
 
 //  join_if ------------------------------------------------------------------//
@@ -502,7 +506,7 @@ namespace boost {
         inline typename range_value<SequenceSequenceT>::type 
         join_if(
             const SequenceSequenceT& Input,
-            Range1T& Separator,
+            const Range1T& Separator,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -511,8 +515,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -521,23 +525,23 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !regex_match(begin(*itBegin), end(*itBegin), Rx, Flags)) ++itBegin;
+                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(regex_match(begin(*itBegin), end(*itBegin), Rx, Flags))
+                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), Separator);
+                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 
@@ -570,7 +574,7 @@ namespace boost {
         inline typename range_value<SequenceSequenceT>::type 
         join_if_regex(
             const SequenceSequenceT& Input,
-            Range1T& Separator,
+            const Range1T& Separator,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -579,8 +583,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -589,23 +593,23 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !regex_match(begin(*itBegin), end(*itBegin), Rx, Flags)) ++itBegin;
+                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(regex_match(begin(*itBegin), end(*itBegin), Rx, Flags))
+                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), Separator);
+                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 
@@ -630,6 +634,12 @@ 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,11 +1,12 @@
 //  Boost string_algo library regex_find_format.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library replace.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_REPLACE_HPP
 #define BOOST_STRING_REPLACE_HPP
@@ -60,11 +61,11 @@ namespace boost {
                     range_const_iterator<Range1T>::type>& SearchRange,
             const Range2T& Format)
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                range_finder(SearchRange),
-                const_formatter(Format));
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -79,10 +80,10 @@ namespace boost {
                     range_const_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Input,
-                range_finder(SearchRange),
-                const_formatter(Format));
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -102,10 +103,10 @@ namespace boost {
                     range_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            find_format(
+            ::boost::algorithm::find_format(
                 Input,
-                range_finder(SearchRange),
-                const_formatter(Format));
+                ::boost::algorithm::range_finder(SearchRange),
+                ::boost::algorithm::const_formatter(Format));
         }
 
 //  replace_first --------------------------------------------------------------------//
@@ -137,11 +138,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format)
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -154,10 +155,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -175,10 +176,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_first ( case insensitive ) ---------------------------------------------//
@@ -213,11 +214,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -231,10 +232,10 @@ namespace boost {
             const Range1T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -255,10 +256,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_last --------------------------------------------------------------------//
@@ -290,11 +291,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                last_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -307,10 +308,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                last_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -328,10 +329,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                last_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_last ( case insensitive ) -----------------------------------------------//
@@ -366,11 +367,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                last_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -384,10 +385,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                last_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -409,10 +410,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                last_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_nth --------------------------------------------------------------------//
@@ -447,11 +448,11 @@ namespace boost {
             int Nth,
             const Range3T& Format )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                nth_finder(Search, Nth),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -465,10 +466,10 @@ namespace boost {
             int Nth,
             const Range2T& Format )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                nth_finder(Search, Nth),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -489,10 +490,10 @@ namespace boost {
             int Nth,
             const Range2T& Format )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                nth_finder(Search, Nth),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_nth ( case insensitive ) -----------------------------------------------//
@@ -530,11 +531,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                nth_finder(Search, Nth, is_iequal(Loc) ),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -549,10 +550,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                nth_finder(Search, Nth, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -576,10 +577,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                nth_finder(Search, Nth, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_all --------------------------------------------------------------------//
@@ -611,11 +612,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return find_format_all_copy(
+            return ::boost::algorithm::find_format_all_copy(
                 Output,
                 Input,
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -628,10 +629,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input,
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -650,10 +651,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input, 
-                first_finder(Search),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search),
+                ::boost::algorithm::const_formatter(Format) );
         }
         
 //  replace_all ( case insensitive ) -----------------------------------------------//
@@ -688,11 +689,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_all_copy(
+            return ::boost::algorithm::find_format_all_copy(
                 Output,
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -706,10 +707,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return find_format_all_copy( 
+            return ::boost::algorithm::find_format_all_copy( 
                 Input,
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -730,10 +731,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            find_format_all( 
+            ::boost::algorithm::find_format_all( 
                 Input, 
-                first_finder(Search, is_iequal(Loc)),
-                const_formatter(Format) );
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                ::boost::algorithm::const_formatter(Format) );
         }
         
 //  replace_head --------------------------------------------------------------------//
@@ -768,11 +769,11 @@ namespace boost {
             int N,
             const Range2T& Format )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                head_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -785,10 +786,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                head_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -810,10 +811,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                head_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::head_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
 //  replace_tail --------------------------------------------------------------------//
@@ -848,11 +849,11 @@ namespace boost {
             int N,
             const Range2T& Format )
         {
-            return find_format_copy(
+            return ::boost::algorithm::find_format_copy(
                 Output,
                 Input,
-                tail_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -865,10 +866,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            return find_format_copy( 
+            return ::boost::algorithm::find_format_copy( 
                 Input,
-                tail_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -890,10 +891,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            find_format( 
+            ::boost::algorithm::find_format( 
                 Input, 
-                tail_finder(N),
-                const_formatter(Format) );
+                ::boost::algorithm::tail_finder(N),
+                ::boost::algorithm::const_formatter(Format) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/sequence_traits.hpp

@@ -1,11 +1,12 @@
 //  Boost string_algo library sequence_traits.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  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.
+//  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,11 +1,12 @@
 //  Boost string_algo library split.hpp header file  ---------------------------//
 
-//  Copyright Pavol Droba 2002-2006. 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)
+//  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.
+//  See http://www.boost.org/ for updates, documentation, and revision history.
 
 #ifndef BOOST_STRING_SPLIT_HPP
 #define BOOST_STRING_SPLIT_HPP
@@ -63,10 +64,10 @@ namespace boost {
             Range1T& Input,
             const Range2T& Search)
         {
-            return iter_find(
+            return ::boost::algorithm::iter_find(
                 Result,
                 Input,
-                first_finder(Search) );        
+                ::boost::algorithm::first_finder(Search) );        
         }
 
         //! Find all algorithm ( case insensitive ) 
@@ -99,10 +100,10 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return iter_find(
+            return ::boost::algorithm::iter_find(
                 Result,
                 Input,
-                first_finder(Search, is_iequal(Loc) ) );        
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );        
         }
 
 
@@ -142,10 +143,10 @@ namespace boost {
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {
-            return iter_split(
+            return ::boost::algorithm::iter_split(
                 Result,
                 Input,
-                token_finder( Pred, eCompress ) );         
+                ::boost::algorithm::token_finder( Pred, eCompress ) );         
         }
 
     } // namespace algorithm

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

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

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

include/boost/algorithm/string/trim_all.hpp

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

minmax/example/Jamfile

@@ -7,8 +7,6 @@
 # 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_first_max_element</tt>,
-<tt>first_min_first_max_element</tt>,
-and <tt>first_min_first_max_element</tt> can be described generically as
+<tt>first_min_last_max_element</tt>,
+<tt>last_min_first_max_element</tt>,
+and <tt>last_min_last_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>
-<a NAME="Complexity"></a>Complexity</h3>
+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.
@@ -438,7 +438,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="#Performance">[2]</a>
+<tt>last_max_element</tt> called separately.  <a href="#Note2">[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

@@ -1,33 +0,0 @@
-# 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 = minmax(zero, one);
+  tuple<Value const&, Value const&> result1 = boost::minmax(zero, one);
   BOOST_CHECK_EQUAL( get<0>(result1), zero );
   BOOST_CHECK_EQUAL( get<1>(result1), one );
 
-  tuple<Value const&, Value const&> result2 = minmax(one, zero);
+  tuple<Value const&, Value const&> result2 = boost::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 = minmax(zero, one, lc );
+  tuple<Value const&, Value const&> result3 = boost::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 = minmax(one, zero, lc );
+  tuple<Value const&, Value const&> result4 = boost::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,7 +10,11 @@
 import toolset ;
 toolset.using doxygen ;
 
-boostbook string_algo : string_algo.xml ;
+boostbook string_algo : string_algo.xml autodoc 
+	:
+        <xsl:param>boost.root=../../../../..
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+	;
 
 doxygen autodoc
     :   
@@ -31,6 +35,7 @@ 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 ]

string/doc/concept.xml

@@ -1,6 +1,12 @@
 <?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>
 
@@ -96,7 +102,7 @@
 struct simple_finder
 {
     template&lt;typename ForwardIteratorT&gt;
-    boost::iterator_range&lt;ForwardIterator&gt; operator()(
+    boost::iterator_range&lt;ForwardIteratorT&gt; operator()(
         ForwardIteratorT Begin,
         ForwardIteratorT End )
     {

string/doc/credits.xml

@@ -1,6 +1,12 @@
 <?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,6 +1,13 @@
 <?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>
 
@@ -18,7 +25,7 @@
         </para>
         <para>
             <emphasis role="bold">Definition:</emphasis> A string is a 
-            <ulink url="../../libs/range/doc/range.html">range</ulink> of characters accessible in sequential
+            <ulink url="../../libs/range/index.html">range</ulink> of characters accessible in sequential
             ordered fashion. Character is any value type with "cheap" copying and assignment.                
         </para>
         <para>
@@ -210,7 +217,7 @@
         </para>
         <para>
             For more information about the exception safety topics, follow this 
-            <ulink url="../../more/generic_exception_safety.html">link</ulink>
+            <ulink url="http://www.boost.org/more/generic_exception_safety.html">link</ulink>
         </para>        
     </section>
 </section>

string/doc/environment.xml

@@ -1,6 +1,12 @@
 <?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,7 +32,9 @@
             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).
-    Permission to copy, use, modify, sell and distribute this software is granted provided this copyright notice appears
-     in all copies. This software is provided "as is" without express or implied warranty, and with no
-         claim as to its suitability for any purpose.</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>
- <!-- Copyright Dezide Aps 2003-2004 -->
+<br>Use, modification and distribution is subject to the Boost
+ Software License, Version 1.0. (See accompanying file
+ <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>)
+</br>
+</p>
+ <!-- Copyright Dezide Aps 2003-2004 -->

string/doc/intro.xml

@@ -1,6 +1,13 @@
 <?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,6 +1,12 @@
 <?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>
 
@@ -145,7 +151,7 @@
                     </row>
                     <row>
                         <entry><code>lexicographical_compare</code></entry>
-                        <entry>Check if a string is lexicographicaly less then another one</entry>
+                        <entry>Check if a string is lexicographically less then another one</entry>
                         <entry>
                             <functionname>lexicographical_compare()</functionname>
                             <sbr/>
@@ -428,7 +434,7 @@
                             <functionname>find_all_regex()</functionname>
                         </entry>
                     </row>
-                        <row>
+                    <row>
                         <entry>split</entry>
                         <entry>Split input into parts</entry>
                         <entry>
@@ -436,7 +442,21 @@
                             <sbr/>
                             <functionname>split_regex()</functionname>
                         </entry>
-                   </row>
+					</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>

string/doc/rationale.xml

@@ -1,6 +1,12 @@
 <?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,7 +1,17 @@
 <?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>
@@ -13,5 +23,23 @@
             <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,6 +1,12 @@
 <?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>
@@ -27,7 +33,7 @@
         <librarypurpose>
             A set of generic string-related algorithms and utilities
         </librarypurpose> 
-        <librarycategory name="category:algoritms"/>
+        <librarycategory name="category:algorithms"/>
         <librarycategory name="category:string-text"/>
     </libraryinfo>
 
@@ -38,7 +44,7 @@
     <xi:include href="quickref.xml"/>
     <xi:include href="design.xml"/>
     <xi:include href="concept.xml"/>
-    <xi:include href="autodoc.boostbook"/>
+    <xi:include href="autodoc.xml"/>
     <xi:include href="rationale.xml"/>
     <xi:include href="environment.xml"/>
     <xi:include href="credits.xml"/>

string/doc/usage.xml

@@ -1,6 +1,14 @@
 <?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>
 
@@ -49,7 +57,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/utility_class.html"><code>boost::iterator_range</code></ulink>
+                    <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
                     can be used to package iterators into a structure with a compatible interface.
                 </para>
             </listitem>
@@ -122,7 +130,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"
     
@@ -130,7 +138,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>
@@ -161,7 +169,7 @@
         <programlisting>
     string str1="     hello world!     ";
     string str2=trim_left_copy(str1);   // str2 == "hello world!     "
-    string str3=trim_right_copy(str2);  // str3 == "     hello world!"
+    string str3=trim_right_copy(str1);  // str3 == "     hello world!"
     trim(str1);                         // str1 == "hello world!"
 
     string phone="00423333444";
@@ -200,7 +208,7 @@
         </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/utility_class.html"><code>boost::iterator_range</code></ulink>. 
+            The result is given in the <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.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".
             
@@ -209,7 +217,7 @@
             <ulink url="../../libs/range/index.html">Boost.Range</ulink>.
 
             The following lines transform the result. Notice that 
-            <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> has familiar 
+            <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.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>
@@ -256,7 +264,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/utility_class.html"><code>boost::iterator_range</code></ulink> 
+            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> 
             object, that delimits the current match.
         </para>
         <para>
@@ -283,9 +291,9 @@
     // aBC
     
     typedef split_iterator&lt;string::iterator&gt; string_split_iterator;
-    for(string_find_iterator It=
+    for(string_split_iterator It=
         make_split_iterator(str1, first_finder("-*-", is_iequal()));
-        It!=string_find_iterator();
+        It!=string_split_iterator();
         ++It)
     {
         cout &lt;&lt; copy_range&lt;std::string&gt;(*It) &lt;&lt; endl;
@@ -331,7 +339,7 @@
     typedef vector&lt; string &gt; split_vector_type;
     
     split_vector_type SplitVec; // #2: Search for tokens
-    split( SplitVec, str1, is_any_of("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
+    split( SplitVec, str1, is_any_of("-*"), token_compress_on ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
         </programlisting>
         <para>
             <code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.                       

string/example/Jamfile

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

string/example/rle_example.cpp

@@ -114,10 +114,13 @@ public:
     result_type operator()( const ReplaceT& Replace ) const
     {
         SeqT r;
-        r.push_back( repeat_mark<value_type>() );
-        r.push_back( *(Replace.begin()) );
-        r.push_back( value_type( Replace.size() ) );
-        
+        if(!Replace.empty())
+        {
+            r.push_back( repeat_mark<value_type>() );
+            r.push_back( *(Replace.begin()) );
+            r.push_back( value_type( Replace.size() ) );
+        }
+
         return r;
     }
 };
@@ -183,14 +186,18 @@ 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,6 +4,11 @@
 </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

@@ -1,85 +0,0 @@
-#  Boost string_algo library test suite Jamfile  ----------------------------
-#
-#  Copyright Pavol Droba 2002-2003. Use, modification and
-#  distribution is subject to the Boost Software License, Version
-#  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-#  http://www.boost.org/LICENSE_1_0.txt)
-#
-#  See http://www.boost.org for updates, documentation, and revision history.
-
-subproject libs/algorithm/string/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-    test-suite 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
-                join_test.cpp
-              : :
-                :
-                std::locale-support
-                std::facet-support
-                : join
-            ]
-          [ 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

@@ -59,5 +59,11 @@ test-suite algorithm/string
             :   
             : regex
         ]
+      [ run 
+            find_format_test.cpp
+          : :
+            :   
+            : find_format
+        ]
     ;
 

string/test/find_format_test.cpp

@@ -0,0 +1,163 @@
+//  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/predicate_test.cpp

@@ -96,10 +96,29 @@ void predicate_test()
 
 }
 
+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 )\
 {\
-    BOOST_CHECK( all( string(YesInput), Pred ) );\
-    BOOST_CHECK( !all( string(NoInput), Pred ) );\
+    test_pred(Pred, YesInput, true); \
+    test_pred(Pred, NoInput, false); \
 }
 
 void classification_test()
@@ -121,6 +140,14 @@ 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/replace_test.cpp

@@ -11,6 +11,9 @@
 #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>
@@ -120,6 +123,7 @@ 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") );
@@ -284,6 +288,23 @@ 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*[] )
 {
@@ -296,6 +317,7 @@ 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,6 +40,7 @@ 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;
@@ -122,6 +123,45 @@ 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,6 +8,7 @@
 //  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>
@@ -109,10 +110,95 @@ 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;
 }