cereal::InputArchive< ArchiveType, Flags >(3) Library Functions Manual cereal::InputArchive< ArchiveType, Flags >(3)

# [NAME](#NAME)

cereal::InputArchive< ArchiveType, Flags > - The base input archive class.

# [SYNOPSIS](#SYNOPSIS)

#include </home/build/include/cereal/cereal.hpp>

Inherits **cereal::detail::InputArchiveBase**.

## [Public Member Functions](#Public_Member_Functions)

**InputArchive** (ArchiveType \*const derived)  
Construct the output archive. **InputArchive** & **operator=** (**InputArchive** 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::shared\_ptr< void > **getSharedPointer** (std::uint32\_t const id)  
Retrieves a shared pointer given a unique key for it. void **registerSharedPointer** (std::uint32\_t const id, std::shared\_ptr< void > ptr)  
Registers a shared pointer to its unique identifier. std::string **getPolymorphicName** (std::uint32\_t const id)  
Retrieves the string for a polymorphic type given a unique key for it. void **registerPolymorphicName** (std::uint32\_t const id, std::string const &name)  
Registers a polymorphic name string to its unique identifier.

Public Member Functions inherited from **cereal::detail::InputArchiveBase**  
**InputArchiveBase** (InputArchiveBase &&) **CEREAL\_NOEXCEPT**  
InputArchiveBase & **operator=** (InputArchiveBase &&) **CEREAL\_NOEXCEPT**

## [Friends](#Friends)

template<class A, class B, bool C, bool D, bool E, bool F> struct **detail::Construct**  
Befriend for versioning in load\_and\_construct.

## [Boost Transition Layer](#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::true\_type  
Indicates this archive is intended for loading. using **is\_saving** = std::false\_type  
Indicates this archive is not 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.

# [Detailed Description](#Detailed_Description)

## [template<class ArchiveType, std::uint32\_t Flags = 0>](#template_class_ArchiveType,_std::uint32_t_Flags_=_0_)

class cereal::InputArchive< ArchiveType, Flags >"The base input archive class.

This is the base input archive for all input 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**

*ArchiveType* The archive type that derives from **InputArchive**  
*Flags Flags to control advanced functionality. See the Flags enum for more information.*

# [Member Typedef Documentation](#Member_Typedef_Documentation)

## template<class ArchiveType, std::uint32\_t Flags = 0> using **cereal::InputArchive**< ArchiveType, **Flags** >::is\_loading = std::true\_type

Indicates this archive is 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 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> using **cereal::InputArchive**< ArchiveType, **Flags** >::is\_saving = std::false\_type

Indicates this archive is not 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 disable behavior specific to loading, until you can transition to split save/load or save\_minimal/load\_minimal functions

# [Constructor & Destructor Documentation](#Constructor_&_Destructor_Documentation)

## [template<class ArchiveType, std::uint32\_t Flags = 0> **cereal::InputArchive**< ArchiveType, **Flags** >::InputArchive (ArchiveType \*const derived) \[inline\]](#template_class_ArchiveType,_std::uint32_t_Flags_=_0__)

Construct the output archive.

**Parameters**

*derived* A pointer to the derived ArchiveType (pass this from the derived archive)

# [Member Function Documentation](#Member_Function_Documentation)

## [template<class ArchiveType, std::uint32\_t Flags = 0> std::string **cereal::InputArchive**< ArchiveType, **Flags** >::getPolymorphicName (std::uint32\_t const id) \[inline\]](#template_class_ArchiveType,_std::uint32_t_Flags_=_0__std::string_)

Retrieves the string for a polymorphic type given a unique key for it. This is used to retrieve a string previously registered during a polymorphic load.

## [template<class ArchiveType, std::uint32\_t Flags = 0> std::shared\_ptr< void > **cereal::InputArchive**< ArchiveType, **Flags** >::getSharedPointer (std::uint32\_t const id) \[inline\]](#template_class_ArchiveType,_std::uint32_t_Flags_=_0__std::shared_ptr__void___)

Retrieves a shared pointer given a unique key for it. This is used to retrieve a previously registered shared\_ptr which has already been loaded.

## template<class ArchiveType, std::uint32\_t Flags = 0> template<class T> ArchiveType & **cereal::InputArchive**< 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::InputArchive**< ArchiveType, **Flags** >::operator() (Types &&... args) \[inline\]](#template_class_ArchiveType,_std::uint32_t_Flags_=_0__template_class_)

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::InputArchive**< 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> void **cereal::InputArchive**< ArchiveType, **Flags** >::registerPolymorphicName (std::uint32\_t const id, std::string const & name) \[inline]

Registers a polymorphic name string to its unique identifier. After a polymorphic type has been loaded for the first time, it should be registered with its loaded id for future references to it.

## template<class ArchiveType, std::uint32\_t Flags = 0> void **cereal::InputArchive**< ArchiveType, **Flags** >::registerSharedPointer (std::uint32\_t const id, std::shared\_ptr< void > ptr) \[inline]

Registers a shared pointer to its unique identifier. After a shared pointer has been allocated for the first time, it should be registered with its loaded id for future references to it.

## template<class ArchiveType, std::uint32\_t Flags = 0> void **cereal::InputArchive**< ArchiveType, **Flags** >::serializeDeferments () \[inline]

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

# [Author](#Author)

Generated automatically by Doxygen for cereal from the source code.

Sat Oct 10 2026 08:08:15 cereal

---

Document: cereal_InputArchive(3) from cereal 1.3.2-r6 (Chainguard OS)
Source: https://github.com/USCiLab/cereal