Branch at revision 46530

[SVN r46531]

CMakeLists.txt

@@ -1,22 +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/test/CMakeLists.txt

@@ -1,8 +0,0 @@
-#-------------------------------------------------------------------------
-#-- Needed include directories for the tests
-boost_test_add_dependent_includes("utility;detail;config;test;mpl;bind;type_traits;static_assert;preprocessor;array;iterator;timer;tuple;range")
-#-------------------------------------------------------------------------
-
-
-boost_test_run(minmax_element_test)
-boost_test_run(minmax_test)

module.cmake

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

string/test/CMakeLists.txt

@@ -1,16 +0,0 @@
-#-------------------------------------------------------------------------
-#-- Needed include directories for the tests
-boost_test_add_dependent_includes("utility;detail;config;test;mpl;bind;type_traits;static_assert;preprocessor;array;iterator;exception;range;timer")
-#-------------------------------------------------------------------------
-
-
-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()