Ticket #9601: 0001-Added-new-method-for-loading-tracked-pointers-which-.patch

include/boost/archive/detail/basic_pointer_iserializer.hpp

@@ -58 +58 @@
         void * & x,
         const unsigned int file_version
     ) const = 0;
+        
+        virtual void load_object_ptr_tracked(
+        basic_iarchive & ar, 
+        void * & x,
+                void * & tx,
+        const unsigned int file_version
+    ) const = 0;
 };
 
 } // namespace detail

include/boost/archive/detail/iserializer.hpp

@@ -206 +206 @@
             iserializer<Archive, T>
         >::get_const_instance();
     }
-    BOOST_DLLEXPORT virtual void load_object_ptr(
+    BOOST_DLLEXPORT virtual void load_object_ptr(       
         basic_iarchive & ar, 
         void * & x,
         const unsigned int file_version
     ) const BOOST_USED;
+        
+        BOOST_DLLEXPORT virtual void load_object_ptr_tracked(
+        basic_iarchive & ar, 
+        void * & x,
+                void * & tx,
+        const unsigned int file_version
+    ) const BOOST_USED;
 protected:
     // this should alway be a singleton so make the constructor protected
     pointer_iserializer();
@@ -428 +435 @@
     h.release();
 }
 
+// note: BOOST_DLLEXPORT is so that code for polymorphic class
+// serialized only through base class won't get optimized out
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr_tracked(
+    basic_iarchive & ar, 
+    void * & t,
+        void * & tx,
+    const unsigned int file_version
+) const
+{
+    Archive & ar_impl = 
+        boost::serialization::smart_cast_reference<Archive &>(ar);
+
+    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 situation that occurs when 
+        // load_constructor de-serializes something through a pointer.
+        ar.next_object_pointer(h.get());
+        boost::serialization::load_construct_data_adl<Archive, T>(
+            ar_impl,
+            h.get(), 
+            file_version
+        );
+                
+                //! Update the value of the stored pointer so cycles can use it.
+                tx = h.get();//Assign to the tracker the newly constructed value.
+    }
+    BOOST_CATCH(...){
+        // 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, *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>
 pointer_iserializer<Archive, T>::pointer_iserializer() :
     basic_pointer_iserializer(

src/basic_iarchive.cpp

@@ -518 +518 @@
 
         // remember that that the address of these elements could change
         // when we make another call so don't use the address
-        bpis_ptr->load_object_ptr(
+        bpis_ptr->load_object_ptr_tracked(
             ar,
             t,
+                        object_id_vector[ui].address,
             m_pending.version
         );
         BOOST_ASSERT(NULL != t);