1.37.0 Beta 1

[SVN r49441]

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

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

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()