[Boost-commit] svn:boost r86486 - in trunk/boost/archive: . detail impl

Subject: [Boost-commit] svn:boost r86486 - in trunk/boost/archive: . detail impl
From: ramey_at_[hidden]
Date: 2013-10-27 16:38:43

Author: ramey
Date: 2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)
New Revision: 86486
URL: http://svn.boost.org/trac/boost/changeset/86486

Log:
correct rounding
fix memory leak for constructor failure in load_construct_data
fix another bug in loading pointers

Text files modified: 
   trunk/boost/archive/basic_text_oprimitive.hpp      |    70 +++++++++++++++-------                  
   trunk/boost/archive/detail/iserializer.hpp         |   122 +++++++++++++++++++++++++++++++++++---- 
   trunk/boost/archive/impl/basic_text_oprimitive.ipp |     1                                         
   trunk/boost/archive/impl/xml_oarchive_impl.ipp     |     2                                         
   trunk/boost/archive/impl/xml_wiarchive_impl.ipp    |     2                                         
   trunk/boost/archive/impl/xml_woarchive_impl.ipp    |     2                                         
   6 files changed, 159 insertions(+), 40 deletions(-)

Modified: trunk/boost/archive/basic_text_oprimitive.hpp
==============================================================================
--- trunk/boost/archive/basic_text_oprimitive.hpp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/basic_text_oprimitive.hpp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -26,7 +26,7 @@
 
 #include <iomanip>
 #include <locale>
-#include <boost/config/no_tr1/cmath.hpp> // isnan
+//#include <boost/config/no_tr1/cmath.hpp> // isnan
 #include <boost/assert.hpp>
 #include <cstddef> // size_t
 
@@ -46,6 +46,8 @@
 } // namespace std
 #endif
 
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/mpl/bool.hpp>
 #include <boost/limits.hpp>
 #include <boost/integer.hpp>
 #include <boost/io/ios_state.hpp>
@@ -82,16 +84,6 @@
     > locale_saver;
     #endif
 
-    // default saving of primitives.
-    template<class T>
-    void save(const T &t){
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os << t;
-    }
-
     /////////////////////////////////////////////////////////
     // fundamental types that need special treatment
     void save(const bool t){
@@ -123,32 +115,62 @@
         save(static_cast<int>(t));
     }
     #endif
