Phoenix Reloaded

[SVN r53348]

CMakeLists.txt

@@ -0,0 +1,20 @@
+#----------------------------------------------------------------------------
+# 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.hpp

@@ -21,6 +21,7 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/find.hpp>
 #include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/classification.hpp>

include/boost/algorithm/string/classification.hpp

@@ -202,8 +202,8 @@ namespace boost {
             BOOST_STRING_TYPENAME range_value<RangeT>::type> 
         is_any_of( const RangeT& Set )
         {
-            return detail::is_any_ofF<
-                BOOST_STRING_TYPENAME range_value<RangeT>::type>(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); 
         }
 
         //! is_from_range predicate

include/boost/algorithm/string/concept.hpp

@@ -65,8 +65,8 @@ namespace boost {
             void constraints()
             {
                 // Operation
-                begin((*pFo)( (*pF)(i,i) ));
-                end((*pFo)( (*pF)(i,i) ));
+                ::boost::begin((*pFo)( (*pF)(i,i) ));
+                ::boost::end((*pFo)( (*pF)(i,i) ));
             }
         private:
             IteratorT i;

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

@@ -21,6 +21,11 @@ namespace boost {
 
 //  case conversion functors -----------------------------------------------//
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
             // a tolower functor
             template<typename CharT>
             struct to_lowerF : public std::unary_function<CharT, CharT>
@@ -61,6 +66,10 @@ namespace boost {
                 const std::locale& m_Loc;
             };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
 // algorithm implementation -------------------------------------------------------------------------
 
             // Transform a range
@@ -71,8 +80,8 @@ namespace boost {
                 FunctorT Functor)
             {
                 return std::transform( 
-                    begin(Input), 
-                    end(Input), 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
                     Output,
                     Functor);
             }
@@ -84,9 +93,9 @@ namespace boost {
                 FunctorT Functor)
             {
                 std::transform( 
-                    begin(Input), 
-                    end(Input), 
-                    begin(Input),
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
+                    ::boost::begin(Input),
                     Functor);
             }
 
@@ -97,10 +106,10 @@ namespace boost {
             {
                 return SequenceT(
                     make_transform_iterator(
-                        begin(Input),
+                        ::boost::begin(Input),
                         Functor),
                     make_transform_iterator(
-                        end(Input), 
+                        ::boost::end(Input), 
                         Functor));
             }
 

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

@@ -15,7 +15,6 @@
 #include <algorithm>
 #include <functional>
 #include <locale>
-#include <set>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -29,7 +28,7 @@ namespace boost {
 
 //  classification functors -----------------------------------------------//
 
-            // is_classified functor
+   // is_classified functor
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
             {
@@ -39,7 +38,6 @@ namespace boost {
                 // Constructor from a locale
                 is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                     m_Type(Type), m_Locale(Loc) {}
-
                 // Operation
                 template<typename CharT>
                 bool operator()( CharT Ch ) const
@@ -56,10 +54,11 @@ namespace boost {
                 #endif
 
             private:
-                const std::ctype_base::mask m_Type;
-                const std::locale m_Locale;
+                std::ctype_base::mask m_Type;
+                std::locale m_Locale;
             };
 
+
             // is_any_of functor
             /*
                 returns true if the value is from the specified set
@@ -68,25 +67,181 @@ namespace boost {
             struct is_any_ofF :
                 public predicate_facade<is_any_ofF<CharT> >
             {
+            private:
+                // set cannot operate on const value-type
+                typedef typename ::boost::remove_const<CharT>::type set_value_type;
+
+            public:     
                 // Boost.Lambda support
                 template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 template<typename RangeT>
-                is_any_ofF( const RangeT& Range ) :
-                    m_Set( begin(Range), end(Range) ) {}
+                is_any_ofF( const RangeT& Range ) : m_Size(0)
+                {
+                    // Prepare storage
+                    m_Storage.m_dynSet=0;
+
+                    std::size_t Size=::boost::distance(Range);
+                    m_Size=Size;
+                    set_value_type* Storage=0;
+
+                    if(use_fixed_storage(m_Size))
+                    {
+                        // Use fixed storage
+                        Storage=&m_Storage.m_fixSet[0];
+                    }
+                    else
+                    {
+                        // Use dynamic storage
+                        m_Storage.m_dynSet=new set_value_type[m_Size];
+                        Storage=m_Storage.m_dynSet;
+                    }
+
+                    // Use fixed storage
+                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
+                    ::std::sort(Storage, Storage+m_Size);
+                }
+
+                // Copy constructor
+                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
+                {
+                    // Prepare storage
+                    m_Storage.m_dynSet=0;               
+                    const set_value_type* SrcStorage=0;
+                    set_value_type* DestStorage=0;
+
+                    if(use_fixed_storage(m_Size))
+                    {
+                        // Use fixed storage
+                        DestStorage=&m_Storage.m_fixSet[0];
+                        SrcStorage=&Other.m_Storage.m_fixSet[0];
+                    }
+                    else
+                    {
+                        // Use dynamic storage
+                        m_Storage.m_dynSet=new set_value_type[m_Size];
+                        DestStorage=m_Storage.m_dynSet;
+                        SrcStorage=Other.m_Storage.m_dynSet;
+                    }
+
+                    // Use fixed storage
+                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
+                }
+
+                // Destructor
+                ~is_any_ofF()
+                {
+                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
+                    {
+                        delete [] m_Storage.m_dynSet;
+                    }
+                }
+
+                // Assignment
+                is_any_ofF& operator=(const is_any_ofF& Other)
+                {
+                    // Handle self assignment
+                    if(this==&Other) return *this;
+
+                    // Prepare storage             
+                    const set_value_type* SrcStorage;
+                    set_value_type* DestStorage;
+
+                    if(use_fixed_storage(Other.m_Size))
+                    {
+                        // Use fixed storage
+                        DestStorage=&m_Storage.m_fixSet[0];
+                        SrcStorage=&Other.m_Storage.m_fixSet[0];
+
+                        // Delete old storage if was present
+                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
+                        {
+                            delete [] m_Storage.m_dynSet;
+                        }
+
+                        // Set new size
+                        m_Size=Other.m_Size;
+                    }
+                    else
+                    {
+                        // Other uses dynamic storage
+                        SrcStorage=Other.m_Storage.m_dynSet;
+
+                        // Check what kind of storage are we using right now
+                        if(use_fixed_storage(m_Size))
+                        {
+                            // Using fixed storage, allocate new
+                            set_value_type* pTemp=new set_value_type[Other.m_Size];
+                            DestStorage=pTemp;
+                            m_Storage.m_dynSet=pTemp;
+                            m_Size=Other.m_Size;
+                        }
+                        else
+                        {
+                            // Using dynamic storage, check if can reuse
+                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
+                            {
+                                // Reuse the current storage
+                                DestStorage=m_Storage.m_dynSet;
+                                m_Size=Other.m_Size;
+                            }
+                            else
+                            {
+                                // Allocate the new one
+                                set_value_type* pTemp=new set_value_type[Other.m_Size];
+                                DestStorage=pTemp;
+                        
+                                // Delete old storage if necessary
+                                if(m_Storage.m_dynSet!=0)
+                                {
+                                    delete [] m_Storage.m_dynSet;
+                                }
+                                // Store the new storage
+                                m_Storage.m_dynSet=pTemp;
+                                // Set new size
+                                m_Size=Other.m_Size;
+                            }
+                        }
+                    }
+
+                    // Copy the data
+                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
+
+                    return *this;
+                }
 
                 // Operation
                 template<typename Char2T>
                 bool operator()( Char2T Ch ) const
                 {
-                    return m_Set.find(Ch)!=m_Set.end();
+                    const set_value_type* Storage=
+                        (use_fixed_storage(m_Size))
+                        ? &m_Storage.m_fixSet[0]
+                        : m_Storage.m_dynSet;
+
+                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
+                }
+            private:
+                // check if the size is eligible for fixed storage
+                static bool use_fixed_storage(std::size_t size)
+                {
+                    return size<=sizeof(set_value_type*)*2;
                 }
 
+
             private:
-                // set cannot operate on const value-type
-                typedef typename remove_const<CharT>::type set_value_type;
-                std::set<set_value_type> m_Set;
+                // storage
+                // The actual used storage is selected on the type
+                union
+                {
+                    set_value_type* m_dynSet;
+                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
+                } 
+                m_Storage;
+        
+                // storage size
+                ::std::size_t m_Size;
             };
 
             // is_from_range functor

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

@@ -68,17 +68,17 @@ namespace boost {
                 if ( !M )
                 {
                     // Match not found - return original sequence
-                    std::copy( begin(Input), end(Input), Output );
+                    std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                     return Output;
                 }
 
                 // Copy the beginning of the sequence
-                std::copy( begin(Input), begin(M), Output );
+                std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
                 // Format find result
                 // Copy formated result
-                std::copy( begin(M.format_result()), end(M.format_result()), Output );
+                std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
                 // Copy the rest of the sequence
-                std::copy( M.end(), end(Input), Output );
+                std::copy( M.end(), ::boost::end(Input), Output );
 
                 return Output;
             }
@@ -129,11 +129,11 @@ namespace boost {
 
                 InputT Output;
                 // Copy the beginning of the sequence
-                insert( Output, end(Output), begin(Input), M.begin() );
+                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
                 // Copy formated result
-                insert( Output, end(Output), M.format_result() );
+                insert( Output, ::boost::end(Output), M.format_result() );
                 // Copy the rest of the sequence
-                insert( Output, end(Output), M.end(), end(Input) );
+                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
 
                 return Output;
             }

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

@@ -73,7 +73,7 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=begin(Input);
+                input_iterator_type LastMatch=::boost::begin(Input);
 
                 // Iterate through all matches
                 while( M )
@@ -81,15 +81,15 @@ namespace boost {
                     // Copy the beginning of the sequence
                     std::copy( LastMatch, M.begin(), Output );
                     // Copy formated result
-                    std::copy( begin(M.format_result()), end(M.format_result()), Output );
+                    std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, end(Input) );
+                    M=Finder( LastMatch, ::boost::end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                std::copy( LastMatch, end(Input), Output );
+                std::copy( LastMatch, ::boost::end(Input), Output );
 
                 return Output;
             }
@@ -140,7 +140,7 @@ namespace boost {
                 store_type M( FindResult, FormatResult, Formatter );
 
                 // Initialize last match
-                input_iterator_type LastMatch=begin(Input);
+                input_iterator_type LastMatch=::boost::begin(Input);
 
                 // Output temporary
                 InputT Output;
@@ -149,17 +149,17 @@ namespace boost {
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    insert( Output, end(Output), LastMatch, M.begin() );
+                    insert( Output, ::boost::end(Output), LastMatch, M.begin() );
                     // Copy formated result
-                    insert( Output, end(Output), M.format_result() );
+                    insert( Output, ::boost::end(Output), M.format_result() );
 
                     // Proceed to the next match
                     LastMatch=M.end();
-                    M=Finder( LastMatch, end(Input) );
+                    M=Finder( LastMatch, ::boost::end(Input) );
                 }
 
                 // Copy the rest of the sequence
-                insert( Output, end(Output), LastMatch, end(Input) );
+                insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
 
                 return Output;
             }
@@ -213,8 +213,8 @@ namespace boost {
                     BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
 
                 // Initialize replacement iterators
-                input_iterator_type InsertIt=begin(Input);
-                input_iterator_type SearchIt=begin(Input);
+                input_iterator_type InsertIt=::boost::begin(Input);
+                input_iterator_type SearchIt=::boost::begin(Input);
                 
                 while( M )
                 {
@@ -233,7 +233,7 @@ namespace boost {
                     copy_to_storage( Storage, M.format_result() );
 
                     // Find range for a next match
-                    M=Finder( SearchIt, end(Input) );
+                    M=Finder( SearchIt, ::boost::end(Input) );
                 }
 
                 // process the last segment
@@ -242,17 +242,17 @@ namespace boost {
                     Input,
                     InsertIt,
                     SearchIt,
-                    end(Input) );
+                    ::boost::end(Input) );
                 
                 if ( Storage.empty() )
                 {
                     // Truncate input
-                    erase( Input, InsertIt, end(Input) );
+                    erase( Input, InsertIt, ::boost::end(Input) );
                 }
                 else
                 {
                     // Copy remaining data to the end of input
-                    insert( Input, end(Input), Storage.begin(), Storage.end() );
+                    insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
                 }
             }
 

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

@@ -20,6 +20,10 @@ namespace boost {
 
 //  temporary format and find result storage --------------------------------//
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
             template< 
                 typename ForwardIteratorT,
                 typename FormatterT,
@@ -64,6 +68,9 @@ namespace boost {
                 const formatter_type& m_Formatter;
             };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

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

@@ -41,7 +41,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 first_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
+                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                 first_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -108,7 +108,7 @@ namespace boost {
                 // Construction
                 template< typename SearchT >
                 last_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
+                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                 last_finderF(
                         search_iterator_type SearchBegin,
                         search_iterator_type SearchEnd,
@@ -154,7 +154,7 @@ namespace boost {
                     while( M )
                     {
                         Last=M;
-                        M=first_finder( end(M), End );
+                        M=first_finder( ::boost::end(M), End );
                     }
 
                     return Last;
@@ -224,7 +224,7 @@ namespace boost {
                         const SearchT& Search,
                         int Nth,
                         PredicateT Comp) :
-                    m_Search(begin(Search), end(Search)),
+                    m_Search(::boost::begin(Search), ::boost::end(Search)),
                     m_Nth(Nth),
                     m_Comp(Comp) {}
                 nth_finderF(
@@ -279,7 +279,7 @@ namespace boost {
                     for( unsigned int n=0; n<=N; ++n )
                     {
                         // find next match
-                        M=first_finder( end(M), End );
+                        M=first_finder( ::boost::end(M), End );
 
                         if ( !M )
                         {
@@ -314,7 +314,7 @@ namespace boost {
                     for( unsigned int n=1; n<=N; ++n )
                     {
                         // find next match
-                        M=last_finder( Begin, begin(M) );
+                        M=last_finder( Begin, ::boost::begin(M) );
 
                         if ( !M )
                         {

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

@@ -39,7 +39,7 @@ namespace boost {
             public:
                 // Construction
                 const_formatF(const RangeT& Format) :
-                    m_Format(begin(Format), end(Format)) {}
+                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}
 
                 // Operation
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -70,7 +70,7 @@ namespace boost {
                 template< typename Range2T >
                 const RangeT& operator()(const Range2T& Replace) const
                 {
-                    return RangeT(begin(Replace), end(Replace));
+                    return RangeT(::boost::begin(Replace), ::boost::end(Replace));
                 }
             };
 

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

@@ -46,7 +46,7 @@ namespace boost {
                 StorageT& Storage,
                 const WhatT& What )
             {
-                Storage.insert( Storage.end(), begin(What), end(What) );
+                Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
             }
 
 

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

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

include/boost/algorithm/string/find.hpp

@@ -17,8 +17,6 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/result_iterator.hpp>
 #include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/finder.hpp>
@@ -50,14 +48,14 @@ namespace boost {
         */
         template<typename RangeT, typename FinderT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find( 
             RangeT& Input, 
             const FinderT& Finder)
         {
             iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
-            return Finder(begin(lit_input),end(lit_input));
+            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
         }
 
 //  find_first  -----------------------------------------------//
@@ -78,7 +76,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_first( 
             Range1T& Input, 
             const Range2T& Search)
@@ -104,7 +102,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_first( 
             Range1T& Input, 
             const Range2T& Search,
@@ -131,7 +129,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_last( 
             Range1T& Input, 
             const Range2T& Search)
@@ -157,7 +155,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_last( 
             Range1T& Input, 
             const Range2T& Search,
@@ -185,7 +183,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         find_nth( 
             Range1T& Input, 
             const Range2T& Search,
@@ -215,7 +213,7 @@ namespace boost {
         */
         template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
         ifind_nth( 
             Range1T& Input, 
             const Range2T& Search,
@@ -247,7 +245,7 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_head( 
             RangeT& Input, 
             int N)
@@ -278,7 +276,7 @@ namespace boost {
         */
         template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_tail( 
             RangeT& Input, 
             int N)
@@ -307,7 +305,7 @@ namespace boost {
         */
         template<typename RangeT, typename PredicateT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         find_token( 
             RangeT& Input,
             PredicateT Pred,

include/boost/algorithm/string/find_format.hpp

@@ -76,7 +76,7 @@ namespace boost {
                 Output,
                 lit_input,
                 Formatter,
-                Finder( begin(lit_input), end(lit_input) ) );
+                Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
         }
 
         //! Generic replace algorithm
@@ -104,7 +104,7 @@ namespace boost {
             return detail::find_format_copy_impl(
                 Input,
                 Formatter,
-                Finder(begin(Input), end(Input)));
+                Finder(::boost::begin(Input), ::boost::end(Input)));
         }
 
         //! Generic replace algorithm
@@ -137,7 +137,7 @@ namespace boost {
             detail::find_format_impl(
                 Input,
                 Formatter,
-                Finder(begin(Input), end(Input)));
+                Finder(::boost::begin(Input), ::boost::end(Input)));
         }
 
 
@@ -187,7 +187,7 @@ namespace boost {
                 lit_input,
                 Finder,
                 Formatter,
-                Finder(begin(lit_input), end(lit_input)));
+                Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
         }
 
         //! Generic replace all algorithm
@@ -216,7 +216,7 @@ namespace boost {
                 Input,
                 Finder,
                 Formatter,
-                Finder( begin(Input), end(Input) ) );
+                Finder( ::boost::begin(Input), ::boost::end(Input) ) );
         }
 
         //! Generic replace all algorithm
@@ -251,7 +251,7 @@ namespace boost {
                 Input,
                 Finder,
                 Formatter,
-                Finder(begin(Input), end(Input)));
+                Finder(::boost::begin(Input), ::boost::end(Input)));
 
         }
 

include/boost/algorithm/string/find_iterator.hpp

@@ -18,13 +18,13 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/detail/find_iterator.hpp>
 
 /*! \file
-    Defines find iterator classes. Find iterator repeatly applies a Finder
+    Defines find iterator classes. Find iterator repeatedly applies a Finder
     to the specified input string to search for matches. Dereferencing
     the iterator yields the current match or a range between the last and the current
     match depending on the iterator used.
@@ -58,12 +58,6 @@ namespace boost {
             // facade support
             friend class ::boost::iterator_core_access;
 
-            // base type
-            typedef iterator_facade<
-                find_iterator<IteratorT>,
-                const iterator_range<IteratorT>,
-                forward_traversal_tag> facade_type;
-
         private:
         // typedefs
 
@@ -120,8 +114,8 @@ namespace boost {
                 detail::find_iterator_base<IteratorT>(Finder,0)
             {
                 iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(as_literal(Col));
-                m_Match=make_iterator_range(begin(lit_col), begin(lit_col));
-                m_End=end(lit_col);
+                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_End=::boost::end(lit_col);
 
                 increment();
             }
@@ -185,12 +179,12 @@ namespace boost {
          */
         template<typename RangeT, typename FinderT>
         inline find_iterator< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         make_find_iterator(
             RangeT& Collection,
             FinderT Finder)
         {
-            return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
+            return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
                 Collection, Finder);
         }
 
@@ -220,12 +214,6 @@ namespace boost {
             // facade support
             friend class ::boost::iterator_core_access;
 
-            // base type
-            typedef iterator_facade<
-                find_iterator<IteratorT>,
-                iterator_range<IteratorT>,
-                forward_traversal_tag> facade_type;
-
         private:
         // typedefs
 
@@ -286,9 +274,9 @@ namespace boost {
                 m_bEof(false)
             {
                 iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(as_literal(Col));
-                m_Match=make_iterator_range(begin(lit_col), begin(lit_col));
-                m_Next=begin(lit_col);
-                m_End=end(lit_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);
 
                 increment();
             }
@@ -363,12 +351,12 @@ namespace boost {
          */
         template<typename RangeT, typename FinderT>
         inline split_iterator< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
         make_split_iterator(
             RangeT& Collection,
             FinderT Finder)
         {
-            return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
+            return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
                 Collection, Finder);
         }
 

include/boost/algorithm/string/iter_find.hpp

@@ -19,7 +19,7 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/as_literal.hpp>
 
@@ -76,26 +76,26 @@ namespace boost {
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
+                BOOST_STRING_TYPENAME range_iterator<RangeT>::type> >();
 
             iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
-                range_result_iterator<RangeT>::type input_iterator_type;
+                range_iterator<RangeT>::type input_iterator_type;
             typedef find_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
                     range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
-            input_iterator_type InputEnd=end(lit_input);
+            input_iterator_type InputEnd=::boost::end(lit_input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
                 make_transform_iterator( 
-                    find_iterator_type( begin(lit_input), InputEnd, Finder ),
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type());
             
             transform_iter_type itEnd=
@@ -145,26 +145,26 @@ namespace boost {
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
+                BOOST_STRING_TYPENAME range_iterator<RangeT>::type> >();
 
             iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             typedef BOOST_STRING_TYPENAME 
-                range_result_iterator<RangeT>::type input_iterator_type;
+                range_iterator<RangeT>::type input_iterator_type;
             typedef split_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
                     range_value<SequenceSequenceT>::type,
                 input_iterator_type> copy_range_type;
             
-            input_iterator_type InputEnd=end(lit_input);
+            input_iterator_type InputEnd=::boost::end(lit_input);
 
             typedef transform_iterator<copy_range_type, find_iterator_type>
                 transform_iter_type;
     
             transform_iter_type itBegin=
                 make_transform_iterator( 
-                    find_iterator_type( begin(lit_input), InputEnd, Finder ),
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                     copy_range_type() );
 
             transform_iter_type itEnd=

include/boost/algorithm/string/join.hpp

@@ -52,8 +52,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -61,16 +61,16 @@ namespace boost {
             // Append first element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
                 // Add separator
-                detail::insert(Result, end(Result), as_literal(Separator));
+                detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                 // Add element
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
             }
 
             return Result;
@@ -103,8 +103,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -114,7 +114,7 @@ namespace boost {
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
@@ -123,9 +123,9 @@ namespace boost {
                 if(Pred(*itBegin))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 

include/boost/algorithm/string/predicate.hpp

@@ -67,11 +67,11 @@ namespace boost {
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range2T>::type Iterator2T;
 
-            Iterator1T InputEnd=end(lit_input);
-            Iterator2T TestEnd=end(lit_test);
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
 
-            Iterator1T it=begin(lit_input);
-            Iterator2T pit=begin(lit_test);
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -151,10 +151,10 @@ namespace boost {
 
             return detail::
                 ends_with_iter_select( 
-                    begin(lit_input), 
-                    end(lit_input), 
-                    begin(lit_test), 
-                    end(lit_test), 
+                    ::boost::begin(lit_input), 
+                    ::boost::end(lit_input), 
+                    ::boost::begin(lit_test), 
+                    ::boost::end(lit_test), 
                     Comp,
                     category());
         }
@@ -225,7 +225,7 @@ namespace boost {
             }
             
             // Use the temporary variable to make VACPP happy
-            bool bResult=(first_finder(lit_test,Comp)(begin(lit_input), end(lit_input)));
+            bool bResult=(first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
             return bResult;
         }
 
@@ -294,11 +294,11 @@ namespace boost {
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<Range2T>::type Iterator2T;
                 
-            Iterator1T InputEnd=end(lit_input);
-            Iterator2T TestEnd=end(lit_test);
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
 
-            Iterator1T it=begin(lit_input);
-            Iterator2T pit=begin(lit_test);
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
             for(;
                 it!=InputEnd && pit!=TestEnd;
                 ++it,++pit)
@@ -376,10 +376,10 @@ namespace boost {
             iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(as_literal(Arg2));
 
             return std::lexicographical_compare(
-                begin(lit_arg1),
-                end(lit_arg1),
-                begin(lit_arg2),
-                end(lit_arg2),
+                ::boost::begin(lit_arg1),
+                ::boost::end(lit_arg1),
+                ::boost::begin(lit_arg2),
+                ::boost::end(lit_arg2),
                 Pred);
         }
 
@@ -444,8 +444,8 @@ namespace boost {
             typedef BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type Iterator1T;
 
-            Iterator1T InputEnd=end(lit_input);
-            for( Iterator1T It=begin(lit_input); It!=InputEnd; ++It)
+            Iterator1T InputEnd=::boost::end(lit_input);
+            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
             {
                 if (!Pred(*It))
                     return false;

include/boost/algorithm/string/regex.hpp

@@ -17,7 +17,7 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/range/as_literal.hpp>
 
 #include <boost/algorithm/string/find_format.hpp>
@@ -54,7 +54,7 @@ namespace boost {
             typename CharT, 
             typename RegexTraitsT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type >
         find_regex( 
             RangeT& Input, 
             const basic_regex<CharT, RegexTraitsT>& Rx,
@@ -63,7 +63,7 @@ namespace boost {
             iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
 
             return regex_finder(Rx,Flags)(
-                begin(lit_input), end(lit_input) );
+                ::boost::begin(lit_input), ::boost::end(lit_input) );
         }
 
 //  replace_regex --------------------------------------------------------------------//
@@ -515,8 +515,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -525,23 +525,23 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !regex_match(begin(*itBegin), end(*itBegin), Rx, Flags)) ++itBegin;
+                !regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(regex_match(begin(*itBegin), end(*itBegin), Rx, Flags))
+                if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 
@@ -583,8 +583,8 @@ namespace boost {
             typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
 
             // Parse input
-            InputIteratorT itBegin=begin(Input);
-            InputIteratorT itEnd=end(Input);
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
 
             // Construct container to hold the result
             ResultT Result;
@@ -593,23 +593,23 @@ namespace boost {
             // Roll to the first element that will be added
             while(
                 itBegin!=itEnd && 
-                !regex_match(begin(*itBegin), end(*itBegin), Rx, Flags)) ++itBegin;
+                !regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
 
             // Add this element
             if(itBegin!=itEnd)
             {
-                detail::insert(Result, end(Result), *itBegin);
+                detail::insert(Result, ::boost::end(Result), *itBegin);
                 ++itBegin;
             }
 
             for(;itBegin!=itEnd; ++itBegin)
             {
-                if(regex_match(begin(*itBegin), end(*itBegin), Rx, Flags))
+                if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
                 {
                     // Add separator
-                    detail::insert(Result, end(Result), as_literal(Separator));
+                    detail::insert(Result, ::boost::end(Result), as_literal(Separator));
                     // Add element
-                    detail::insert(Result, end(Result), *itBegin);
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
                 }
             }
 
@@ -634,6 +634,12 @@ namespace boost {
     using algorithm::find_all_regex;
     using algorithm::split_regex;
 
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    using algorithm::join_if;
+#else  // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    using algorithm::join_if_regex;
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
 } // namespace boost
 
 

include/boost/algorithm/string/trim.hpp

@@ -67,10 +67,10 @@ namespace boost {
 
             std::copy( 
                 ::boost::algorithm::detail::trim_begin( 
-                    begin(lit_range), 
-                    end(lit_range), 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
                     IsSpace ),
-                end(lit_range),
+                ::boost::end(lit_range),
                 Output);
 
             return Output;
@@ -85,10 +85,10 @@ namespace boost {
         {
             return SequenceT( 
                 ::boost::algorithm::detail::trim_begin( 
-                    begin(Input), 
-                    end(Input), 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
                     IsSpace ),
-                end(Input));
+                ::boost::end(Input));
         }
 
         //! Left trim - parametric
@@ -124,10 +124,10 @@ namespace boost {
         inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
         {
             Input.erase( 
-                begin(Input),
+                ::boost::begin(Input),
                 ::boost::algorithm::detail::trim_begin( 
-                    begin(Input), 
-                    end(Input), 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
                     IsSpace));
         }
 
@@ -174,10 +174,10 @@ namespace boost {
             iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
          
             std::copy( 
-                begin(lit_range),
+                ::boost::begin(lit_range),
                 ::boost::algorithm::detail::trim_end( 
-                    begin(lit_range), 
-                    end(lit_range), 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
                     IsSpace ),
                 Output );
 
@@ -192,10 +192,10 @@ namespace boost {
         inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
         {
             return SequenceT( 
-                begin(Input),
+                ::boost::begin(Input),
                 ::boost::algorithm::detail::trim_end( 
-                    begin(Input), 
-                    end(Input), 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
                     IsSpace)
                 );
         }
@@ -235,10 +235,10 @@ namespace boost {
         {
             Input.erase(
                 ::boost::algorithm::detail::trim_end( 
-                    begin(Input), 
-                    end(Input), 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
                     IsSpace ),
-                end(Input)
+                ::boost::end(Input)
                 );
         }
 
@@ -288,13 +288,13 @@ namespace boost {
             BOOST_STRING_TYPENAME 
                 range_const_iterator<RangeT>::type TrimEnd=
                 ::boost::algorithm::detail::trim_end( 
-                    begin(lit_range), 
-                    end(lit_range), 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
                     IsSpace);
 
             std::copy( 
                 detail::trim_begin( 
-                    begin(lit_range), TrimEnd, IsSpace),
+                    ::boost::begin(lit_range), TrimEnd, IsSpace),
                 TrimEnd,
                 Output
                 );
@@ -312,13 +312,13 @@ namespace boost {
             BOOST_STRING_TYPENAME 
                 range_const_iterator<SequenceT>::type TrimEnd=
                     ::boost::algorithm::detail::trim_end( 
-                        begin(Input), 
-                        end(Input), 
+                        ::boost::begin(Input), 
+                        ::boost::end(Input), 
                         IsSpace);
 
             return SequenceT( 
                 detail::trim_begin( 
-                    begin(Input), 
+                    ::boost::begin(Input), 
                     TrimEnd, 
                     IsSpace),
                 TrimEnd

minmax/index.html

@@ -56,7 +56,7 @@ be enough. The present library solves both problems.</p>
 <tt>minmax</tt>
 as straightforward extensions of the C++
 standard. As it returns a pair of <tt>const&amp;</tt>, we must use the <a
-href=:../../../../tuple/index.html>Boost.tuple</a> library to construct such
+href="../../tuple/index.html">Boost.tuple</a> library to construct such
 pairs. (Please note: the intent is not to fix the known defaults of
 <tt>std::min</tt>
 and <tt>std::max</tt>, but to add one more algorithms that combines both; see the
@@ -158,9 +158,9 @@ identical to
 that they return the last instance of the largest element (and not the
 first, as <tt>first_min_element</tt> and <tt>last_max_element</tt> would).
 <p>The family of algorithms comprising <tt>first_min_first_max_element</tt>,
-<tt>first_min_first_max_element</tt>,
-<tt>first_min_first_max_element</tt>,
-and <tt>first_min_first_max_element</tt> can be described generically as
+<tt>first_min_last_max_element</tt>,
+<tt>last_min_first_max_element</tt>,
+and <tt>last_min_last_max_element</tt> can be described generically as
 follows (using <i><tt>which</tt></i> and
 <i><tt>what</tt></i> for <tt>first</tt>
 or <tt>last</tt>): <tt><i>which</i>_min_<i>what</i>_max_element</tt> finds

minmax/test/CMakeLists.txt

@@ -0,0 +1,4 @@
+boost_additional_test_dependencies(algorithm BOOST_DEPENDS test)
+
+boost_test_run(minmax_element_test)
+boost_test_run(minmax_test)

minmax/test/minmax_test.cpp

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

module.cmake

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

string/doc/Jamfile.v2

@@ -10,7 +10,10 @@
 import toolset ;
 toolset.using doxygen ;
 
-boostbook string_algo : string_algo.xml autodoc ;
+boostbook string_algo : string_algo.xml autodoc 
+	:
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+	;
 
 doxygen autodoc
     :   
@@ -31,6 +34,7 @@ doxygen autodoc
     [ glob ../../../../boost/algorithm/string/trim.hpp ]
     [ glob ../../../../boost/algorithm/string/predicate.hpp ]
     [ glob ../../../../boost/algorithm/string/split.hpp ]
+    [ glob ../../../../boost/algorithm/string/iter_find.hpp ]
     [ glob ../../../../boost/algorithm/string/erase.hpp ]
     [ glob ../../../../boost/algorithm/string/join.hpp ]
     [ glob ../../../../boost/algorithm/string/replace.hpp ]

string/doc/concept.xml

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

string/doc/credits.xml

@@ -4,7 +4,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.credits" last-revision="$Date$">

string/doc/design.xml

@@ -5,7 +5,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.design" last-revision="$Date$">
@@ -217,7 +217,7 @@
         </para>
         <para>
             For more information about the exception safety topics, follow this 
-            <ulink url="../../more/generic_exception_safety.html">link</ulink>
+            <ulink url="http://www.boost.org/more/generic_exception_safety.html">link</ulink>
         </para>        
     </section>
 </section>

string/doc/environment.xml

@@ -4,7 +4,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.env" last-revision="$Date$">

string/doc/intro.xml

@@ -5,7 +5,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.intro" last-revision="$Date$">

string/doc/quickref.xml

@@ -4,7 +4,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.quickref" last-revision="$Date$">
@@ -151,7 +151,7 @@
                     </row>
                     <row>
                         <entry><code>lexicographical_compare</code></entry>
-                        <entry>Check if a string is lexicographicaly less then another one</entry>
+                        <entry>Check if a string is lexicographically less then another one</entry>
                         <entry>
                             <functionname>lexicographical_compare()</functionname>
                             <sbr/>
@@ -434,7 +434,7 @@
                             <functionname>find_all_regex()</functionname>
                         </entry>
                     </row>
-                        <row>
+                    <row>
                         <entry>split</entry>
                         <entry>Split input into parts</entry>
                         <entry>
@@ -442,7 +442,21 @@
                             <sbr/>
                             <functionname>split_regex()</functionname>
                         </entry>
-                   </row>
+					</row>
+					<row>
+						<entry>iter_find</entry>
+						<entry>Iteratively apply the finder to the input to find all matching substrings</entry>
+						<entry>
+							<functionname>iter_find()</functionname>
+						</entry>
+					</row>
+					<row>
+						<entry>iter_split</entry>
+						<entry>Use the finder to find matching substrings in the input and use them as separators to split the input into parts</entry>
+						<entry>
+							<functionname>iter_split()</functionname>
+						</entry>
+					</row>
                 </tbody>
             </tgroup>
         </table>

string/doc/rationale.xml

@@ -4,7 +4,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <section id="string_algo.rationale" last-revision="$Date$">

string/doc/release_notes.xml

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

string/doc/string_algo.xml

@@ -4,7 +4,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <library name="String Algorithms" dirname="algorithm/string" xmlns:xi="http://www.w3.org/2001/XInclude" 

string/doc/usage.xml

@@ -5,7 +5,7 @@
 
 <!-- Copyright (c) 2002-2006 Pavol Droba.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 

string/example/rle_example.cpp

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

string/test/CMakeLists.txt

@@ -0,0 +1,12 @@
+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)
+

string/test/predicate_test.cpp

@@ -96,10 +96,29 @@ void predicate_test()
 
 }
 
+template<typename Pred, typename Input>
+void test_pred(const Pred& pred, const Input& input, bool bYes)
+{
+    // test assignment operator
+    Pred pred1=pred;
+    pred1=pred;
+    pred1=pred1;
+    if(bYes)
+    {
+        BOOST_CHECK( all( input, pred ) );
+        BOOST_CHECK( all( input, pred1 ) );
+    }
+    else
+    {
+        BOOST_CHECK( !all( input, pred ) );
+        BOOST_CHECK( !all( input, pred1 ) );
+    }
+}
+
 #define TEST_CLASS( Pred, YesInput, NoInput )\
 {\
-    BOOST_CHECK( all( string(YesInput), Pred ) );\
-    BOOST_CHECK( !all( string(NoInput), Pred ) );\
+    test_pred(Pred, YesInput, true); \
+    test_pred(Pred, NoInput, false); \
 }
 
 void classification_test()
@@ -121,6 +140,14 @@ void classification_test()
 
     TEST_CLASS( !is_classified(std::ctype_base::space), "...", "..\n\r\t " );
     TEST_CLASS( ( !is_any_of("abc") && is_from_range('a','e') ) || is_space(), "d e", "abcde" );
+
+    // is_any_of test
+//  TEST_CLASS( !is_any_of(""), "", "aaa" )
+    TEST_CLASS( is_any_of("a"), "a", "ab" )
+    TEST_CLASS( is_any_of("ba"), "ab", "abc" )
+    TEST_CLASS( is_any_of("cba"), "abc", "abcd" )
+    TEST_CLASS( is_any_of("hgfedcba"), "abcdefgh", "abcdefghi" )
+    TEST_CLASS( is_any_of("qponmlkjihgfedcba"), "abcdefghijklmnopq", "zzz" )
 }
 
 #undef TEST_CLASS

string/test/replace_test.cpp

@@ -120,6 +120,7 @@ void replace_all_test()
 {
     // replace all
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3YYY2") );
+    TEST_ALGO( replace_all, string("1abc3abc2"), "/" C_ "\\", string("1abc3abc2") );
     TEST_ALGO( ireplace_all, "1aBc3AbC2", "abC" C_ "YYY", string("1YYY3YYY2") );
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3Z2") );
     TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3XXXX2") );