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

Used to construct types with no default constructor. More...

#include </home/shane/workspace/cereal/include/cereal/access.hpp>

Public Member Functions

template<class... Args>
void operator() (Args &&...args)
 Construct and initialize the type T with the given arguments. More...
 
T * operator-> ()
 Get a reference to the initialized underlying object. More...
 
T * ptr ()
 Returns a raw pointer to the initialized underlying object. More...
 

Friends

template<class A , class B >
struct ::cereal::memory_detail::LoadAndConstructLoadWrapper
 

Detailed Description

template<class T>
class cereal::construct< T >

Used to construct types with no default constructor.

When serializing a type that has no default constructor, cereal will attempt to call either the class static function load_and_construct or the appropriate template specialization of LoadAndConstruct. cereal will pass that function a reference to the archive as well as a reference to a construct object which should be used to perform the allocation once data has been appropriately loaded.

struct MyType
{
// note the lack of default constructor
MyType( int xx, int yy );
int x, y;
double notInConstructor;
template <class Archive>
void serialize( Archive & ar )
{
ar( x, y );
ar( notInConstructor );
}
template <class Archive>
static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
{
int x, y;
ar( x, y );
// use construct object to initialize with loaded data
construct( x, y );
// access to member variables and functions via -> operator
ar( construct->notInConstructor );
// could also do the above section by:
double z;
ar( z );
construct->notInConstructor = z;
}
};
Template Parameters
TThe class type being serialized

Member Function Documentation

template<class T >
template<class... Args>
void cereal::construct< T >::operator() ( Args &&...  args)
inline

Construct and initialize the type T with the given arguments.

This will forward all arguments to the underlying type T, calling an appropriate constructor.

Calling this function more than once will result in an exception being thrown.

Parameters
argsThe arguments to the constructor for T
Exceptions
ExceptionIf called more than once
template<class T>
T* cereal::construct< T >::operator-> ( )
inline

Get a reference to the initialized underlying object.

This must be called after the object has been initialized.

Returns
A reference to the initialized object
Exceptions
ExceptionIf called before initialization
template<class T>
T* cereal::construct< T >::ptr ( )
inline

Returns a raw pointer to the initialized underlying object.

This is mainly intended for use with passing an instance of a constructed object to cereal::base_class.

It is strongly recommended to avoid using this function in any other circumstance.

Returns
A raw pointer to the initialized type

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