tidying up

include/cereal/cereal.hpp

@@ -39,8 +39,6 @@
 
 namespace cereal
 {
-  static const int32_t msb_32bit = 0x80000000;
-
   // ######################################################################
   //! An exception class thrown when things go wrong at runtime
   struct Exception : public std::runtime_error
@@ -72,7 +70,6 @@ namespace cereal
                    size() call.  In either case, any constness will be stripped away */
       NameValuePair( char const * n, T && v ) : name(n), value(const_cast<Type>(v)) {}
 
-      //std::string name;
       char const * name;
       Type value;
   };
@@ -91,6 +88,9 @@ namespace cereal
     return {name, std::forward<T>(value)};
   }
 
+  //! Creates a name value pair for the variable T, using the same name
+  #define CEREAL_NVP(T) ::cereal::make_nvp(#T, T)
+
   // ######################################################################
   //! A wrapper around data that can be serialized in a binary fashion
   template <class T>
@@ -115,9 +115,6 @@ namespace cereal
     return {std::forward<T>(data), size};
   }
 
-  //! Creates a name value pair for the variable T, using the same name
-  #define CEREAL_NVP(T) ::cereal::make_nvp(#T, T)
-
   // ######################################################################
   //! Called before a type is serialized to set up any special archive state
   //! for processing some type
@@ -155,6 +152,8 @@ namespace cereal
     // forward decls for polymorphic support
     template <class Archive, class T> struct polymorphic_serialization_support;
     struct adl_tag;
+
+    static const int32_t msb_32bit = 0x80000000;
   }
 
   //! Registers a specific Archive type with cereal
@@ -194,7 +193,7 @@ namespace cereal
         {
           auto ptrId = itsCurrentPointerId++;
           itsSharedPointerMap.insert( {addr, ptrId} );
-          return ptrId | msb_32bit; // mask MSB to be 1
+          return ptrId | detail::msb_32bit; // mask MSB to be 1
         }
         else
           return id->second;
@@ -312,7 +311,6 @@ namespace cereal
 
       //! The id to be given to the next pointer
       std::size_t itsCurrentPointerId;
-
   }; // class OutputArchive
 
   // ######################################################################
@@ -345,7 +343,7 @@ namespace cereal
 
       void registerSharedPointer(uint32_t const id, std::shared_ptr<void> ptr)
       {
-        uint32_t const stripped_id = id & ~msb_32bit;
+        uint32_t const stripped_id = id & ~detail::msb_32bit;
         itsSharedPointerMap.insert( {stripped_id, ptr} );
       }
 
@@ -459,7 +457,6 @@ namespace cereal
 
       //! Maps from addresses to pointer ids
       std::unordered_map<std::size_t, std::shared_ptr<void>> itsSharedPointerMap;
-
   }; // class InputArchive
 } // namespace cereal
 

include/cereal/types/memory.hpp

@@ -40,7 +40,7 @@ namespace cereal
     uint32_t id = ar.registerSharedPointer( ptr.get() );
     ar( id );
 
-    if( id & msb_32bit )
+    if( id & detail::msb_32bit )
     {
       ar( *ptr );
     }
@@ -56,7 +56,7 @@ namespace cereal
 
     ar( id );
 
-    if( id & msb_32bit )
+    if( id & detail::msb_32bit )
     {
       ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
       ar.registerSharedPointer(id, ptr);
@@ -77,7 +77,7 @@ namespace cereal
 
     ar( id );
 
-    if( id & msb_32bit )
+    if( id & detail::msb_32bit )
     {
       ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
       ar( *ptr );
@@ -134,7 +134,6 @@ namespace cereal
     ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
     ar( *ptr );
   }
-
 } // namespace cereal
 
 #endif // CEREAL_TYPES_SHARED_PTR_HPP_

include/cereal/types/polymorphic.hpp

@@ -27,6 +27,8 @@
 #ifndef CEREAL_TYPES_POLYMORPHIC_HPP_
 #define CEREAL_TYPES_POLYMORPHIC_HPP_
 
+#include <cereal/cereal.hpp>
+#include <memory>
 #include <cereal/details/polymorphic_impl.hpp>
 
 //! Binds a polymorhic type to all registered archives
@@ -47,4 +49,109 @@
         >::getInstance().bind();                             \
     }} // end namespaces
 
