Ticket #5876: boost.serialization2.patch

boost/archive/basic_archive.hpp

@@ -210 +210 @@
     }
 };
 
+struct tracking_level_type {
+    int t;
+    explicit tracking_level_type(const int t_ = 0)
+        : t(t_)
+    {};
+    tracking_level_type(const tracking_level_type & t_)
+        : t(t_.t)
+    {}
+    operator int () const {
+        return t;
+    };
+    operator int & () {
+        return t;
+    };
+    tracking_level_type & operator=(const int t_){
+        t = t_;
+        return *this;
+    }
+    bool operator==(const tracking_level_type & rhs) const {
+        return t == rhs.t;
+    }
+    bool operator==(const int & rhs) const {
+        return t == rhs;
+    }
+    tracking_level_type & operator=(const tracking_level_type & rhs){
+        t = rhs.t;
+        return *this;
+    }
+};
+
 struct class_name_type : 
     private boost::noncopyable 
 {

boost/archive/detail/basic_iserializer.hpp

@@ -57 +57 @@
     #endif
     ~basic_iserializer();
 public:
-    bool serialized_as_pointer() const {
+    bool maybe_serialized_as_pointer() const {
         return m_bpis != NULL;
     }
     void set_bpis(basic_pointer_iserializer *bpis){
@@ -73 +73 @@
     ) const = 0;
     // returns true if class_info should be saved
     virtual bool class_info() const = 0 ;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int) const = 0 ;
+    // returns the tracking level
+    virtual int tracking() const = 0 ;
     // returns class version
     virtual version_type version() const = 0 ;
     // returns true if this class is polymorphic

boost/archive/detail/basic_oserializer.hpp

@@ -58 +58 @@
     #endif
     ~basic_oserializer();
 public:
-    bool serialized_as_pointer() const {
+    bool maybe_serialized_as_pointer() const {
         return m_bpos != NULL;
     }
     void set_bpos(basic_pointer_oserializer *bpos){
@@ -72 +72 @@
     ) const = 0;
     // returns true if class_info should be saved
     virtual bool class_info() const = 0;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int flags) const = 0;
+    // returns the tracking level
+    virtual int tracking() const = 0;
     // returns class version
     virtual version_type version() const = 0;
     // returns true if this class is polymorphic

boost/archive/detail/iserializer.hpp

@@ -142 +142 @@
         return boost::serialization::implementation_level< T >::value 
             >= boost::serialization::object_class_info;
     }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_always
-            || ( boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_selectively
-                && serialized_as_pointer());
+        virtual int tracking() const {
+        return boost::serialization::tracking_level< T >::value;
     }
     virtual version_type version() const {
         return version_type(::boost::serialization::version< T >::value);

boost/archive/detail/oserializer.hpp

@@ -119 +119 @@
         return boost::serialization::implementation_level< T >::value 
             >= boost::serialization::object_class_info;
     }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
-            || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
-                && serialized_as_pointer());
+    virtual int tracking() const {
+        return boost::serialization::tracking_level< T >::value;
     }
     virtual version_type version() const {
         return version_type(::boost::serialization::version< T >::value);

libs/serialization/src/basic_iarchive.cpp

@@ -135 +135 @@
         const basic_iserializer * bis_ptr;
         const basic_pointer_iserializer * bpis_ptr;
         version_type file_version;
-        tracking_type tracking_level;
+        tracking_level_type tracking_level;
         bool initialized;
 
         cobject_id(const basic_iserializer & bis_) :
@@ -318 +318 @@
     if(! co.initialized){
         if(co.bis_ptr->class_info()){
             class_id_optional_type cid(class_id_type(0));
-            load(ar, cid);    // to be thrown away
-            load(ar, co.tracking_level);
-            load(ar, co.file_version);
+                        load(ar, cid);    // to be thrown away
+
+                        tracking_type tracking;
+            load(ar, tracking);
+                        co.tracking_level = tracking ? track_always : track_never;
+
+                        load(ar, co.file_version);
         }
         else{
             // override tracking with indicator from class information
-            co.tracking_level = co.bis_ptr->tracking(m_flags);
+            co.tracking_level = co.bis_ptr->tracking();
             co.file_version = version_type(
                 co.bis_ptr->version()
             );
@@ -373 +377 @@
     boost::serialization::state_saver<object_id_type> w(moveable_objects_start);
 
     // note: extra line used to evade borland issue
-    const bool tracking = co.tracking_level;
+    const bool tracking = co.tracking_level == tracking_level_type(track_always);
 
     object_id_type this_id;
     moveable_objects_start =
@@ -446 +450 @@
     load_preamble(ar, co);
 
     // extra line to evade borland issue
-    const bool tracking = co.tracking_level;
+    const bool tracking = co.tracking_level != tracking_level_type(track_never);
     // if we're tracking and the pointer has already been read
     if(tracking && ! track(ar, t))
         // we're done

libs/serialization/src/basic_oarchive.cpp

@@ -181 +181 @@
             BOOST_ASSERT(false); 
             return false;
         }
-        // returns true if objects should be tracked
-        bool tracking(const unsigned int) const {
+        // returns the tracking level
+        int tracking() const {
             BOOST_ASSERT(false);
             return false;
         }
@@ -255 +255 @@
         return;
     }
 
+        const bool has_class_info = bos.class_info();
+        const tracking_type tracking(
+                has_class_info && bos.tracking() == track_selectively && bos.maybe_serialized_as_pointer()
+                || bos.tracking() == track_always
+        );
+
     // get class information for this object
     const cobject_type & co = register_type(bos);
-    if(bos.class_info()){
+    if(has_class_info){
         if( ! co.m_initialized){
             ar.vsave(class_id_optional_type(co.m_class_id));
-            ar.vsave(tracking_type(bos.tracking(m_flags)));
+            ar.vsave(tracking);
             ar.vsave(version_type(bos.version()));
             (const_cast<cobject_type &>(co)).m_initialized = true;
         }
     }
 
     // we're not tracking this type of object
-    if(! bos.tracking(m_flags)){
+    if(!tracking){
         // just windup the preamble - no object id to write
         ar.end_preamble();
         // and save the data
@@ -317 +323 @@
     const basic_oserializer & bos = bpos_ptr->get_basic_serializer();
     std::size_t original_count = cobject_info_set.size();
     const cobject_type & co = register_type(bos);
+
+        const tracking_type tracking(bos.tracking() != track_never);
+
     if(! co.m_initialized){
         ar.vsave(co.m_class_id);
         // if its a previously unregistered class 
@@ -343 +352 @@
             }
         }
         if(bos.class_info()){
-            ar.vsave(tracking_type(bos.tracking(m_flags)));
+            ar.vsave(tracking);
             ar.vsave(version_type(bos.version()));
         }
         (const_cast<cobject_type &>(co)).m_initialized = true;
@@ -353 +362 @@
     }
 
     // if we're not tracking
-    if(! bos.tracking(m_flags)){
+    if(!tracking){
         // just save the data itself
         ar.end_preamble();
         serialization::state_saver<const void *> x(pending_object);