30 #ifndef CEREAL_TYPES_SHARED_PTR_HPP_ 31 #define CEREAL_TYPES_SHARED_PTR_HPP_ 38 #if defined(_MSC_VER) && _MSC_VER < 1900 39 #define CEREAL_ALIGNOF __alignof 40 #else // not MSVC 2013 or older 41 #define CEREAL_ALIGNOF alignof 42 #endif // end MSVC check 46 namespace memory_detail
54 PtrWrapper(T && p) : ptr(std::forward<T>(p)) {}
62 template<
class T>
inline 65 return {std::forward<T>(t)};
72 template <
class Archive,
class T>
136 using BaseType = typename ::cereal::traits::get_shared_from_this_base<T>::type;
137 using ParentType = std::enable_shared_from_this<BaseType>;
138 using StorageType =
typename std::aligned_storage<sizeof(ParentType), CEREAL_ALIGNOF(ParentType)>::type;
144 itsPtr( static_cast<ParentType *>( ptr ) ),
148 std::memcpy( &itsState, itsPtr,
sizeof(ParentType) );
156 std::memcpy( itsPtr, &itsState,
sizeof(ParentType) );
169 StorageType itsState;
178 template <
class Archive,
class T>
inline 197 template <
class Archive,
class T>
inline 206 template <
class Archive,
class T>
inline 207 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
210 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
214 template <
class Archive,
class T>
inline 215 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
218 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
222 template <
class Archive,
class T>
inline 223 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
226 auto const sptr = ptr.lock();
227 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
231 template <
class Archive,
class T>
inline 232 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
235 std::shared_ptr<T> sptr;
236 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
241 template <
class Archive,
class T,
class D>
inline 242 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
245 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
249 template <
class Archive,
class T,
class D>
inline 250 typename std::enable_if<!std::is_polymorphic<T>::value,
void>::type
253 ar(
CEREAL_NVP_(
"ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
261 template <
class Archive,
class T>
inline 264 auto & ptr = wrapper.ptr;
266 uint32_t
id = ar.registerSharedPointer( ptr.get() );
269 if(
id & detail::msb_32bit )
277 template <
class Archive,
class T>
inline 278 typename std::enable_if<traits::has_load_and_construct<T, Archive>::value,
void>::type
281 auto & ptr = wrapper.ptr;
287 if(
id & detail::msb_32bit )
291 using ST =
typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
296 auto valid = std::make_shared<bool>( false );
300 ptr.reset( reinterpret_cast<T *>(
new ST() ),
306 delete reinterpret_cast<ST *
>( t );
310 ar.registerSharedPointer(
id, ptr );
313 memory_detail::loadAndConstructSharedPtr( ar, ptr.get(), typename ::cereal::traits::has_shared_from_this<T>::type() );
319 ptr = std::static_pointer_cast<T>(ar.getSharedPointer(
id));
324 template <
class Archive,
class T>
inline 325 typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value,
void>::type
328 auto & ptr = wrapper.ptr;
334 if(
id & detail::msb_32bit )
337 ar.registerSharedPointer(
id, ptr );
341 ptr = std::static_pointer_cast<T>(ar.getSharedPointer(
id));
346 template <
class Archive,
class T,
class D>
inline 349 auto & ptr = wrapper.ptr;
366 template <
class Archive,
class T,
class D>
inline 367 typename std::enable_if<traits::has_load_and_construct<T, Archive>::value,
void>::type
373 auto & ptr = wrapper.ptr;
379 using ST =
typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
383 std::unique_ptr<ST> stPtr(
new ST() );
392 ptr.reset( reinterpret_cast<T *>( stPtr.release() ) );
395 ptr.reset(
nullptr );
400 template <
class Archive,
class T,
class D>
inline 401 typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value,
void>::type
407 auto & ptr = wrapper.ptr;
416 ptr.reset(
nullptr );
424 #undef CEREAL_ALIGNOF 425 #endif // CEREAL_TYPES_SHARED_PTR_HPP_ #define CEREAL_NVP_(name, value)
Convenience for creating a templated NVP.
Definition: helpers.hpp:199
void loadAndConstructSharedPtr(Archive &ar, T *ptr, std::true_type)
Definition: memory.hpp:179
void restore()
Restores the state of the held pointer (can only be done once)
Definition: memory.hpp:152
Used to construct types with no default constructor.
Definition: access.hpp:162
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:78
A struct that acts as a wrapper around calling load_andor_construct.
Definition: memory.hpp:73
Definition: memory.hpp:133
Support for pointers to polymorphic base classes.
EnableSharedStateHelper(T *ptr)
Saves the state of some type inheriting from enable_shared_from_this.
Definition: memory.hpp:143
Definition: access.hpp:40
A wrapper class to notify cereal that it is ok to serialize the contained pointer.
Definition: memory.hpp:52
Main cereal functionality.
~EnableSharedStateHelper()
Restores the state of the held pointer if not done previously.
Definition: memory.hpp:162
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:85
LoadAndConstructLoadWrapper(T *ptr, F &&sharedFromThisFunc)
Constructor for embedding an early call for restoring shared_from_this.
Definition: memory.hpp:81
PtrWrapper< T > make_ptr_wrapper(T &&t)
Make a PtrWrapper.
Definition: memory.hpp:63
#define CEREAL_SAVE_FUNCTION_NAME
The serialization (save) function name to search for.
Definition: macros.hpp:92
Definition: traits.hpp:1316