Save state before 1.36 merges.

[SVN r47337]

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;
-                std::locale m_Locale;
+                const std::ctype_base::mask m_Type;
+                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
-                    if(this==&Other) return *this;
+                    // Prepare storage
+                    m_Storage.m_dynSet=0;
+                    m_Size=Other.m_Size;
+                    const set_value_type* SrcStorage=0;
+                    set_value_type* DestStorage=0;
 
-                    // Prepare storage             
-                    const set_value_type* SrcStorage;
-                    set_value_type* DestStorage;
-
-                    if(use_fixed_storage(Other.m_Size))
+                    if(m_Size<=FIXED_STORAGE_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

@@ -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

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); \
-    test_pred(Pred, NoInput, false); \
+    BOOST_CHECK( all( string(YesInput), Pred ) );\
+    BOOST_CHECK( !all( string(NoInput), Pred ) );\
 }
 
 void classification_test()