Release 1.40.0

[SVN r55802]

CMakeLists.txt

@@ -0,0 +1,26 @@
+#
+# Copyright Troy D. Straszheim
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+#
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    algorithm
+)
+
+# Add a library target to the build system
+boost_library_project(
+  algorithm
+  #  SRCDIRS 
+  TESTDIRS  minmax/test string/test
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  DESCRIPTION  "A library of various algorithms."
+  MODULARIZED
+  AUTHORS  "Pavol Droba <droba -at- topmail.sk>"
+           "Herve Bronnimann <hbr -at- poly.edu>"
+  #  MAINTAINERS 
+)

include/boost/algorithm/string/case_conv.hpp

@@ -59,7 +59,7 @@ namespace boost {
         {
             return ::boost::algorithm::detail::transform_range_copy( 
                Output,
-               ::boost::as_literal(Input),
+               as_literal(Input),
                ::boost::algorithm::detail::to_lowerF<
                     typename range_value<RangeT>::type >(Loc));
         }
@@ -93,7 +93,7 @@ namespace boost {
             const std::locale& Loc=std::locale())
         {
             ::boost::algorithm::detail::transform_range(
-                ::boost::as_literal(Input),
+                as_literal(Input),
                 ::boost::algorithm::detail::to_lowerF<
                     typename range_value<WritableRangeT>::type >(Loc));
         }
@@ -124,7 +124,7 @@ namespace boost {
         {
             return ::boost::algorithm::detail::transform_range_copy( 
                Output,
-               ::boost::as_literal(Input),
+               as_literal(Input),
                ::boost::algorithm::detail::to_upperF<
                     typename range_value<RangeT>::type >(Loc));
         }
@@ -158,7 +158,7 @@ namespace boost {
             const std::locale& Loc=std::locale())
         {
             ::boost::algorithm::detail::transform_range(
-                ::boost::as_literal(Input),
+                as_literal(Input),
                 ::boost::algorithm::detail::to_upperF<
                     typename range_value<WritableRangeT>::type >(Loc));
         }

include/boost/algorithm/string/classification.hpp

@@ -202,7 +202,7 @@ namespace boost {
             BOOST_STRING_TYPENAME range_value<RangeT>::type> 
         is_any_of( const RangeT& Set )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(as_literal(Set));
             return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); 
         }
 

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

@@ -105,10 +105,10 @@ namespace boost {
                 FunctorT Functor)
             {
                 return SequenceT(
-                    ::boost::make_transform_iterator(
+                    make_transform_iterator(
                         ::boost::begin(Input),
                         Functor),
-                    ::boost::make_transform_iterator(
+                    make_transform_iterator(
                         ::boost::end(Input), 
                         Functor));
             }

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

@@ -24,6 +24,25 @@ namespace boost {
 
 // find_format_copy (iterator variant) implementation -------------------------------//
 
+            template< 
+                typename OutputIteratorT,
+                typename InputT,
+                typename FormatterT,
+                typename FindResultT >
+            inline OutputIteratorT find_format_copy_impl(
+                OutputIteratorT Output,
+                const InputT& Input,
+                FormatterT Formatter,
+                const FindResultT& FindResult )
+            {       
+                return find_format_copy_impl2( 
+                    Output,
+                    Input,
+                    Formatter,
+                    FindResult,
+                    Formatter(FindResult) );
+            }
+
             template< 
                 typename OutputIteratorT,
                 typename InputT,
@@ -64,28 +83,24 @@ namespace boost {
                 return Output;
             }
 
+// find_format_copy implementation --------------------------------------------------//
+
             template< 
-                typename OutputIteratorT,
                 typename InputT, 
                 typename FormatterT,
                 typename FindResultT >
-            inline OutputIteratorT find_format_copy_impl(
+            inline InputT find_format_copy_impl(
-                OutputIteratorT Output,
                 const InputT& Input,
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                return ::boost::algorithm::detail::find_format_copy_impl2( 
+                return find_format_copy_impl2(
-                    Output,
                     Input,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
             }
 
- 
-// find_format_copy implementation --------------------------------------------------//
-
             template< 
                 typename InputT, 
                 typename FormatterT,
@@ -123,24 +138,24 @@ namespace boost {
                 return Output;
             }
 
+// replace implementation ----------------------------------------------------//
+        
             template<
                 typename InputT,
                 typename FormatterT,
                 typename FindResultT >
-            inline InputT find_format_copy_impl(
+            inline void find_format_impl( 
-                const InputT& Input,
+                InputT& Input,
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                return ::boost::algorithm::detail::find_format_copy_impl2(
+                find_format_impl2(
                     Input,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
             }
 
- // replace implementation ----------------------------------------------------//
-        
             template<
                 typename InputT,
                 typename FormatterT,
@@ -168,23 +183,7 @@ namespace boost {
                 }
 
                 // Replace match
-                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
+                replace( Input, M.begin(), M.end(), M.format_result() );
-            }
-
-            template<
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT >
-            inline void find_format_impl( 
-                InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                ::boost::algorithm::detail::find_format_impl2(
-                    Input,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
             }
 
         } // namespace detail

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

@@ -24,6 +24,28 @@ 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< 
                 typename OutputIteratorT,
                 typename InputT,
@@ -72,21 +94,20 @@ namespace boost {
                 return Output;
             }
 
+// find_format_all_copy implementation ----------------------------------------------//
+
             template< 
-                typename OutputIteratorT,
                 typename InputT, 
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline OutputIteratorT find_format_all_copy_impl(
+            inline InputT find_format_all_copy_impl(
-                OutputIteratorT Output,
                 const InputT& Input,
                 FinderT Finder,
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                return ::boost::algorithm::detail::find_format_all_copy_impl2( 
+                return find_format_all_copy_impl2(
-                    Output,
                     Input,
                     Finder,
                     Formatter,
@@ -94,8 +115,6 @@ namespace boost {
                     Formatter(FindResult) );
             }
 
- // find_format_all_copy implementation ----------------------------------------------//
-
             template< 
                 typename InputT, 
                 typename FinderT,
@@ -140,23 +159,25 @@ namespace boost {
                 }
 
                 // Copy the rest of the sequence
-                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
+                insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
 
                 return Output;
             }
 
+// find_format_all implementation ------------------------------------------------//
+        
             template<
                 typename InputT,
                 typename FinderT,
                 typename FormatterT,
                 typename FindResultT >
-            inline InputT find_format_all_copy_impl(
+            inline void find_format_all_impl( 
-                const InputT& Input,
+                InputT& Input,
                 FinderT Finder,
                 FormatterT Formatter,
-                const FindResultT& FindResult)
+                FindResultT FindResult)
             {
-                return ::boost::algorithm::detail::find_format_all_copy_impl2(
+                find_format_all_impl2(
                     Input,
                     Finder,
                     Formatter,
@@ -164,8 +185,6 @@ namespace boost {
                     Formatter(FindResult) );
             }
 
- // find_format_all implementation ------------------------------------------------//
-        
             template<
                 typename InputT,
                 typename FinderT,
@@ -211,14 +230,14 @@ namespace boost {
                     SearchIt=M.end();
 
                     // Copy formated replace to the storage
-                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
+                    copy_to_storage( Storage, M.format_result() );
 
                     // Find range for a next match
                     M=Finder( SearchIt, ::boost::end(Input) );
                 }
 
                 // process the last segment
-                InsertIt=::boost::algorithm::detail::process_segment( 
+                InsertIt=process_segment( 
                     Storage,
                     Input,
                     InsertIt,
@@ -228,34 +247,15 @@ namespace boost {
                 if ( Storage.empty() )
                 {
                     // Truncate input
-                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
+                    erase( Input, InsertIt, ::boost::end(Input) );
                 }
                 else
                 {
                     // Copy remaining data to the end of input
-                    ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
+                    insert( Input, ::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)
-            {
-                ::boost::algorithm::detail::find_format_all_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
-            }
-
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

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

@@ -382,7 +382,7 @@ namespace boost {
                 typedef BOOST_STRING_TYPENAME boost::detail::
                     iterator_traits<ForwardIteratorT>::iterator_category category;
 
-                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
+                return find_head_impl( Begin, End, N, category() );
             }
 
             template< typename ForwardIteratorT >
@@ -456,7 +456,7 @@ namespace boost {
                 typedef BOOST_STRING_TYPENAME boost::detail::
                     iterator_traits<ForwardIteratorT>::iterator_category category;
 
-                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
+                return find_tail_impl( Begin, End, N, category() );
             }
 
 
@@ -484,14 +484,14 @@ namespace boost {
                 {
                     if(m_N>=0)
                     {
-                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
+                        return find_head_impl( Begin, End, m_N );
                     }
                     else
                     {
                         iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
+                            find_tail_impl( Begin, End, -m_N );
 
-                        return ::boost::make_iterator_range(Begin, Res.begin());
+                        return make_iterator_range(Begin, Res.begin());
                     }
                 }
 
@@ -522,14 +522,14 @@ namespace boost {
                 {
                     if(m_N>=0)
                     {
-                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
+                        return find_tail_impl( Begin, End, m_N );
                     }
                     else
                     {
                         iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
+                            find_head_impl( Begin, End, -m_N );
 
-                        return ::boost::make_iterator_range(Res.end(), End);
+                        return make_iterator_range(Res.end(), End);
                     }
                 }
 

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

@@ -98,7 +98,7 @@ namespace boost {
                     // instantiate match result
                     match_results<input_iterator_type> result;
                     // search for a match
-                    if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
+                    if ( regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
                     {
                         // construct a result
                         return result_type( result );

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

@@ -63,7 +63,7 @@ namespace boost {
 
                 iterator_range<ForwardIterator1T> Result
                     =last_finder( 
-                        ::boost::make_iterator_range(SubBegin, SubEnd),
+                        make_iterator_range(SubBegin, SubEnd),
                         Comp)(Begin, End);
 
                 return !Result.empty() && Result.end()==End;

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

@@ -68,7 +68,7 @@ namespace boost {
                     ForwardIteratorT SegmentEnd )
                 {
                     // Copy data from the storage until the beginning of the segment
-                    ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
+                    ForwardIteratorT It=move_from_storage( Storage, InsertIt, SegmentBegin );
 
                     // 3 cases are possible :
                     //   a) Storage is empty, It==SegmentBegin
@@ -125,7 +125,7 @@ namespace boost {
 
                 {
                     // Call replace to do the job
-                    ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
+                    replace( Input, InsertIt, SegmentBegin, Storage );
                     // Empty the storage
                     Storage.clear();
                     // Iterators were not changed, simply return the end of segment

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

@@ -41,7 +41,7 @@ namespace boost {
                 BOOST_STRING_TYPENAME InputT::iterator At,
                 const InsertT& Insert )
             {
-                ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
+                insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
             }
            
 //  erase helper  ---------------------------------------------------//
@@ -184,11 +184,11 @@ namespace boost {
             {
                 if(From!=To)
                 {
-                    ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
+                    replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
                 }
                 else
                 {
-                    ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
+                    insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
                 }
             }
 

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

@@ -20,6 +20,36 @@ namespace boost {
 
 //  trim iterator helper -----------------------------------------------//
 
+            // Search for first non matching character from the beginning of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_begin( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                ForwardIteratorT It=InBegin;
+                for(; It!=InEnd; ++It )
+                {
+                    if (!IsSpace(*It))
+                        return It;
+                }
+
+                return It;
+            }
+
+            // Search for first non matching character from the end of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_end( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;
+
+                return trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
+            }
+
             template< typename ForwardIteratorT, typename PredicateT >
             inline ForwardIteratorT trim_end_iter_select( 
                 ForwardIteratorT InBegin, 
@@ -56,36 +86,6 @@ namespace boost {
 
                 return InBegin;
             }
-   // Search for first non matching character from the beginning of the sequence
-            template< typename ForwardIteratorT, typename PredicateT >
-            inline ForwardIteratorT trim_begin( 
-                ForwardIteratorT InBegin, 
-                ForwardIteratorT InEnd, 
-                PredicateT IsSpace )
-            {
-                ForwardIteratorT It=InBegin;
-                for(; It!=InEnd; ++It )
-                {
-                    if (!IsSpace(*It))
-                        return It;
-                }
-
-                return It;
-            }
-
-            // Search for first non matching character from the end of the sequence
-            template< typename ForwardIteratorT, typename PredicateT >
-            inline ForwardIteratorT trim_end( 
-                ForwardIteratorT InBegin, 
-                ForwardIteratorT InEnd, 
-                PredicateT IsSpace )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
-            }
-
 
         } // namespace detail
     } // namespace algorithm

include/boost/algorithm/string/erase.hpp

@@ -54,11 +54,11 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<RangeT>::type>& SearchRange )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -72,10 +72,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<SequenceT>::type>& SearchRange )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase range algorithm
@@ -93,10 +93,10 @@ namespace boost {
                 BOOST_STRING_TYPENAME 
                     range_iterator<SequenceT>::type>& SearchRange )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_first  --------------------------------------------------------//
@@ -124,11 +124,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -140,10 +140,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm
@@ -159,10 +159,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_first ( case insensitive ) ------------------------------------//
@@ -193,11 +193,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -210,10 +210,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase first algorithm ( case insensitive )
@@ -231,10 +231,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_last  --------------------------------------------------------//
@@ -262,11 +262,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -278,10 +278,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm
@@ -297,10 +297,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_last ( case insensitive ) ------------------------------------//
@@ -331,11 +331,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -348,10 +348,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase last algorithm ( case insensitive )
@@ -369,10 +369,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_nth --------------------------------------------------------------------//
@@ -404,11 +404,11 @@ namespace boost {
             const Range2T& Search,
             int Nth )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -421,10 +421,10 @@ namespace boost {
             const RangeT& Search,
             int Nth )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -443,10 +443,10 @@ namespace boost {
             const RangeT& Search,
             int Nth )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_nth ( case insensitive ) ---------------------------------------------//
@@ -480,11 +480,11 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase nth algorithm
@@ -498,9 +498,9 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
                 empty_formatter(Input) );
         }
 
@@ -522,10 +522,10 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 
@@ -555,11 +555,11 @@ namespace boost {
             const Range1T& Input,
             const Range2T& Search )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -571,10 +571,10 @@ namespace boost {
             const SequenceT& Input,
             const RangeT& Search )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm
@@ -590,10 +590,10 @@ namespace boost {
             SequenceT& Input,
             const RangeT& Search )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_all ( case insensitive ) ------------------------------------//
@@ -624,11 +624,11 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -641,10 +641,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
         //! Erase all algorithm ( case insensitive )
@@ -662,10 +662,10 @@ namespace boost {
             const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::empty_formatter(Input) );
+                empty_formatter(Input) );
         }
 
 //  erase_head --------------------------------------------------------------------//
@@ -696,11 +696,11 @@ namespace boost {
             const RangeT& Input,
             int N )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -712,10 +712,10 @@ namespace boost {
             const SequenceT& Input,
             int N )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase head algorithm
@@ -734,10 +734,10 @@ namespace boost {
             SequenceT& Input,
             int N )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  erase_tail --------------------------------------------------------------------//
@@ -768,11 +768,11 @@ namespace boost {
             const RangeT& Input,
             int N )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -784,10 +784,10 @@ namespace boost {
             const SequenceT& Input,
             int N )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase tail algorithm
@@ -806,10 +806,10 @@ namespace boost {
             SequenceT& Input,
             int N )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find.hpp

@@ -53,7 +53,7 @@ namespace boost {
             RangeT& Input, 
             const FinderT& Finder)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             return Finder(::boost::begin(lit_input),::boost::end(lit_input));
         }
@@ -81,7 +81,7 @@ namespace boost {
             Range1T& Input, 
             const Range2T& Search)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
+            return find(Input, first_finder(Search));
         }
 
         //! Find first algorithm ( case insensitive )
@@ -108,7 +108,7 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
+            return find(Input, first_finder(Search,is_iequal(Loc)));
         }
 
 //  find_last  -----------------------------------------------//
@@ -134,7 +134,7 @@ namespace boost {
             Range1T& Input, 
             const Range2T& Search)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
+            return find(Input, last_finder(Search));
         }
 
         //! Find last algorithm ( case insensitive )
@@ -161,7 +161,7 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
+            return find(Input, last_finder(Search, is_iequal(Loc)));
         }
 
 //  find_nth ----------------------------------------------------------------------//
@@ -189,7 +189,7 @@ namespace boost {
             const Range2T& Search,
             int Nth)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
+            return find(Input, nth_finder(Search,Nth));
         }
 
         //! Find n-th algorithm ( case insensitive ).
@@ -220,7 +220,7 @@ namespace boost {
             int Nth,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
+            return find(Input, nth_finder(Search,Nth,is_iequal(Loc)));
         }
 
 //  find_head ----------------------------------------------------------------------//
@@ -250,7 +250,7 @@ namespace boost {
             RangeT& Input, 
             int N)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
+            return find(Input, head_finder(N));
         }
 
 //  find_tail ----------------------------------------------------------------------//
@@ -281,7 +281,7 @@ namespace boost {
             RangeT& Input, 
             int N)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
+            return find(Input, tail_finder(N));
         }
 
 //  find_token --------------------------------------------------------------------//
@@ -311,7 +311,7 @@ namespace boost {
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off)
         {
-            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
+            return find(Input, token_finder(Pred, eCompress));
         }
 
     } // namespace algorithm

include/boost/algorithm/string/find_format.hpp

@@ -62,18 +62,15 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                ));
 
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             return detail::find_format_copy_impl(
                 Output,
@@ -96,16 +93,13 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             return detail::find_format_copy_impl(
                 Input,
@@ -132,16 +126,13 @@ namespace boost {
             FormatterT Formatter)
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT(( 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             detail::find_format_impl(
                 Input,
@@ -181,18 +172,15 @@ namespace boost {
             FormatterT Formatter)
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT(( 
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT(( 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
-                ));
 
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             return detail::find_format_all_copy_impl(
                 Output,
@@ -216,16 +204,13 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             return detail::find_format_all_copy_impl(
                 Input,
@@ -254,16 +239,13 @@ namespace boost {
             FormatterT Formatter )
         {
             // Concept check
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+            function_requires< 
-                ));
-            BOOST_CONCEPT_ASSERT((
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
-                ));
 
             detail::find_format_all_impl(
                 Input,

include/boost/algorithm/string/find_iterator.hpp

@@ -113,8 +113,8 @@ namespace boost {
                     FinderT Finder ) :
                 detail::find_iterator_base<IteratorT>(Finder,0)
             {
-                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(as_literal(Col));
-                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
                 m_End=::boost::end(lit_col);
 
                 increment();
@@ -273,7 +273,7 @@ namespace boost {
                 detail::find_iterator_base<IteratorT>(Finder,0),
                 m_bEof(false)
             {
-                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(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);

include/boost/algorithm/string/finder.hpp

@@ -56,7 +56,7 @@ namespace boost {
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                        is_equal>( ::boost::as_literal(Search), is_equal() ) ;
+                    is_equal>( as_literal(Search), is_equal() ) ;
         }
 
         //! "First" finder
@@ -74,7 +74,7 @@ namespace boost {
                 detail::first_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Comp );
+                    PredicateT>( as_literal(Search), Comp );
         }
 
         //! "Last" finder
@@ -97,7 +97,7 @@ namespace boost {
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                    is_equal>( ::boost::as_literal(Search), is_equal() );
+                    is_equal>( as_literal(Search), is_equal() );
         }
         //! "Last" finder
         /*!
@@ -113,7 +113,7 @@ namespace boost {
                 detail::last_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Comp ) ;
+                    PredicateT>( as_literal(Search), Comp ) ;
         }
 
         //! "Nth" finder
@@ -139,7 +139,7 @@ namespace boost {
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                    is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
+                    is_equal>( as_literal(Search), Nth, is_equal() ) ;
         }
         //! "Nth" finder
         /*!
@@ -158,7 +158,7 @@ namespace boost {
                 detail::nth_finderF<
                     BOOST_STRING_TYPENAME 
                         range_const_iterator<RangeT>::type,
-                    PredicateT>( ::boost::as_literal(Search), Nth, Comp );
+                    PredicateT>( as_literal(Search), Nth, Comp );
         }
 
         //! "Head" finder

include/boost/algorithm/string/formatter.hpp

@@ -50,7 +50,7 @@ namespace boost {
         {
             return detail::const_formatF<
                 iterator_range<
-                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
+                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(as_literal(Format));
         }
 
         //! Identity formatter

include/boost/algorithm/string/iter_find.hpp

@@ -74,13 +74,11 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
-                FinderConcept<
+                FinderConcept<FinderT,
-                    FinderT,
+                BOOST_STRING_TYPENAME range_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));
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
                 range_iterator<RangeT>::type input_iterator_type;
@@ -96,12 +94,12 @@ namespace boost {
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type());
             
             transform_iter_type itEnd=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type());
 
@@ -145,12 +143,11 @@ namespace boost {
             RangeT& Input,
             FinderT Finder )
         {
-            BOOST_CONCEPT_ASSERT((
+            function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_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));
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
                 range_iterator<RangeT>::type input_iterator_type;
@@ -166,12 +163,12 @@ namespace boost {
                 transform_iter_type;
     
             transform_iter_type itBegin=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type() );
 
             transform_iter_type itEnd=
-                ::boost::make_transform_iterator( 
+                make_transform_iterator( 
                     find_iterator_type(),
                     copy_range_type() );
             

include/boost/algorithm/string/join.hpp

@@ -68,7 +68,7 @@ namespace boost {
             for(;itBegin!=itEnd; ++itBegin)
             {
                 // Add separator
-                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                 // Add element
                 detail::insert(Result, ::boost::end(Result), *itBegin);
             }
@@ -123,7 +123,7 @@ namespace boost {
                 if(Pred(*itBegin))
                 {
                     // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
                     detail::insert(Result, ::boost::end(Result), *itBegin);
                 }

include/boost/algorithm/string/predicate.hpp

@@ -59,8 +59,8 @@ 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<Range1T>::type> lit_input(as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
 
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
@@ -92,7 +92,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::starts_with(Input, Test, is_equal());
+            return starts_with(Input, Test, is_equal());
         }
 
         //! 'Starts with' predicate ( case insensitive )
@@ -114,7 +114,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
+            return starts_with(Input, Test, is_iequal(Loc));
         }
 
 
@@ -141,8 +141,8 @@ 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<Range1T>::type> lit_input(as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
 
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
@@ -169,7 +169,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::ends_with(Input, Test, is_equal());
+            return ends_with(Input, Test, is_equal());
         }
 
         //! 'Ends with' predicate ( case insensitive )
@@ -191,7 +191,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
+            return ends_with(Input, Test, is_iequal(Loc));
         }
 
 //  contains predicate  -----------------------------------------------//
@@ -215,17 +215,17 @@ 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<Range1T>::type> lit_input(as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
 
-            if (::boost::empty(lit_test))
+            if (empty(lit_test))
             {
                 // Empty range is contained always
                 return true;
             }
             
             // Use the temporary variable to make VACPP happy
-            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
+            bool bResult=(first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
             return bResult;
         }
 
@@ -238,7 +238,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::contains(Input, Test, is_equal());
+            return contains(Input, Test, is_equal());
         }
 
         //! 'Contains' predicate ( case insensitive )
@@ -259,7 +259,7 @@ namespace boost {
             const Range2T& Test, 
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
+            return contains(Input, Test, is_iequal(Loc));
         }
 
 //  equals predicate  -----------------------------------------------//
@@ -286,8 +286,8 @@ 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<Range1T>::type> lit_input(as_literal(Input));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
 
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range1T>::type Iterator1T;
@@ -319,7 +319,7 @@ namespace boost {
             const Range1T& Input, 
             const Range2T& Test)
         {
-            return ::boost::algorithm::equals(Input, Test, is_equal());
+            return equals(Input, Test, is_equal());
         }
 
         //! 'Equals' predicate ( case insensitive )
@@ -343,7 +343,7 @@ namespace boost {
             const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
+            return equals(Input, Test, is_iequal(Loc));
         }
 
 // lexicographical_compare predicate -----------------------------//
@@ -372,8 +372,8 @@ 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<Range1T>::type> lit_arg1(as_literal(Arg1));
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(as_literal(Arg2));
 
             return std::lexicographical_compare(
                 ::boost::begin(lit_arg1),
@@ -392,7 +392,7 @@ namespace boost {
             const Range1T& Arg1,
             const Range2T& Arg2)
         {
-            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
+            return lexicographical_compare(Arg1, Arg2, is_less());
         }
 
         //! Lexicographical compare predicate (case-insensitive)
@@ -417,7 +417,7 @@ namespace boost {
             const Range2T& Arg2,
             const std::locale& Loc=std::locale())
         {
-            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
+            return lexicographical_compare(Arg1, Arg2, is_iless(Loc));
         }
         
 
@@ -439,7 +439,7 @@ namespace boost {
             const RangeT& Input, 
             PredicateT Pred)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type Iterator1T;

include/boost/algorithm/string/regex.hpp

@@ -60,9 +60,9 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
-            return ::boost::algorithm::regex_finder(Rx,Flags)(
+            return regex_finder(Rx,Flags)(
                 ::boost::begin(lit_input), ::boost::end(lit_input) );
         }
 
@@ -98,11 +98,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -120,10 +120,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace regex algorithm
@@ -147,10 +147,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
 //  replace_all_regex --------------------------------------------------------------------//
@@ -184,11 +184,11 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -206,10 +206,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
         //! Replace all regex algorithm
@@ -233,10 +233,10 @@ namespace boost {
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::regex_formatter( Format, Flags ) );
+                regex_formatter( Format, Flags ) );
         }
 
 //  erase_regex --------------------------------------------------------------------//
@@ -267,11 +267,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -287,10 +287,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase regex algorithm
@@ -311,10 +311,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  erase_all_regex --------------------------------------------------------------------//
@@ -346,11 +346,11 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -366,10 +366,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
         //! Erase all regex algorithm
@@ -390,10 +390,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::regex_finder( Rx, Flags ),
+                regex_finder( Rx, Flags ),
-                ::boost::algorithm::empty_formatter( Input ) );
+                empty_formatter( Input ) );
         }
 
 //  find_all_regex ------------------------------------------------------------------//
@@ -431,10 +431,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::regex_finder(Rx,Flags) );         
+                regex_finder(Rx,Flags) );         
         }
 
 //  split_regex ------------------------------------------------------------------//
@@ -472,10 +472,10 @@ namespace boost {
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
-            return ::boost::algorithm::iter_split(
+            return iter_split(
                 Result,
                 Input,
-                ::boost::algorithm::regex_finder(Rx,Flags) );         
+                regex_finder(Rx,Flags) );         
         }
 
 //  join_if ------------------------------------------------------------------//
@@ -525,7 +525,7 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
+                !regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
@@ -536,10 +536,10 @@ namespace boost {
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
+                if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
                     detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
@@ -593,7 +593,7 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
+                !regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
@@ -604,10 +604,10 @@ namespace boost {
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
+                if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
                     detail::insert(Result, ::boost::end(Result), *itBegin);
                 }

include/boost/algorithm/string/replace.hpp

@@ -61,11 +61,11 @@ namespace boost {
                     range_const_iterator<Range1T>::type>& SearchRange,
             const Range2T& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -80,10 +80,10 @@ namespace boost {
                     range_const_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
         //! Replace range algorithm
@@ -103,10 +103,10 @@ namespace boost {
                     range_iterator<SequenceT>::type>& SearchRange,
             const RangeT& Format)
         {
-            ::boost::algorithm::find_format(
+            find_format(
                 Input,
-                ::boost::algorithm::range_finder(SearchRange),
+                range_finder(SearchRange),
-                ::boost::algorithm::const_formatter(Format));
+                const_formatter(Format));
         }
 
 //  replace_first --------------------------------------------------------------------//
@@ -138,11 +138,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format)
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -155,10 +155,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm
@@ -176,10 +176,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_first ( case insensitive ) ---------------------------------------------//
@@ -214,11 +214,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -232,10 +232,10 @@ namespace boost {
             const Range1T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace first algorithm ( case insensitive )
@@ -256,10 +256,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_last --------------------------------------------------------------------//
@@ -291,11 +291,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -308,10 +308,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm
@@ -329,10 +329,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search),
+                last_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_last ( case insensitive ) -----------------------------------------------//
@@ -367,11 +367,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -385,10 +385,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace last algorithm ( case insensitive )
@@ -410,10 +410,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+                last_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_nth --------------------------------------------------------------------//
@@ -448,11 +448,11 @@ namespace boost {
             int Nth,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -466,10 +466,10 @@ namespace boost {
             int Nth,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm
@@ -490,10 +490,10 @@ namespace boost {
             int Nth,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth),
+                nth_finder(Search, Nth),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_nth ( case insensitive ) -----------------------------------------------//
@@ -531,11 +531,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
+                nth_finder(Search, Nth, is_iequal(Loc) ),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -550,10 +550,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace nth algorithm ( case insensitive )
@@ -577,10 +577,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+                nth_finder(Search, Nth, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_all --------------------------------------------------------------------//
@@ -612,11 +612,11 @@ namespace boost {
             const Range2T& Search,
             const Range3T& Format )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -629,10 +629,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm
@@ -651,10 +651,10 @@ namespace boost {
             const Range1T& Search,
             const Range2T& Format )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search),
+                first_finder(Search),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
         
 //  replace_all ( case insensitive ) -----------------------------------------------//
@@ -689,11 +689,11 @@ namespace boost {
             const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy(
+            return find_format_all_copy(
                 Output,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -707,10 +707,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::find_format_all_copy( 
+            return find_format_all_copy( 
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace all algorithm ( case insensitive )
@@ -731,10 +731,10 @@ namespace boost {
             const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
-            ::boost::algorithm::find_format_all( 
+            find_format_all( 
                 Input, 
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+                first_finder(Search, is_iequal(Loc)),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
         
 //  replace_head --------------------------------------------------------------------//
@@ -769,11 +769,11 @@ namespace boost {
             int N,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -786,10 +786,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace head algorithm
@@ -811,10 +811,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::head_finder(N),
+                head_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
 //  replace_tail --------------------------------------------------------------------//
@@ -849,11 +849,11 @@ namespace boost {
             int N,
             const Range2T& Format )
         {
-            return ::boost::algorithm::find_format_copy(
+            return find_format_copy(
                 Output,
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -866,10 +866,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            return ::boost::algorithm::find_format_copy( 
+            return find_format_copy( 
                 Input,
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
         //! Replace tail algorithm
@@ -891,10 +891,10 @@ namespace boost {
             int N,
             const RangeT& Format )
         {
-            ::boost::algorithm::find_format( 
+            find_format( 
                 Input, 
-                ::boost::algorithm::tail_finder(N),
+                tail_finder(N),
-                ::boost::algorithm::const_formatter(Format) );
+                const_formatter(Format) );
         }
 
     } // namespace algorithm

include/boost/algorithm/string/split.hpp

@@ -64,10 +64,10 @@ namespace boost {
             Range1T& Input,
             const Range2T& Search)
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::first_finder(Search) );        
+                first_finder(Search) );        
         }
 
         //! Find all algorithm ( case insensitive ) 
@@ -100,10 +100,10 @@ namespace boost {
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
-            return ::boost::algorithm::iter_find(
+            return iter_find(
                 Result,
                 Input,
-                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );        
+                first_finder(Search, is_iequal(Loc) ) );        
         }
 
 
@@ -143,10 +143,10 @@ namespace boost {
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {
-            return ::boost::algorithm::iter_split(
+            return iter_split(
                 Result,
                 Input,
-                ::boost::algorithm::token_finder( Pred, eCompress ) );         
+                token_finder( Pred, eCompress ) );         
         }
 
     } // namespace algorithm

include/boost/algorithm/string/trim.hpp

@@ -63,7 +63,7 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
 
             std::copy( 
                 ::boost::algorithm::detail::trim_begin( 
@@ -106,7 +106,7 @@ namespace boost {
         inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
         {
             return            
-                ::boost::algorithm::trim_left_copy_if(
+                trim_left_copy_if(
                     Input, 
                     is_space(Loc));
         }
@@ -142,7 +142,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_left_if( 
+            trim_left_if( 
                 Input, 
                 is_space(Loc));
         }
@@ -171,7 +171,7 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace )
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
          
             std::copy( 
                 ::boost::begin(lit_range),
@@ -215,7 +215,7 @@ namespace boost {
         inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
         {
             return 
-                ::boost::algorithm::trim_right_copy_if( 
+                trim_right_copy_if( 
                     Input, 
                     is_space(Loc));
         }
@@ -254,7 +254,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_right_if(
+            trim_right_if(
                 Input, 
                 is_space(Loc) );
         }
@@ -283,7 +283,7 @@ namespace boost {
             const RangeT& Input,
             PredicateT IsSpace)
         {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
 
             BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type TrimEnd=
@@ -340,7 +340,7 @@ namespace boost {
         inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
         {
             return
-                ::boost::algorithm::trim_copy_if(
+                trim_copy_if(
                     Input, 
                     is_space(Loc) );
         }
@@ -357,8 +357,8 @@ namespace boost {
         template<typename SequenceT, typename PredicateT>
         inline void trim_if(SequenceT& Input, PredicateT IsSpace)
         {
-            ::boost::algorithm::trim_right_if( Input, IsSpace );
+            trim_right_if( Input, IsSpace );
-            ::boost::algorithm::trim_left_if( Input, IsSpace );
+            trim_left_if( Input, IsSpace );
         }
 
         //! Trim
@@ -372,7 +372,7 @@ namespace boost {
         template<typename SequenceT>
         inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
         {
-            ::boost::algorithm::trim_if(
+            trim_if(
                 Input, 
                 is_space( Loc ) );
         }

minmax/index.html

@@ -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);
 
 }
@@ -243,7 +243,7 @@ range
 
 <a name="complexity">
 <h3>
-Complexity</h3>
+<a NAME="Complexity"></a>Complexity</h3>
 Minmax performs a single comparison and is otherwise of constant complexity.
 The use of <tt>boost::tuple&lt;T const&amp;></tt> prevents copy
 constructors in case the arguments are passed by reference.
@@ -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="#Note2">[2]</a>
+<tt>last_max_element</tt> called separately.  <a href="#Performance">[2]</a>
 
 <h4><b>Why algorithms and not accumulators?</b></h4>
 <p>The minmax algorithms are useful in computing the extent of a range.

minmax/test/CMakeLists.txt

@@ -0,0 +1,10 @@
+#
+# Copyright Troy D. Straszheim
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+#
+boost_additional_test_dependencies(algorithm BOOST_DEPENDS test)
+
+boost_test_run(minmax_element_test)
+boost_test_run(minmax_test)

module.cmake

@@ -0,0 +1,4 @@
+boost_module(algorithm DEPENDS regex concept_check range)
+
+
+

string/doc/design.xml

@@ -25,7 +25,7 @@
         </para>
         <para>
             <emphasis role="bold">Definition:</emphasis> A string is a 
-            <ulink url="../../libs/range/index.html">range</ulink> of characters accessible in sequential
+            <ulink url="../../libs/range/doc/range.html">range</ulink> of characters accessible in sequential
             ordered fashion. Character is any value type with "cheap" copying and assignment.                
         </para>
         <para>

string/doc/string_algo.xml

@@ -33,7 +33,7 @@
         <librarypurpose>
             A set of generic string-related algorithms and utilities
         </librarypurpose> 
-        <librarycategory name="category:algorithms"/>
+        <librarycategory name="category:algoritms"/>
         <librarycategory name="category:string-text"/>
     </libraryinfo>
 

string/doc/usage.xml

@@ -57,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/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
+                    <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>
                     can be used to package iterators into a structure with a compatible interface.
                 </para>
             </listitem>
@@ -208,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/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>. 
+            The result is given in the <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>. 
             This range delimits the
             part of the input which satisfies the find criteria. In our example it is the last occurrence of "ll".
             
@@ -217,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/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> has familiar 
+            <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> has familiar 
             <code>begin()</code> and <code>end()</code> methods, so it can be used like any other STL container.
             Also it is convertible to bool therefore it is easy to use find algorithms for a simple containment checking.
         </para>
@@ -264,7 +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/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> 
+            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> 
             object, that delimits the current match.
         </para>
         <para>
@@ -339,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("-*"), token_compress_on ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
+    split( SplitVec, str1, is_any_of("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
         </programlisting>
         <para>
             <code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.                       

string/test/CMakeLists.txt

@@ -0,0 +1,18 @@
+#
+# Copyright Troy D. Straszheim
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+#
+boost_additional_test_dependencies(algorithm BOOST_DEPENDS test)
+
+
+boost_test_run(trim_test)
+boost_test_run(conv_test)
+boost_test_run(predicate_test)
+boost_test_run(find_test)
+boost_test_run(split_test)
+boost_test_run(join_test)
+boost_test_run(replace_test)
+boost_test_run(regex_test DEPENDS boost_regex SHARED)
+