Ticket #3123: serialization.diff

boost/serialization/shared_ptr.hpp

@@ -26 +26 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/shared_ptr.hpp>
 
+#include <boost/type_traits/remove_const.hpp>
+
 #include <boost/serialization/split_free.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/version.hpp>
@@ -55 +57 @@
         };
         // don't track shared pointers
         template<class T>
-        struct tracking_level< ::boost::shared_ptr<T> > { 
+        struct tracking_level< ::boost::shared_ptr<T> > {
             typedef mpl::integral_c_tag tag;
             #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
             typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
@@ -104 +106 @@
     ar << boost::serialization::make_nvp("px", t_ptr);
 }
 
-template<class Archive, class T>
+template<class Archive, class MaybeConstT>
 inline void load(
     Archive & ar,
-    boost::shared_ptr<T> &t,
+    boost::shared_ptr<MaybeConstT> &t,
     const unsigned int file_version
 ){
     // The most common cause of trapping here would be serializing
     // something like shared_ptr<int>.  This occurs because int
     // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+    BOOST_STATIC_ASSERT((tracking_level<MaybeConstT>::value != track_never));
+
+    typedef typename boost::remove_const<MaybeConstT>::type T;
+
     T* r;
     #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
     if(file_version < 1){
@@ -130 +135 @@
         ar.append(sp);
         r = sp.get();
     }
-    else    
+    else
     #endif
     {
         ar >> boost::serialization::make_nvp("px", r);
     }
-    ar.reset(t,r);
+    boost::shared_ptr<T> nct;
+    ar.reset(nct,r);
+    t = nct;
 }
 
 template<class Archive, class T>

libs/serialization/test/test_shared_ptr.cpp

@@ -1 +1 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // test_shared_ptr.cpp
 
-// (C) Copyright 2002 Robert Ramey- http://www.rrsd.com - David Tonge  . 
+// (C) Copyright 2002 Robert Ramey- http://www.rrsd.com - David Tonge  .
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -14 +14 @@
 
 #include <boost/config.hpp>
 #if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
+namespace std{
     using ::remove;
 }
 #endif
@@ -104 +104 @@
 }
 
 void save2(
-    const char * testfile, 
-    const boost::shared_ptr<A>& first, 
+    const char * testfile,
+    const boost::shared_ptr<A>& first,
     const boost::shared_ptr<A>& second
 ){
     test_ostream os(testfile, TEST_STREAM_FLAGS);
@@ -114 +114 @@
     oa << BOOST_SERIALIZATION_NVP(second);
 }
 
+void save2c(
+    const char * testfile,
+    const boost::shared_ptr<const A>& first,
+    const boost::shared_ptr<const A>& second
+){
+    test_ostream os(testfile, TEST_STREAM_FLAGS);
+    test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
+    oa << BOOST_SERIALIZATION_NVP(first);
+    oa << BOOST_SERIALIZATION_NVP(second);
+}
+
 void load2(
-    const char * testfile, 
-    boost::shared_ptr<A>& first, 
+    const char * testfile,
+    boost::shared_ptr<A>& first,
     boost::shared_ptr<A>& second)
 {
     test_istream is(testfile, TEST_STREAM_FLAGS);
@@ -125 +136 @@
     ia >> BOOST_SERIALIZATION_NVP(second);
 }
 
+void load2c(
+    const char * testfile,
+    boost::shared_ptr<const A>& first,
+    boost::shared_ptr<const A>& second)
+{
+    test_istream is(testfile, TEST_STREAM_FLAGS);
+    test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+    ia >> BOOST_SERIALIZATION_NVP(first);
+    ia >> BOOST_SERIALIZATION_NVP(second);
+}
+
 // Run tests by serializing two shared_ptrs into an archive,
 // clearing them (deleting the objects) and then reloading the
 // objects back from an archive.
@@ -145 +167 @@
     std::remove(testfile);
 }
 
+void save_and_load2c(boost::shared_ptr<const A>& first, boost::shared_ptr<const A>& second)
+{
+    const char * testfile = boost::archive::tmpnam(NULL);
+    BOOST_REQUIRE(NULL != testfile);
+
+    save2c(testfile, first, second);
+
+    // Clear the pointers, thereby destroying the objects they contain
+    first.reset();
+    second.reset();
+
+    load2c(testfile, first, second);
+
+    BOOST_CHECK(first && first == second);
+    std::remove(testfile);
+}
+
 void save3(
-    const char * testfile, 
-    boost::shared_ptr<A>& first, 
+    const char * testfile,
+    boost::shared_ptr<A>& first,
     boost::shared_ptr<A>& second,
     boost::weak_ptr<A>& third
 ){
@@ -159 +198 @@
 }
 
 void load3(
-    const char * testfile, 
-    boost::shared_ptr<A>& first, 
+    const char * testfile,
+    boost::shared_ptr<A>& first,
     boost::shared_ptr<A>& second,
     boost::weak_ptr<A>& third
 ){
@@ -175 +214 @@
 }
 
 void save_and_load3(
-    boost::shared_ptr<A>& first, 
+    boost::shared_ptr<A>& first,
     boost::shared_ptr<A>& second,
     boost::weak_ptr<A>& third
 ){
@@ -214 +253 @@
     boost::shared_ptr<A> spa1 = spa;
     save_and_load2(spa, spa1);
 
+    // Try to save and load pointers to As, to a text archive
+    boost::shared_ptr<const A> spca = boost::shared_ptr<A>(new A);
+    boost::shared_ptr<const A> spca1 = spca;
+    save_and_load2c(spca, spca1);
+
     // test a weak pointer
     spa = boost::shared_ptr<A>(new A);
     spa1 = spa;
     boost::weak_ptr<A> wp = spa;
     save_and_load3(spa, spa1, wp);
-    
+
     // Try to save and load pointers to Bs, to a text archive
     spa = boost::shared_ptr<A>(new B);
     spa1 = spa;