cereal
A C++11 library for serialization
Public Member Functions | List of all members
cereal::memory_detail::EnableSharedStateHelper< T > Class Template Reference

#include </home/shane/workspace/cereal/include/cereal/types/memory.hpp>

Public Member Functions

 EnableSharedStateHelper (T *ptr)
 Saves the state of some type inheriting from enable_shared_from_this. More...
 
void restore ()
 Restores the state of the held pointer (can only be done once)
 
 ~EnableSharedStateHelper ()
 Restores the state of the held pointer if not done previously.
 

Detailed Description

template<class T>
class cereal::memory_detail::EnableSharedStateHelper< T >

A helper struct for saving and restoring the state of types that derive from std::enable_shared_from_this

This special struct is necessary because when a user uses load_and_construct, the weak_ptr (or whatever implementation defined variant) that allows enable_shared_from_this to function correctly will not be initialized properly.

This internal weak_ptr can also be modified by the shared_ptr that is created during the serialization of a polymorphic pointer, where cereal creates a wrapper shared_ptr out of a void pointer to the real data.

In the case of load_and_construct, this happens because it is the allocation of shared_ptr that perform this initialization, which we let happen on a buffer of memory (aligned_storage). This buffer is then used for placement new later on, effectively overwriting any initialized weak_ptr with a default initialized one, eventually leading to issues when the user calls shared_from_this.

To get around these issues, we will store the memory for the enable_shared_from_this portion of the class and replace it after whatever happens to modify it (e.g. the user performing construction or the wrapper shared_ptr in saving).

Example usage:

T * myActualPointer;
{
EnableSharedStateHelper<T> helper( myActualPointer ); // save the state
std::shared_ptr<T> myPtr( myActualPointer ); // modifies the internal weak_ptr
// helper restores state when it goes out of scope
}

When possible, this is designed to be used in an RAII fashion - it will save state on construction and restore it on destruction. The restore can be done at an earlier time (e.g. after construct() is called in load_and_construct) in which case the destructor will do nothing. Performing the restore immediately following construct() allows a user to call shared_from_this within their load_and_construct function.

Template Parameters
TType pointed to by shared_ptr

Constructor & Destructor Documentation

template<class T>
cereal::memory_detail::EnableSharedStateHelper< T >::EnableSharedStateHelper ( T *  ptr)
inline

Saves the state of some type inheriting from enable_shared_from_this.

Parameters
ptrThe raw pointer held by the shared_ptr

The documentation for this class was generated from the following file: