cereal_OutputArchive(3)

Public Member Functions

OutputArchive (ArchiveType *const derived)
Construct the output archive. OutputArchive & operator= (OutputArchive const &)=delete
template<class ... Types> ArchiveType & operator() (Types &&... args)
Serializes all passed in data. void serializeDeferments ()
Serializes any data marked for deferment using defer. std::uint32_t registerSharedPointer (const std::shared_ptr< const void > &sharedPointer)
Registers a shared pointer with the archive. std::uint32_t registerPolymorphicType (char const *name)
Registers a polymorphic type name with the archive.

Public Member Functions inherited from cereal::detail::OutputArchiveBase
OutputArchiveBase (OutputArchiveBase &&) CEREAL_NOEXCEPT
OutputArchiveBase & operator= (OutputArchiveBase &&) CEREAL_NOEXCEPT

Boost Transition Layer

Functionality that mirrors the syntax for Boost. This is useful if you are transitioning a large project from Boost to cereal. The preferred interface for cereal is using operator().
using is_loading = std::false_type
Indicates this archive is not intended for loading. using is_saving = std::true_type
Indicates this archive is intended for saving. template<class T> ArchiveType & operator& (T &&arg)
Serializes passed in data. template<class T> ArchiveType & operator<< (T &&arg)
Serializes passed in data.

template<class ArchiveType, std::uint32_t Flags = 0>

class cereal::OutputArchive< ArchiveType, Flags >"The base output archive class.

This is the base output archive for all output archives. If you create a custom archive class, it should derive from this, passing itself as a template parameter for the ArchiveType.

The base class provides all of the functionality necessary to properly forward data to the correct serialization functions.

Individual archives should use a combination of prologue and epilogue functions together with specializations of serialize, save, and load to alter the functionality of their serialization.

Template Parameters

template<class ArchiveType, std::uint32_t Flags = 0> using cereal::OutputArchive< ArchiveType, Flags >::is_loading = std::false_type

Indicates this archive is not intended for loading. This ensures compatibility with boost archive types. If you are transitioning from boost, you can check this value within a member or external serialize function (i.e., Archive::is_loading::value) to disable behavior specific to loading, until you can transition to split save/load or save_minimal/load_minimal functions

template<class ArchiveType, std::uint32_t Flags = 0> using cereal::OutputArchive< ArchiveType, Flags >::is_saving = std::true_type

Indicates this archive is intended for saving. This ensures compatibility with boost archive types. If you are transitioning from boost, you can check this value within a member or external serialize function (i.e., Archive::is_saving::value) to enable behavior specific to loading, until you can transition to split save/load or save_minimal/load_minimal functions

template<class ArchiveType, std::uint32_t Flags = 0> cereal::OutputArchive< ArchiveType, Flags >::OutputArchive (ArchiveType *const derived) [inline]

Construct the output archive.

Parameters

template<class ArchiveType, std::uint32_t Flags = 0> template<class T> ArchiveType & cereal::OutputArchive< ArchiveType, Flags >::operator& (T && arg) [inline]

Serializes passed in data. This is a boost compatability layer and is not the preferred way of using cereal. If you are transitioning from boost, use this until you can transition to the operator() overload

template<class ArchiveType, std::uint32_t Flags = 0> template<class ... Types> ArchiveType & cereal::OutputArchive< ArchiveType, Flags >::operator() (Types &&... args) [inline]

Serializes all passed in data. This is the primary interface for serializing data with an archive

template<class ArchiveType, std::uint32_t Flags = 0> template<class T> ArchiveType & cereal::OutputArchive< ArchiveType, Flags >::operator<< (T && arg) [inline]

Serializes passed in data. This is a boost compatability layer and is not the preferred way of using cereal. If you are transitioning from boost, use this until you can transition to the operator() overload

template<class ArchiveType, std::uint32_t Flags = 0> std::uint32_t cereal::OutputArchive< ArchiveType, Flags >::registerPolymorphicType (char const * name) [inline]

Registers a polymorphic type name with the archive. This function is used to track polymorphic types to prevent unnecessary saves of identifying strings used by the polymorphic support functionality.

template<class ArchiveType, std::uint32_t Flags = 0> std::uint32_t cereal::OutputArchive< ArchiveType, Flags >::registerSharedPointer (const std::shared_ptr< const void > & sharedPointer) [inline]

Registers a shared pointer with the archive. This function is used to track shared pointer targets to prevent unnecessary saves from taking place if multiple shared pointers point to the same data.

template<class ArchiveType, std::uint32_t Flags = 0> void cereal::OutputArchive< ArchiveType, Flags >::serializeDeferments () [inline]

Serializes any data marked for deferment using defer. This will cause any data wrapped in DeferredData to be immediately serialized