cereal::DeferredData< T > Class Template Reference

A wrapper around data that should be serialized after all non-deferred data. More...

#include <helpers.hpp>

Inheritance diagram for cereal::DeferredData< T >:

Public Member Functions
	DeferredData (T &&v)
	Constructs a new NameValuePair. More...

Public Attributes
Type	value

Private Types
using	Type = typename std::conditional< std::is_array< typename std::remove_reference< T >::type >::value, typename std::remove_cv< T >::type, typename std::conditional< std::is_lvalue_reference< T >::value, T, typename std::decay< T >::type >::type >::type

Private Member Functions
DeferredData &	operator= (DeferredData const &)=delete

Related Functions
(Note that these are not member functions.)
template<class T >
DeferredData< T >	defer (T &&value)
	Marks data for deferred serialization. More...

Detailed Description

template<class T>
class cereal::DeferredData< T >

A wrapper around data that should be serialized after all non-deferred data.

This class is used to demarcate data that can only be safely serialized after any data not wrapped in this class.

Member Typedef Documentation

Type

template<class T >

using cereal::DeferredData< T >::Type = typename std::conditional<std::is_array<typename std::remove_reference<T>::type>::value, typename std::remove_cv<T>::type, typename std::conditional<std::is_lvalue_reference<T>::value, T, typename std::decay<T>::type>::type>::type

private

Constructor & Destructor Documentation

DeferredData()

template<class T >

cereal::DeferredData< T >::DeferredData ( T &&  v )

inline

Constructs a new NameValuePair.

Parameters

v

The value to defer. Ideally this should be an l-value reference so that the value can be both loaded and saved to. If you pass an r-value reference, the DeferredData will store a copy of it instead of a reference. Thus you should only pass r-values in cases where this makes sense, such as the result of some size() call.

Member Function Documentation

operator=()

template<class T >

DeferredData& cereal::DeferredData< T >::operator= ( DeferredData< T > const &  )

privatedelete

Friends And Related Function Documentation

defer()

template<class T >

DeferredData< T > defer ( T &&  value )

related

Marks data for deferred serialization.

cereal performs a recursive depth-first traversal of data it serializes. When serializing smart pointers to large, nested, or cyclical data structures, it is possible to encounter a stack overflow from excessive recursion when following a chain of pointers.

Deferment can help in these situations if the data can be serialized separately from the pointers used to traverse the structure. For example, a graph structure can have its nodes serialized before its edges:

struct MyEdge
{
  std::shared_ptr<MyNode> connection;
  int some_value;
 
  template<class Archive>
  void serialize(Archive & archive)
  {
    // when we serialize an edge, we'll defer serializing the associated node
    archive( cereal::defer( connection ),
             some_value );
  }
};
 
struct MyGraphStructure
{
  std::vector<MyEdge> edges;
  std::vector<MyNodes> nodes;
 
  template<class Archive>
  void serialize(Archive & archive)
  {
    // because of the deferment, we ensure all nodes are fully serialized
    // before any connection pointers to those nodes are serialized
    archive( edges, nodes );
 
    // we have to explicitly inform the archive when it is safe to serialize
    // the deferred data
    archive.serializeDeferments();
  }
};

Member Data Documentation

value

template<class T >

Type cereal::DeferredData< T >::value

---

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

• /home/runner/work/NDDEM/NDDEM/src/Dem/cereal/details/helpers.hpp
• /home/runner/work/NDDEM/NDDEM/src/Dem/cereal/cereal.hpp