Class Serializer¶

Defined in File serialize.h

Inheritance Relationships¶

Derived Type¶

public portal::BinarySerializer (Class BinarySerializer)

Class Documentation¶

class Serializer¶

Base class for sequential binary serialization (stream-based).

Performance-focused alternative to ArchiveObject. Writes values directly to a stream in order without intermediate property trees.

Use for: Network packets, cache files, performance-critical paths, fixed schemas Avoid for: Config files, save games, human-readable formats (use ArchiveObject instead)

Supported types: Scalars, strings, GLM vectors, std::vector, std::map, enums, custom types

BinarySerializer serializer(output_stream);
serializer.add_value(42);
serializer.add_value("hello");
serializer.add_value(glm::vec3(1, 2, 3));

See also

Deserializer for reading data back

Subclassed by portal::BinarySerializer

Public Functions

virtual ~Serializer() = default¶

template<typename T> inline void add_value(const T &t)¶

Serializes a scalar value (integral or floating-point).

Writes fundamental numeric types directly to the stream with type metadata. Supports all integral types (int8_t through int64_t, unsigned variants) and floating-point types (float, double).

Template Parameters:: T – Scalar type (integral or floating-point, excluding bool which has its own overload)
Parameters:: t – The value to serialize

template<typename T> inline void add_value(const T &t)

Serializes a 128-bit unsigned integer.

Special handling for uint128_t which requires explicit PropertyType::integer128.

Parameters:: t – The 128-bit integer to serialize

template<reflection::Vector T> inline void add_value(const T &t)¶

Serializes a std::vector of complex elements. (not fundamental)

Writes the vector size followed by each element. Each element’s serialize() method is called to write its data sequentially.

Template Parameters:: T – Vector type with complex elements
Parameters:: t – The vector to serialize

template<reflection::Vector T> inline void add_value(const T &t)

Serializes a std::vector of basic fundamental (ints, floats, etc…)

Writes the vector’s data contiguously without size prefix. For vectors of Serializable types, see the overload that writes size followed by elements.

Template Parameters:: T – Vector type with non-Serializable elements
Parameters:: t – The vector to serialize

template<reflection::String T> inline void add_value(const T &t)¶

Serializes a string value.

Writes the string with null terminator for safe deserialization. Handles std::string and other types satisfying the reflection::String concept.

Template Parameters:: T – String type (std::string, etc.)
Parameters:: t – The string to serialize

inline void add_value(const std::string_view string_view)¶

Serializes a std::string_view.

Writes the string_view with null terminator.

Parameters:: string_view – The string view to serialize

template<reflection::GlmVec1 T> inline void add_value(const T &t)¶

Serializes a GLM vec1 (single-component vector).

Template Parameters:: T – GLM vec1 type (glm::vec1, glm::ivec1, etc.)
Parameters:: t – The vector to serialize

template<reflection::GlmVec2 T> inline void add_value(const T &t)¶

Serializes a GLM vec2 (two-component vector).

Template Parameters:: T – GLM vec2 type (glm::vec2, glm::ivec2, glm::dvec2, etc.)
Parameters:: t – The vector to serialize

template<reflection::GlmVec3 T> inline void add_value(const T &t)¶

Serializes a GLM vec3 (three-component vector).

Template Parameters:: T – GLM vec3 type (glm::vec3, glm::ivec3, glm::dvec3, etc.)
Parameters:: t – The vector to serialize

template<reflection::GlmVec4 T> inline void add_value(const T &t)¶

Serializes a GLM vec4 (four-component vector).

Template Parameters:: T – GLM vec4 type (glm::vec4, glm::ivec4, glm::dvec4, etc.)
Parameters:: t – The vector to serialize

template<reflection::IsMatrix T> inline void add_value(const T &t)¶: TODO ADD DOCSTRING

template<reflection::Map T> inline void add_value(const T &t)¶

Serializes a map (std::map, std::unordered_map, etc.).

Writes the map size followed by key-value pairs in sequence. Both keys and values are serialized using their respective add_value overloads.

Template Parameters:: T – Map type
Parameters:: t – The map to serialize

template<typename T> inline void add_value(const T &t)

Serializes an enum as its underlying integer type.

Converts the enum to its underlying type (e.g., int, uint8_t) and serializes that value. More compact than the string-based enum serialization used by ArchiveObject.

Template Parameters:: T – Enum type
Parameters:: t – The enum value to serialize

template<SerializableConcept T> inline void add_value(const T &t)¶

Serializes a custom Serializable type.

Calls the type’s serialize() method, which should write its members sequentially to this Serializer.

Template Parameters:: T – Type satisfying the Serializable concept
Parameters:: t – The object to serialize

template<ExternalSerializable T> inline void add_value(const T &t)¶

Serializes a type with a SerializableType<T> specialization.

Calls SerializableType<T>::serialize() to write the object’s data sequentially. This enables non-intrusive serialization for types you don’t control.

Template Parameters:: T – Type satisfying the ExternalSerializable concept
Parameters:: t – The object to serialize

template<typename T> inline void add_value(const std::optional<T> &optional_t)¶: TODO ADD DOCSTRING

template<typename T> inline void add_value(const T &t)

Serializes types with glaze reflection metadata.

Fallback overload for types with glaze compile-time reflection. Automatically serializes all reflected fields in order. Use this for types that don’t implement serialize() but have glaze metadata.

Template Parameters:: T – Type with glaze reflection metadata (glz::reflect)
Parameters:: t – The object to serialize

inline void add_value(const char *t)¶

Serializes a C-string.

Writes the string with null terminator. Calculates length using strlen().

Parameters:: t – Null-terminated C-string

inline void add_value(void *t, const size_t length)¶

Serializes a raw binary data block.

Writes arbitrary binary data of the specified length without interpretation.

Parameters:

t – Pointer to binary data
length – Size of the binary data in bytes

inline void add_value(const StringId &id)¶

Serializes a string id.

A specialization of add_value to serialize string id, serializes only the id part, without the string to save on space,

Parameters:: id – The string id to serialize

Protected Functions

virtual void add_property(reflection::Property property) = 0¶