+namespace cereal
+{
+  //! Saving std::shared_ptr for polymorphic types
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
+  save( Archive & ar, std::shared_ptr<T> const & ptr )
+  {
+    uint32_t id = ar.registerSharedPointer( ptr.get() );
+    ar( id );
+
+    if( id & detail::msb_32bit )
+    {
+      ar( *ptr );
+    }
+  }
+
+  //! Loading std::shared_ptr, case when user load and allocate for polymorphic types
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_polymorphic<T>::value
+                          && traits::has_load_and_allocate<T, Archive>(), void>::type
+  load( Archive & ar, std::shared_ptr<T> & ptr )
+  {
+    uint32_t id;
+
+    ar( id );
+
+    if( id & detail::msb_32bit )
+    {
+      ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
+      ar.registerSharedPointer(id, ptr);
+    }
+    else
+    {
+      ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
+    }
+  }
+
+  //! Loading std::shared_ptr, case when no user load and allocate for polymorphic types
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_polymorphic<T>::value
+                          && !traits::has_load_and_allocate<T, Archive>(), void>::type
+  load( Archive & ar, std::shared_ptr<T> & ptr )
+  {
+    uint32_t id;
+
+    ar( id );
+
+    if( id & detail::msb_32bit )
+    {
+      ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
+      ar( *ptr );
+      ar.registerSharedPointer(id, ptr);
+    }
+    else
+    {
+      ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
+    }
+  }
+
+  //! Saving std::weak_ptr for polymorphic types
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
+  save( Archive & ar, std::weak_ptr<T> const & ptr )
+  {
+    auto sptr = ptr.lock();
+    ar( sptr );
+  }
+
+  //! Loading std::weak_ptr for polymorphic types
+  template <class Archive, class T> inline
+  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
+  load( Archive & ar, std::weak_ptr<T> & ptr )
+  {
+    std::shared_ptr<T> sptr;
+    ar( sptr );
+    ptr = sptr;
+  }
+
+  //! Saving std::unique_ptr for polymorphic types
+  template <class Archive, class T, class D> inline
+  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
+  save( Archive & ar, std::unique_ptr<T, D> const & ptr )
+  {
+    ar( *ptr );
+  }
+
+  //! Loading std::unique_ptr, case when user provides load_and_allocate for polymorphic types
+  template <class Archive, class T, class D> inline
+  typename std::enable_if<std::is_polymorphic<T>::value
+                          && traits::has_load_and_allocate<T, Archive>(), void>::type
+  load( Archive & ar, std::unique_ptr<T, D> & ptr )
+  {
+    ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
+  }
+
+  //! Loading std::unique_ptr, case when no load_and_allocate for polymorphic types
+  template <class Archive, class T, class D> inline
+  typename std::enable_if<std::is_polymorphic<T>::value
+                          && !traits::has_load_and_allocate<T, Archive>(), void>::type
+  load( Archive & ar, std::unique_ptr<T, D> & ptr )
+  {
+    ptr.reset( detail::Load<T, Archive>::load_andor_allocate( ar ) );
+    ar( *ptr );
+  }
+} // namespace cereal
 #endif // CEREAL_TYPES_POLYMORPHIC_HPP_

performance.cpp

@@ -280,7 +280,7 @@ struct PoDChild : PoDStruct
   template <class Archive>
   void serialize( Archive & ar )
   {
-    ar( cereal::base_class<PoDStruct>(this), v );
+    ar( cereal::virtual_base_class<PoDStruct>(this), v );
   };
 
   template <class Archive>

sandbox.cpp

@@ -32,7 +32,7 @@
 #include <cereal/types/memory.hpp>
 #include <cereal/types/complex.hpp>
 #include <cereal/types/boost_variant.hpp>
-#include <cereal/base_class.hpp>
+#include <cereal/types/virtual_base_class.hpp>
 
 #include <cxxabi.h>
 #include <sstream>
@@ -61,7 +61,7 @@ class Derived : public Base
     template <class Archive>
     void save( Archive & ar ) const
     {
-      ar( cereal::base_class<Base>(this) );
+      ar( cereal::virtual_base_class<Base>(this) );
       std::cout << "Derived save" << std::endl;
       ar( y );
     }
@@ -69,7 +69,7 @@ class Derived : public Base
     template <class Archive>
     void load( Archive & ar )
     {
-      ar( cereal::base_class<Base>(this) );
+      ar( cereal::virtual_base_class<Base>(this) );
       std::cout << "Derived load" << std::endl;
       ar( y );
     }