Made OutputBinding serializers

include/cereal/types/memory.hpp

@@ -74,7 +74,8 @@ namespace cereal
   typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
   save( Archive & ar, std::weak_ptr<T> const & ptr )
   {
-    ar( detail::make_ptr_wrapper( ptr ) );
+    auto sptr = ptr.lock();
+    ar( detail::make_ptr_wrapper( sptr ) );
   }
 
   //! Loading std::weak_ptr for non polymorphic types
@@ -82,7 +83,9 @@ namespace cereal
   typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
   load( Archive & ar, std::weak_ptr<T> & ptr )
   {
-    ar( detail::make_ptr_wrapper( ptr ) );
+    std::shared_ptr<T> sptr;
+    ar( detail::make_ptr_wrapper( sptr ) );
+    ptr = sptr;
   }
 
   //! Saving std::unique_ptr for non polymorphic types
@@ -121,8 +124,7 @@ namespace cereal
 
   //! Loading std::shared_ptr, case when user load and allocate (wrapper implementation)
   template <class Archive, class T> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value
+  typename std::enable_if<traits::has_load_and_allocate<T, Archive>(), void>::type
-                          && traits::has_load_and_allocate<T, Archive>(), void>::type
   load( Archive & ar, detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
   {
     auto & ptr = wrapper.ptr;
@@ -144,8 +146,7 @@ namespace cereal
 
   //! Loading std::shared_ptr, case when no user load and allocate (wrapper implementation)
   template <class Archive, class T> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value
+  typename std::enable_if<!traits::has_load_and_allocate<T, Archive>(), void>::type
-                          && !traits::has_load_and_allocate<T, Archive>(), void>::type
   load( Archive & ar, detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
   {
     auto & ptr = wrapper.ptr;
@@ -166,33 +167,9 @@ namespace cereal
     }
   }
 
-  //! Saving std::weak_ptr (wrapper implementation)
-  template <class Archive, class T> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
-  save( Archive & ar, detail::PtrWrapper<std::weak_ptr<T> const &> const & wrapper )
-  {
-    auto & ptr = wrapper.ptr;
-
-    auto sptr = ptr.lock();
-    ar( sptr );
-  }
-
-  //! Loading std::weak_ptr (wrapper implementation)
-  template <class Archive, class T> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
-  load( Archive & ar, detail::PtrWrapper<std::weak_ptr<T> &> & wrapper )
-  {
-    auto & ptr = wrapper.ptr;
-
-    std::shared_ptr<T> sptr;
-    ar( sptr );
-    ptr = sptr;
-  }
-
   //! Saving std::unique_ptr (wrapper implementation)
   template <class Archive, class T, class D> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
+  void save( Archive & ar, detail::PtrWrapper<std::unique_ptr<T, D> const &> const & wrapper )
-  save( Archive & ar, detail::PtrWrapper<std::unique_ptr<T, D> const &> const & wrapper )
   {
     auto & ptr = wrapper.ptr;
     ar( *ptr );
@@ -200,8 +177,7 @@ namespace cereal
 
   //! Loading std::unique_ptr, case when user provides load_and_allocate (wrapper implementation)
   template <class Archive, class T, class D> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value
+  typename std::enable_if<traits::has_load_and_allocate<T, Archive>(), void>::type
-                          && traits::has_load_and_allocate<T, Archive>(), void>::type
   load( Archive & ar, detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
   {
     auto & ptr = wrapper.ptr;
@@ -210,8 +186,7 @@ namespace cereal
 
   //! Loading std::unique_ptr, case when no load_and_allocate (wrapper implementation)
   template <class Archive, class T, class D> inline
-  typename std::enable_if<!std::is_polymorphic<T>::value
+  typename std::enable_if<!traits::has_load_and_allocate<T, Archive>(), void>::type
-                          && !traits::has_load_and_allocate<T, Archive>(), void>::type
   load( Archive & ar, detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
   {
     auto & ptr = wrapper.ptr;

sandbox_rtti.cpp

@@ -29,7 +29,25 @@
 #include <cereal/archives/binary.hpp>
 #include <cereal/types/polymorphic.hpp>
 
-struct MyType {};
+struct Base 
+{
+  virtual void foo() = 0;
+
+  template<class Archive>
+    void serialize(Archive & ar)
+    {
+    }
+};
+
+struct MyType : public Base
+{
+  void foo() {}
+
+  template<class Archive>
+    void serialize(Archive & ar)
+    {
+    }
+};
 
 CEREAL_BIND_TO_ARCHIVES(MyType);
 
@@ -37,6 +55,16 @@ template <class T> void nop(T&&t) {}
 
 int main()
 {
+  cereal::BinaryOutputArchive archive(std::cout);
+  //auto ptr = std::make_shared<MyType>();
+
+
+  std::shared_ptr<int> const ptr(new int);
+
+  archive(cereal::detail::make_ptr_wrapper(ptr));
+
+  //cereal::detail::PtrWrapper<const std::unique_ptr<const MyType, cereal::detail::EmptyDeleter<const MyType> > &>
+
 
 
 }