Branch at revision 46530

[SVN r46531]

CMakeLists.txt

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

@@ -28,7 +28,11 @@ namespace boost {
 
 //  classification functors -----------------------------------------------//
 
-   // is_classified functor
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+            // is_classified functor
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
             {
@@ -38,6 +42,7 @@ 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
@@ -54,10 +59,13 @@ namespace boost {
                 #endif
 
             private:
-                std::ctype_base::mask m_Type;
+                const std::ctype_base::mask m_Type;
-                std::locale m_Locale;
+                const std::locale m_Locale;
             };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
 
             // is_any_of functor
             /*
@@ -69,7 +77,9 @@ namespace boost {
             {
             private:
                 // set cannot operate on const value-type
-                typedef typename ::boost::remove_const<CharT>::type set_value_type;
+                typedef typename remove_const<CharT>::type set_value_type;
+                // Size of the static storage (size of pointer*2)
+                static const ::std::size_t FIXED_STORAGE_SIZE = sizeof(set_value_type*)*2;
 
             public:     
                 // Boost.Lambda support
@@ -86,7 +96,7 @@ namespace boost {
                     m_Size=Size;
                     set_value_type* Storage=0;
 
-                    if(use_fixed_storage(m_Size))
+                    if(m_Size<=FIXED_STORAGE_SIZE)
                     {
                         // Use fixed storage
                         Storage=&m_Storage.m_fixSet[0];
@@ -111,7 +121,7 @@ namespace boost {
                     const set_value_type* SrcStorage=0;
                     set_value_type* DestStorage=0;
 
-                    if(use_fixed_storage(m_Size))
+                    if(m_Size<=FIXED_STORAGE_SIZE)
                     {
                         // Use fixed storage
                         DestStorage=&m_Storage.m_fixSet[0];
@@ -132,80 +142,36 @@ namespace boost {
                 // Destructor
                 ~is_any_ofF()
                 {
-                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
+                    if(m_Size>FIXED_STORAGE_SIZE && m_Storage.m_dynSet!=0)
                     {
-                        delete [] m_Storage.m_dynSet;
+                        delete m_Storage.m_dynSet;
                     }
                 }
 
                 // Assignment
                 is_any_ofF& operator=(const is_any_ofF& Other)
                 {
-                    // Handle self assignment
+                    // Prepare storage
-                    if(this==&Other) return *this;
+                    m_Storage.m_dynSet=0;
+                    m_Size=Other.m_Size;
+                    const set_value_type* SrcStorage=0;
+                    set_value_type* DestStorage=0;
 
-                    // Prepare storage             
+                    if(m_Size<=FIXED_STORAGE_SIZE)
-                    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
+                        // Use dynamic storage
+                        m_Storage.m_dynSet=new set_value_type[m_Size];
+                        DestStorage=m_Storage.m_dynSet;
                         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
+                    // Use fixed storage
                     ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
 
                     return *this;
@@ -216,19 +182,12 @@ namespace boost {
                 bool operator()( Char2T Ch ) const
                 {
                     const set_value_type* Storage=
-                        (use_fixed_storage(m_Size))
+                        (m_Size<=FIXED_STORAGE_SIZE)
                         ? &m_Storage.m_fixSet[0]
                         : m_Storage.m_dynSet;
 
                     return ::std::binary_search(Storage, Storage+m_Size, Ch);
                 }
-            private:
-                // check if the size is eligible for fixed storage
-                static bool use_fixed_storage(std::size_t size)
-                {
-                    return size<=sizeof(set_value_type*)*2;
-                }
-
 
             private:
                 // storage
@@ -236,7 +195,7 @@ namespace boost {
                 union
                 {
                     set_value_type* m_dynSet;
-                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
+                    set_value_type m_fixSet[FIXED_STORAGE_SIZE];
                 } 
                 m_Storage;
         

minmax/index.html

@@ -158,9 +158,9 @@ identical to
 that they return the last instance of the largest element (and not the
 first, as <tt>first_min_element</tt> and <tt>last_max_element</tt> would).
 <p>The family of algorithms comprising <tt>first_min_first_max_element</tt>,
-<tt>first_min_last_max_element</tt>,
+<tt>first_min_first_max_element</tt>,
-<tt>last_min_first_max_element</tt>,
+<tt>first_min_first_max_element</tt>,
-and <tt>last_min_last_max_element</tt> can be described generically as
+and <tt>first_min_first_max_element</tt> can be described generically as
 follows (using <i><tt>which</tt></i> and
 <i><tt>what</tt></i> for <tt>first</tt>
 or <tt>last</tt>): <tt><i>which</i>_min_<i>what</i>_max_element</tt> finds

minmax/test/CMakeLists.txt

@@ -1,4 +0,0 @@
-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 = boost::minmax(zero, one);
+  tuple<Value const&, Value const&> result1 = minmax(zero, one);
   BOOST_CHECK_EQUAL( get<0>(result1), zero );
   BOOST_CHECK_EQUAL( get<1>(result1), one );
 
-  tuple<Value const&, Value const&> result2 = boost::minmax(one, zero);
+  tuple<Value const&, Value const&> result2 = minmax(one, zero);
   BOOST_CHECK_EQUAL( get<0>(result2), zero );
   BOOST_CHECK_EQUAL( get<1>(result2), one );
   
   // Test functionality and number of comparisons
   lc.reset();
-  tuple<Value const&, Value const&> result3 = boost::minmax(zero, one, lc );
+  tuple<Value const&, Value const&> result3 = minmax(zero, one, lc );
   BOOST_CHECK_EQUAL( get<0>(result3), zero );
   BOOST_CHECK_EQUAL( get<1>(result3), one );
   BOOST_CHECK_EQUAL( counter, 1 );
 
   lc.reset();
-  tuple<Value const&, Value const&> result4 = boost::minmax(one, zero, lc );
+  tuple<Value const&, Value const&> result4 = minmax(one, zero, lc );
   BOOST_CHECK_EQUAL( get<0>(result4), zero );
   BOOST_CHECK_EQUAL( get<1>(result4), one );
   BOOST_CHECK_EQUAL( counter, 1);

module.cmake

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

string/doc/Jamfile.v2

@@ -10,10 +10,7 @@
 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
     :   

string/test/CMakeLists.txt

@@ -1,12 +0,0 @@
-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,29 +96,10 @@ 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 )\
 {\
-    test_pred(Pred, YesInput, true); \
+    BOOST_CHECK( all( string(YesInput), Pred ) );\
-    test_pred(Pred, NoInput, false); \
+    BOOST_CHECK( !all( string(NoInput), Pred ) );\
 }
 
 void classification_test()