-    void save(const float t)
-    {
-        // must be a user mistake - can't serialize un-initialized data
+
+    /////////////////////////////////////////////////////////
+    // saving of any types not listed above
+
+    template<class T>
+    void save_impl(const T &t, boost::mpl::bool_<false> &){
         if(os.fail())
             boost::serialization::throw_exception(
                 archive_exception(archive_exception::output_stream_error)
             );
-        // The formulae for the number of decimla digits required is given in
-        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
-        // which is derived from Kahan's paper:
-        // http://http.cs.berkley.edu/~wkahan/ieee754status/ieee754.ps
-        unsigned int digits = std::numeric_limits<float>::digits * 3010;
-        digits /= 10000;
-        os << std::setprecision(digits);
         os << t;
     }
-    void save(const double t)
-    {
+
+    /////////////////////////////////////////////////////////
+    // floating point types need even more special treatment
+    // the following determines whether the type T is some sort
+    // of floating point type.  Note that we then assume that
+    // the stream << operator is defined on that type - if not
+    // we'll get a compile time error. This is meant to automatically
+    // support synthesized types which support floating point
+    // operations. Also it should handle compiler dependent types
+    // such long double.  Due to John Maddoc.
+
+    template<class T>
+    struct is_float {
+        typedef BOOST_DEDUCED_TYPENAME mpl::bool_< 
+            boost::is_floating_point<T>::value 
+            || (std::numeric_limits<T>::is_specialized
+            && !std::numeric_limits<T>::is_integer
+            && !std::numeric_limits<T>::is_exact
+            && std::numeric_limits<T>::max_exponent) 
+        >::type type;
+    };
+
+    template<class T>
+    void save_impl(const T &t, boost::mpl::bool_<true> &){
         // must be a user mistake - can't serialize un-initialized data
         if(os.fail())
             boost::serialization::throw_exception(
                 archive_exception(archive_exception::output_stream_error)
             );
-        os << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+        // The formulae for the number of decimla digits required is given in
+        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
+        // which is derived from Kahan's paper:
+        // http://http.cs.berkley.edu/~wkahan/ieee754status/ieee754.ps
+        const unsigned int digits = (std::numeric_limits<float>::digits * 3010) / 10000;
+        os << std::setprecision(digits);
         os << t;
     }
+
+    template<class T>
+    void save(const T & t){
+        BOOST_DEDUCED_TYPENAME is_float<T>::type tf;
+        save_impl(t, tf);
+    }
+
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
     basic_text_oprimitive(OStream & os, bool no_codecvt);
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 

Modified: trunk/boost/archive/detail/iserializer.hpp
==============================================================================
--- trunk/boost/archive/detail/iserializer.hpp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/detail/iserializer.hpp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -232,6 +232,7 @@
 //    }
 //}
 
+#if 0
 template<class T>
 struct heap_allocator
 {
@@ -288,6 +289,99 @@
 private:
     T* m_p;
 };
+#endif
+
+// the purpose of this code is to allocate memory for an object
+// without requiring the constructor to be called.  Presumably
+// the allocated object will be subsequently initialized with
+// "placement new". 
+// note: we have the boost type trait has_new_operator but we
+// have no corresponding has_delete_operator.  So we presume
+// that the former being true would imply that the a delete
+// operator is also defined for the class T.
+
+template<class T>
+struct heap_allocation {
+    // boost::has_new_operator< T > doesn't work on these compilers
+    #if DONT_USE_HAS_NEW_OPERATOR
+        // This doesn't handle operator new overload for class T
+        static T * invoke_new(){
+            return static_cast<T *>(operator new(sizeof(T)));
+        }
+        static viod invoke_delete(){
+            (operator delete(sizeof(T)));
+        }
+    #else
+        // note: we presume that a true value for has_new_operator
+        // implies the existence of a class specific delete operator as well
+        // as a class specific new operator.
+        struct has_new_operator {
+            static T * invoke_new() {
+                return static_cast<T *>((T::operator new)(sizeof(T)));
+            }
+            static void invoke_delete(T * t) {
+                // if compilation fails here, the likely cause that the class
+                // T has a class specific new operator but no class specific
+                // delete operator which matches the following signature.  Fix
+                // your program to have this.  Note that adding operator delete
+                // with only one parameter doesn't seem correct to me since 
+                // the standard(3.7.4.2) says "
+                // "If a class T has a member deallocation function named
+                // 'operator delete' with exactly one parameter, then that function 
+                // is a usual (non-placement) deallocation function" which I take
+                // to mean that it will call the destructor of type T which we don't
+                // want to do here.
+                // Note: reliance upon automatic conversion from T * to void * here
+                (T::operator delete)(t, sizeof(T));
+            }
+        };
+        struct doesnt_have_new_operator {
+            static T* invoke_new() {
+                return static_cast<T *>(operator new(sizeof(T)));
+            }
+            static void invoke_delete(T * t) {
+                // Note: I'm reliance upon automatic conversion from T * to void * here
+                (operator delete)(t);
+            }
+        };
+        static T * invoke_new() {
+            typedef BOOST_DEDUCED_TYPENAME
+                mpl::eval_if<
+                    boost::has_new_operator< T >,
+                    mpl::identity<has_new_operator >,
+                    mpl::identity<doesnt_have_new_operator >    
+                >::type typex;
+            return typex::invoke_new();
+        }
+        static void invoke_delete(T *t) {
+            typedef BOOST_DEDUCED_TYPENAME
+                mpl::eval_if<
+                    boost::has_new_operator< T >,
+                    mpl::identity<has_new_operator >,
+                    mpl::identity<doesnt_have_new_operator >    
+                >::type typex;
+            typex::invoke_delete(t);
+        }
+    #endif
+    explicit heap_allocation(){
+        m_p = invoke_new();
+    }
+    ~heap_allocation(){
+        if (0 != m_p)
+            invoke_delete(m_p);
+    }
+    T* get() const {
+        return m_p;
+    }
+
+    T* release() {
+        T* p = m_p;
+        m_p = 0;
+        return p;
+    }
+private:
+    T* m_p;
+};
 
 // note: BOOST_DLLEXPORT is so that code for polymorphic class
 // serialized only through base class won't get optimized out
@@ -301,35 +395,37 @@
     Archive & ar_impl = 
         boost::serialization::smart_cast_reference<Archive &>(ar);
 
-    t  = heap_allocator< T >::invoke();
-    if(NULL == t)
-        boost::serialization::throw_exception(std::bad_alloc()) ;
+    heap_allocation<T> h;
+    t = NULL;
+    // note that the above will throw std::bad_alloc if the allocation
+    // fails so we don't have to address this contingency here.
 
     // catch exception during load_construct_data so that we don't
     // automatically delete the t which is most likely not fully
     // constructed
     BOOST_TRY {
-        // this addresses an obscure situtation that occurs when 
+        // this addresses an obscure situation that occurs when 
         // load_constructor de-serializes something through a pointer.
-        ar.next_object_pointer(t);
+        ar.next_object_pointer(h.get());
         boost::serialization::load_construct_data_adl<Archive, T>(
             ar_impl,
-            static_cast<T *>(t), 
+            h.get(), 
             file_version
         );
     }
     BOOST_CATCH(...){
-        // don't destroy the object - because it was never really
-        // constructed.
-        //boost::serialization::access::destroy(t);
-        // just recover the memory
-        delete t;
-        t = NULL;   // don't leave junk in t
+        // if we get here the load_construct failed.  The heap_allocation
+        // will be automatically deleted so we don't have to do anything
+        // special here.
         BOOST_RETHROW;
     }
     BOOST_CATCH_END
 
-    ar_impl >> boost::serialization::make_nvp(NULL, *static_cast<T *>(t));
+    ar_impl >> boost::serialization::make_nvp(NULL, *h.get());
+    // success !!! - release the heap allocation so it
+    // doesn't delete the object we just loaded.
+    t = h.get();
+    h.release();
 }
 
 template<class Archive, class T>

Modified: trunk/boost/archive/impl/basic_text_oprimitive.ipp
==============================================================================
--- trunk/boost/archive/impl/basic_text_oprimitive.ipp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/impl/basic_text_oprimitive.ipp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -9,6 +9,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 #include <cstddef> // NULL
+#include <algorithm> // std::copy
 #include <boost/serialization/pfto.hpp>
 
 #include <boost/archive/basic_text_oprimitive.hpp>

Modified: trunk/boost/archive/impl/xml_oarchive_impl.ipp
==============================================================================
--- trunk/boost/archive/impl/xml_oarchive_impl.ipp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/impl/xml_oarchive_impl.ipp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -8,7 +8,7 @@
 
 #include <ostream>
 #include <iomanip>
-#include <algorithm>
+#include <algorithm> // std::copy
 #include <string>
 
 #include <cstring> // strlen

Modified: trunk/boost/archive/impl/xml_wiarchive_impl.ipp
==============================================================================
--- trunk/boost/archive/impl/xml_wiarchive_impl.ipp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/impl/xml_wiarchive_impl.ipp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -21,7 +21,7 @@
 #ifndef BOOST_NO_STD_WSTREAMBUF
 
 #include <boost/assert.hpp>
-#include <algorithm>
+#include <algorithm> // std::copy
 
 #include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)

Modified: trunk/boost/archive/impl/xml_woarchive_impl.ipp
==============================================================================
--- trunk/boost/archive/impl/xml_woarchive_impl.ipp	Sun Oct 27 16:37:44 2013	(r86485)
+++ trunk/boost/archive/impl/xml_woarchive_impl.ipp	2013-10-27 16:38:43 EDT (Sun, 27 Oct 2013)	(r86486)
@@ -11,7 +11,7 @@
 
 #include <ostream>
 #include <string>
-#include <algorithm>
+#include <algorithm> // std::copy
 #include <locale>
 
 #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings