Serialize overloads

Synopses

Declared in <serialize.h>

Serialize a boolean to a stream as a single byte.

template<typename Stream>
void
Serialize(
    Stream& s,
    bool a);

Serialize a byte to a stream.

template<typename Stream>
void
Serialize(
    Stream& s,
    std::byte a);

Serialize a signed 16‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    int16_t a);

Serialize a signed 32‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    int32_t a);

Serialize a signed 64‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    int64_t a);

Serialize a signed 8‐bit integer to a stream.

template<typename Stream>
void
Serialize(
    Stream& s,
    int8_t a);

Serialize an unsigned 16‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    uint16_t a);

Serialize an unsigned 32‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    uint32_t a);

Serialize an unsigned 64‐bit integer to a stream in little‐endian order.

template<typename Stream>
void
Serialize(
    Stream& s,
    uint64_t a);

Serialize an unsigned 8‐bit integer to a stream.

template<typename Stream>
void
Serialize(
    Stream& s,
    uint8_t a);

Serialize any object that provides a Serialize member function.

template<
    typename Stream,
    typename T>
requires Serializable<T, Stream>
void
Serialize(
    Stream& os,
    T const& a);

Serialize a string as a CompactSize length followed by its bytes.

template<
    typename Stream,
    typename C>
void
Serialize(
    Stream& os,
    std::basic_string<C> const& str);

Serialize a string view as a CompactSize length followed by its bytes.

template<
    typename Stream,
    typename C>
void
Serialize(
    Stream& os,
    std::basic_string_view<C> const& str);

Serialize the object pointed to by a shared_ptr.

template<
    typename Stream,
    typename T>
void
Serialize(
    Stream& os,
    std::shared_ptr<T const> const& p);

Serialize the object pointed to by a unique_ptr.

template<
    typename Stream,
    typename T>
void
Serialize(
    Stream& os,
    std::unique_ptr<T const> const& p);

Deleted overload that forbids serializing char; use uint8_t or int8_t instead.

template<
    typename Stream,
    CharNotInt8 V>
void
Serialize(
    Stream& s,
    V v) = delete;

Serialize a dynamic‐extent span of basic bytes as raw bytes.

template<
    typename Stream,
    BasicByte B>
void
Serialize(
    Stream& s,
    std::span<B> span);

Serialize a pair as its first then second element.

template<
    typename Stream,
    typename K,
    typename T>
void
Serialize(
    Stream& os,
    std::pair<K, T> const& item);

Serialize a prevector.

template<
    typename Stream,
    unsigned int N,
    typename T>
void
Serialize(
    Stream& os,
    prevector<N, T> const& v);

Serialize a vector.

template<
    typename Stream,
    typename T,
    typename A>
void
Serialize(
    Stream& os,
    std::vector<T, A> const& v);

Serialize a fixed‐extent span of basic bytes as raw bytes.

template<
    typename Stream,
    BasicByte B,
    size_t N>
void
Serialize(
    Stream& s,
    std::span<B, N> span);

Serialize a std::array of basic bytes as raw bytes.

template<
    typename Stream,
    BasicByte B,
    size_t N>
void
Serialize(
    Stream& s,
    std::array<B, N> const& a);

Serialize a C array of basic bytes as raw bytes.

template<
    typename Stream,
    BasicByte B,
    size_t N>
void
Serialize(
    Stream& s,
    B const(& a)[]);

Serialize a set as a CompactSize count followed by its elements.

template<
    typename Stream,
    typename K,
    typename Pred,
    typename A>
void
Serialize(
    Stream& os,
    std::set<K, Pred, A> const& m);

Serialize a map as a CompactSize count followed by its entries.

template<
    typename Stream,
    typename K,
    typename T,
    typename Pred,
    typename A>
void
Serialize(
    Stream& os,
    std::map<K, T, Pred, A> const& m);

Parameters

Name

Description

s

The output stream.

a

The boolean value to serialize.

os

The output stream.

str

The string to serialize.

p

The shared pointer whose pointee is serialized.

v

The char value that must not be serialized.

span

The span of bytes to serialize.

item

The pair to serialize.

m

The set to serialize.

Created with MrDocs