#include <compat/endian.h>
#include <algorithm>
#include <assert.h>
#include <ios>
#include <limits>
#include <map>
#include <memory>
#include <set>
#include <stdint.h>
#include <string>
#include <string.h>
#include <utility>
#include <vector>
#include <prevector.h>
#include <span.h>

Classes
struct	deserialize_type

struct	CheckVarIntMode< Mode, I >

class	CVarInt< Mode, I >

class	BigEndian< I >

class	CCompactSize

class	LimitedString< Limit >

struct	CSerActionSerialize

struct	CSerActionUnserialize

class	CSizeComputer

Macros
#define	READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))

#define	READWRITEAS(type, obj) (::SerReadWriteMany(s, ser_action, ReadWriteAsHelper<type>(obj)))

#define	ADD_SERIALIZE_METHODS

#define	VARINT(obj, ...) WrapVarInt<__VA_ARGS__>(REF(obj))

#define	COMPACTSIZE(obj) CCompactSize(REF(obj))

#define	LIMITED_STRING(obj, n) LimitedString< n >(REF(obj))

Enumerations
enum	{ SER_NETWORK = (1 << 0), SER_DISK = (1 << 1), SER_GETHASH = (1 << 2) }

enum	VarIntMode { VarIntMode::DEFAULT, VarIntMode::NONNEGATIVE_SIGNED }

Functions
template<typename T >
T &	REF (const T &val)

template<typename T >
T *	NCONST_PTR (const T *val)

char *	CharCast (char *c)
	Safely convert odd char pointer types to standard ones. More...

char *	CharCast (unsigned char *c)

const char *	CharCast (const char *c)

const char *	CharCast (const unsigned char *c)

template<typename Stream >
void	ser_writedata8 (Stream &s, uint8_t obj)

template<typename Stream >
void	ser_writedata16 (Stream &s, uint16_t obj)

template<typename Stream >
void	ser_writedata16be (Stream &s, uint16_t obj)

template<typename Stream >
void	ser_writedata32 (Stream &s, uint32_t obj)

template<typename Stream >
void	ser_writedata32be (Stream &s, uint32_t obj)

template<typename Stream >
void	ser_writedata64 (Stream &s, uint64_t obj)

template<typename Stream >
uint8_t	ser_readdata8 (Stream &s)

template<typename Stream >
uint16_t	ser_readdata16 (Stream &s)

template<typename Stream >
uint16_t	ser_readdata16be (Stream &s)

template<typename Stream >
uint32_t	ser_readdata32 (Stream &s)

template<typename Stream >
uint32_t	ser_readdata32be (Stream &s)

template<typename Stream >
uint64_t	ser_readdata64 (Stream &s)

uint64_t	ser_double_to_uint64 (double x)

uint32_t	ser_float_to_uint32 (float x)

double	ser_uint64_to_double (uint64_t y)

float	ser_uint32_to_float (uint32_t y)

template<typename X >
X &	ReadWriteAsHelper (X &x)
	Convert the reference base type to X, without changing constness or reference type. More...

template<typename X >
const X &	ReadWriteAsHelper (const X &x)

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

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

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

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

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

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

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

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

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

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

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

template<typename Stream , int N>
void	Serialize (Stream &s, const char(&a)[N])

template<typename Stream , int N>
void	Serialize (Stream &s, const unsigned char(&a)[N])

template<typename Stream >
void	Serialize (Stream &s, const Span< const unsigned char > &span)

template<typename Stream >
void	Serialize (Stream &s, const Span< unsigned char > &span)

template<typename Stream >
void	Unserialize (Stream &s, char &a)

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

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

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

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

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

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

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

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

template<typename Stream >
void	Unserialize (Stream &s, float &a)

template<typename Stream >
void	Unserialize (Stream &s, double &a)

template<typename Stream , int N>
void	Unserialize (Stream &s, char(&a)[N])

template<typename Stream , int N>
void	Unserialize (Stream &s, unsigned char(&a)[N])

template<typename Stream >
void	Unserialize (Stream &s, Span< unsigned char > &span)

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

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

unsigned int	GetSizeOfCompactSize (uint64_t nSize)

void	WriteCompactSize (CSizeComputer &os, uint64_t nSize)

template<typename Stream >
void	WriteCompactSize (Stream &os, uint64_t nSize)

template<typename Stream >
uint64_t	ReadCompactSize (Stream &is)

template<VarIntMode Mode, typename I >
unsigned int	GetSizeOfVarInt (I n)

template<typename I >
void	WriteVarInt (CSizeComputer &os, I n)

template<typename Stream , VarIntMode Mode, typename I >
void	WriteVarInt (Stream &os, I n)

template<typename Stream , VarIntMode Mode, typename I >
I	ReadVarInt (Stream &is)

template<VarIntMode Mode = VarIntMode::DEFAULT, typename I >
CVarInt< Mode, I >	WrapVarInt (I &n)

template<typename I >
BigEndian< I >	WrapBigEndian (I &n)

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

template<typename Stream , typename C >
void	Unserialize (Stream &is, std::basic_string< C > &str)

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

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

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

template<typename Stream , unsigned int N, typename T >
void	Unserialize_impl (Stream &is, prevector< N, T > &v, const unsigned char &)

template<typename Stream , unsigned int N, typename T , typename V >
void	Unserialize_impl (Stream &is, prevector< N, T > &v, const V &)

template<typename Stream , unsigned int N, typename T >
void	Unserialize (Stream &is, prevector< N, T > &v)

template<typename Stream , typename T , typename A >
void	Serialize_impl (Stream &os, const std::vector< T, A > &v, const unsigned char &)

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

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

template<typename Stream , typename T , typename A >
void	Unserialize_impl (Stream &is, std::vector< T, A > &v, const unsigned char &)

template<typename Stream , typename T , typename A , typename V >
void	Unserialize_impl (Stream &is, std::vector< T, A > &v, const V &)

template<typename Stream , typename T , typename A >
void	Unserialize (Stream &is, std::vector< T, A > &v)

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

template<typename Stream , typename K , typename T >
void	Unserialize (Stream &is, std::pair< K, T > &item)

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

template<typename Stream , typename K , typename T , typename Pred , typename A >
void	Unserialize (Stream &is, std::map< K, T, Pred, A > &m)

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

template<typename Stream , typename K , typename Pred , typename A >
void	Unserialize (Stream &is, std::set< K, Pred, A > &m)

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

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

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

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

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

template<typename Stream , typename T >
void	Unserialize (Stream &is, T &&a)

template<typename Stream >
void	SerializeMany (Stream &s)

template<typename Stream , typename Arg , typename... Args>
void	SerializeMany (Stream &s, const Arg &arg, const Args &... args)

template<typename Stream >
void	UnserializeMany (Stream &s)

template<typename Stream , typename Arg , typename... Args>
void	UnserializeMany (Stream &s, Arg &&arg, Args &&... args)

template<typename Stream , typename... Args>
void	SerReadWriteMany (Stream &s, CSerActionSerialize ser_action, const Args &... args)

template<typename Stream , typename... Args>
void	SerReadWriteMany (Stream &s, CSerActionUnserialize ser_action, Args &&... args)

template<typename T >
size_t	GetSerializeSize (const T &t, int nVersion=0)

template<typename... T>
size_t	GetSerializeSizeMany (int nVersion, const T &... t)

Variables
static const unsigned int	MAX_SIZE = 0x02000000

constexpr deserialize_type	deserialize {}

Macro Definition Documentation

◆ ADD_SERIALIZE_METHODS

#define ADD_SERIALIZE_METHODS

Value:

template<typename Stream>                                         \
    void Serialize(Stream& s) const {                                 \
        NCONST_PTR(this)->SerializationOp(s, CSerActionSerialize());  \
    }                                                                 \
    template<typename Stream>                                         \
    void Unserialize(Stream& s) {                                     \
        SerializationOp(s, CSerActionUnserialize());                  \
    }

Implement three methods for serializable objects. These are actually wrappers over "SerializationOp" template, which implements the body of each class' serialization code. Adding "ADD_SERIALIZE_METHODS" in the body of the class causes these wrappers to be added as members.

◆ COMPACTSIZE

#define COMPACTSIZE ( obj ) CCompactSize(REF(obj))

◆ LIMITED_STRING

#define LIMITED_STRING	(	obj,
		n
	)	LimitedString< n >(REF(obj))

◆ READWRITE

#define READWRITE ( ... ) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))

◆ READWRITEAS

#define READWRITEAS	(	type,
		obj
	)	(::SerReadWriteMany(s, ser_action, ReadWriteAsHelper<type>(obj)))

◆ VARINT

#define VARINT	(	obj,
		...
	)	WrapVarInt<__VA_ARGS__>(REF(obj))

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
SER_NETWORK
SER_DISK
SER_GETHASH

◆ VarIntMode

enum VarIntMode

strong

Variable-length integers: bytes are a MSB base-128 encoding of the number. The high bit in each byte signifies whether another digit follows. To make sure the encoding is one-to-one, one is subtracted from all but the last digit. Thus, the byte sequence a[] with length len, where all but the last byte has bit 128 set, encodes the number:

(a[len-1] & 0x7F) + sum(i=1..len-1, 128^i*((a[len-i-1] & 0x7F)+1))

Properties:

Very small (0-127: 1 byte, 128-16511: 2 bytes, 16512-2113663: 3 bytes)
Every integer has exactly one encoding
Encoding does not depend on size of original integer type
No redundancy: every (infinite) byte sequence corresponds to a list of encoded integers.

0: [0x00] 256: [0x81 0x00] 1: [0x01] 16383: [0xFE 0x7F] 127: [0x7F] 16384: [0xFF 0x00] 128: [0x80 0x00] 16511: [0xFF 0x7F] 255: [0x80 0x7F] 65535: [0x82 0xFE 0x7F] 2^32: [0x8E 0xFE 0xFE 0xFF 0x00]Mode for encoding VarInts.

Currently there is no support for signed encodings. The default mode will not compile with signed values, and the legacy "nonnegative signed" mode will accept signed values, but improperly encode and decode them if they are negative. In the future, the DEFAULT mode could be extended to support negative numbers in a backwards compatible way, and additional modes could be added to support different varint formats (e.g. zigzag encoding).

Enumerator
DEFAULT
NONNEGATIVE_SIGNED

Function Documentation

◆ CharCast() [1/4]

char* CharCast ( char * c )

inline

Safely convert odd char pointer types to standard ones.

Compact Size size < 253 – 1 byte size <= USHRT_MAX – 3 bytes (253 + 2 bytes) size <= UINT_MAX – 5 bytes (254 + 4 bytes) size > UINT_MAX – 9 bytes (255 + 8 bytes)

◆ GetSizeOfVarInt()

template<VarIntMode Mode, typename I >

unsigned int GetSizeOfVarInt ( I n )

inline

◆ NCONST_PTR()

template<typename T >

T* NCONST_PTR ( const T * val )

inline

Used to acquire a non-const pointer "this" to generate bodies of const serialization operations from a template

◆ ReadCompactSize()

template<typename Stream >

uint64_t ReadCompactSize ( Stream & is )

◆ ReadVarInt()

template<typename Stream , VarIntMode Mode, typename I >

I ReadVarInt ( Stream & is )

◆ ReadWriteAsHelper() [1/2]

template<typename X >

X& ReadWriteAsHelper ( X & x )

Convert the reference base type to X, without changing constness or reference type.

◆ ReadWriteAsHelper() [2/2]

template<typename X >

const X& ReadWriteAsHelper ( const X & x )

◆ REF()

template<typename T >

T& REF ( const T & val )

inline

Used to bypass the rule against non-const reference to temporary where it makes sense with wrappers.

◆ ser_double_to_uint64()

uint64_t ser_double_to_uint64 ( double x )

inline

float ser_uint32_to_float ( uint32_t y )

inline

◆ ser_uint64_to_double()

double ser_uint64_to_double ( uint64_t y )

inline

◆ ser_writedata16()

template<typename Stream >

void ser_writedata16	(	Stream &	s,
		uint16_t	obj
	)

inline

◆ ser_writedata16be()

template<typename Stream >

void ser_writedata16be	(	Stream &	s,
		uint16_t	obj
	)

inline

◆ ser_writedata32()

template<typename Stream >

void ser_writedata32	(	Stream &	s,
		uint32_t	obj
	)

inline

◆ ser_writedata32be()

template<typename Stream >

void ser_writedata32be	(	Stream &	s,
		uint32_t	obj
	)

inline

◆ ser_writedata64()

template<typename Stream >

void ser_writedata64	(	Stream &	s,
		uint64_t	obj
	)

inline

◆ ser_writedata8()

template<typename Stream >

void ser_writedata8	(	Stream &	s,
		uint8_t	obj
	)

inline

◆ Serialize() [1/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		char	a
	)

inline

◆ Serialize() [2/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		int8_t	a
	)

inline

◆ Serialize() [3/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		uint8_t	a
	)

inline

◆ Serialize() [4/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		int16_t	a
	)

inline

◆ Serialize() [5/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		uint16_t	a
	)

inline

◆ Serialize() [6/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		int32_t	a
	)

inline

◆ Serialize() [7/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		uint32_t	a
	)

inline

◆ Serialize() [8/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		int64_t	a
	)

inline

◆ Serialize() [9/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		uint64_t	a
	)

inline

◆ Serialize() [10/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		float	a
	)

inline

◆ Serialize() [11/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		double	a
	)

inline

◆ Serialize() [12/25]

template<typename Stream , int N>

void Serialize	(	Stream &	s,
		const char(&)	a[N]
	)

inline

◆ Serialize() [13/25]

template<typename Stream , int N>

void Serialize	(	Stream &	s,
		const unsigned char(&)	a[N]
	)

inline

◆ Serialize() [14/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		const Span< const unsigned char > &	span
	)

inline

◆ Serialize() [15/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		const Span< unsigned char > &	span
	)

inline

◆ Serialize() [16/25]

template<typename Stream >

void Serialize	(	Stream &	s,
		bool	a
	)

inline

◆ Serialize() [17/25]

template<typename Stream , typename C >

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

Forward declarationsstring

string

◆ Serialize() [18/25]

template<typename Stream , unsigned int N, typename T >

void Serialize	(	Stream &	os,
		const prevector< N, T > &	v
	)

inline

◆ Serialize() [19/25]

template<typename Stream , typename T , typename A >

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

inline

◆ Serialize() [20/25]

template<typename Stream , typename K , typename T >

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

pair

◆ Serialize() [21/25]

template<typename Stream , typename K , typename T , typename Pred , typename A >

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

map

◆ Serialize() [22/25]

template<typename Stream , typename K , typename Pred , typename A >

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

set

◆ Serialize() [23/25]

template<typename Stream , typename T >

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

shared_ptr

◆ Serialize() [24/25]

template<typename Stream , typename T >

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

unique_ptr

◆ Serialize() [25/25]

template<typename Stream , typename T >

void Serialize	(	Stream &	os,
		const T &	a
	)

inline

If none of the specialized versions above matched, default to calling member function.

◆ Serialize_impl() [1/4]

template<typename Stream , unsigned int N, typename T >

void Serialize_impl	(	Stream &	os,
		const prevector< N, T > &	v,
		const unsigned char &
	)

prevector prevectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.

prevector

◆ Serialize_impl() [2/4]

template<typename Stream , unsigned int N, typename T , typename V >

void Serialize_impl	(	Stream &	os,
		const prevector< N, T > &	v,
		const V &
	)

◆ Serialize_impl() [3/4]

template<typename Stream , typename T , typename A >

void Serialize_impl	(	Stream &	os,
		const std::vector< T, A > &	v,
		const unsigned char &
	)

vector vectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.

vector

◆ Serialize_impl() [4/4]

template<typename Stream , typename T , typename A , typename V >

void Serialize_impl	(	Stream &	os,
		const std::vector< T, A > &	v,
		const V &
	)

◆ SerializeMany() [1/2]

template<typename Stream >

void SerializeMany ( Stream & s )

◆ SerializeMany() [2/2]

template<typename Stream , typename Arg , typename... Args>

void SerializeMany	(	Stream &	s,
		const Arg &	arg,
		const Args &...	args
	)

◆ SerReadWriteMany() [1/2]

template<typename Stream , typename... Args>

void SerReadWriteMany	(	Stream &	s,
		CSerActionSerialize	ser_action,
		const Args &...	args
	)

inline

◆ SerReadWriteMany() [2/2]

template<typename Stream , typename... Args>

void SerReadWriteMany	(	Stream &	s,
		CSerActionUnserialize	ser_action,
		Args &&...	args
	)

inline

◆ Unserialize() [1/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		char &	a
	)

inline

◆ Unserialize() [2/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		int8_t &	a
	)

inline

◆ Unserialize() [3/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		uint8_t &	a
	)

inline

◆ Unserialize() [4/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		int16_t &	a
	)

inline

◆ Unserialize() [5/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		uint16_t &	a
	)

inline

◆ Unserialize() [6/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		int32_t &	a
	)

inline

◆ Unserialize() [7/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		uint32_t &	a
	)

inline

◆ Unserialize() [8/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		int64_t &	a
	)

inline

◆ Unserialize() [9/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		uint64_t &	a
	)

inline

◆ Unserialize() [10/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		float &	a
	)

inline

◆ Unserialize() [11/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		double &	a
	)

inline

◆ Unserialize() [12/24]

template<typename Stream , int N>

void Unserialize	(	Stream &	s,
		char(&)	a[N]
	)

inline

◆ Unserialize() [13/24]

template<typename Stream , int N>

void Unserialize	(	Stream &	s,
		unsigned char(&)	a[N]
	)

inline

◆ Unserialize() [14/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		Span< unsigned char > &	span
	)

inline

◆ Unserialize() [15/24]

template<typename Stream >

void Unserialize	(	Stream &	s,
		bool &	a
	)

inline

◆ Unserialize() [16/24]

template<typename Stream , typename C >

void Unserialize	(	Stream &	is,
		std::basic_string< C > &	str
	)

◆ Unserialize() [17/24]

template<typename Stream , unsigned int N, typename T >

void Unserialize	(	Stream &	is,
		prevector< N, T > &	v
	)

inline

◆ Unserialize() [18/24]

template<typename Stream , typename T , typename A >

void Unserialize	(	Stream &	is,
		std::vector< T, A > &	v
	)

inline

◆ Unserialize() [19/24]

template<typename Stream , typename K , typename T >

void Unserialize	(	Stream &	is,
		std::pair< K, T > &	item
	)

◆ Unserialize() [20/24]

template<typename Stream , typename K , typename T , typename Pred , typename A >

void Unserialize	(	Stream &	is,
		std::map< K, T, Pred, A > &	m
	)

◆ Unserialize() [21/24]

template<typename Stream , typename K , typename Pred , typename A >

void Unserialize	(	Stream &	is,
		std::set< K, Pred, A > &	m
	)

◆ Unserialize() [22/24]

template<typename Stream , typename T >

void Unserialize	(	Stream &	os,
		std::shared_ptr< const T > &	p
	)

◆ Unserialize() [23/24]

template<typename Stream , typename T >

void Unserialize	(	Stream &	os,
		std::unique_ptr< const T > &	p
	)

◆ Unserialize() [24/24]

template<typename Stream , typename T >

void Unserialize	(	Stream &	is,
		T &&	a
	)

inline

◆ Unserialize_impl() [1/4]

template<typename Stream , unsigned int N, typename T >

void Unserialize_impl	(	Stream &	is,
		prevector< N, T > &	v,
		const unsigned char &
	)

◆ Unserialize_impl() [2/4]

template<typename Stream , unsigned int N, typename T , typename V >

void Unserialize_impl	(	Stream &	is,
		prevector< N, T > &	v,
		const V &
	)

◆ Unserialize_impl() [3/4]

template<typename Stream , typename T , typename A >

void Unserialize_impl	(	Stream &	is,
		std::vector< T, A > &	v,
		const unsigned char &
	)

◆ Unserialize_impl() [4/4]

template<typename Stream , typename T , typename A , typename V >

void Unserialize_impl	(	Stream &	is,
		std::vector< T, A > &	v,
		const V &
	)

◆ UnserializeMany() [1/2]

template<typename Stream >

void UnserializeMany ( Stream & s )

inline

◆ UnserializeMany() [2/2]

template<typename Stream , typename Arg , typename... Args>

void UnserializeMany	(	Stream &	s,
		Arg &&	arg,
		Args &&...	args
	)

inline

◆ WrapBigEndian()

template<typename I >

BigEndian<I> WrapBigEndian ( I & n )

◆ WrapVarInt()

template<VarIntMode Mode = VarIntMode::DEFAULT, typename I >

CVarInt<Mode, I> WrapVarInt ( I & n )

◆ WriteCompactSize() [1/2]

void WriteCompactSize	(	CSizeComputer &	os,
		uint64_t	nSize
	)

inline

◆ WriteCompactSize() [2/2]

template<typename Stream >

void WriteCompactSize	(	Stream &	os,
		uint64_t	nSize
	)

◆ WriteVarInt() [1/2]

template<typename I >

void WriteVarInt	(	CSizeComputer &	os,
		I	n
	)

inline

◆ WriteVarInt() [2/2]

template<typename Stream , VarIntMode Mode, typename I >

void WriteVarInt	(	Stream &	os,
		I	n
	)

Variable Documentation

◆ deserialize

constexpr deserialize_type deserialize {}

◆ MAX_SIZE

const unsigned int MAX_SIZE = 0x02000000

static

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ADD_SERIALIZE_METHODS

◆ COMPACTSIZE

◆ LIMITED_STRING

◆ READWRITE

◆ READWRITEAS

◆ VARINT

Enumeration Type Documentation

◆ anonymous enum

◆ VarIntMode

Function Documentation

◆ CharCast() [1/4]

◆ CharCast() [2/4]

◆ CharCast() [3/4]

◆ CharCast() [4/4]

◆ GetSerializeSize()

◆ GetSerializeSizeMany()

◆ GetSizeOfCompactSize()

◆ GetSizeOfVarInt()

◆ NCONST_PTR()

◆ ReadCompactSize()

◆ ReadVarInt()

◆ ReadWriteAsHelper() [1/2]

◆ ReadWriteAsHelper() [2/2]

◆ REF()

◆ ser_double_to_uint64()

◆ ser_float_to_uint32()

◆ ser_readdata16()

◆ ser_readdata16be()

◆ ser_readdata32()

◆ ser_readdata32be()

◆ ser_readdata64()

◆ ser_readdata8()

◆ ser_uint32_to_float()

◆ ser_uint64_to_double()

◆ ser_writedata16()

◆ ser_writedata16be()

◆ ser_writedata32()

◆ ser_writedata32be()

◆ ser_writedata64()

◆ ser_writedata8()

◆ Serialize() [1/25]

◆ Serialize() [2/25]

◆ Serialize() [3/25]

◆ Serialize() [4/25]

◆ Serialize() [5/25]

◆ Serialize() [6/25]

◆ Serialize() [7/25]

◆ Serialize() [8/25]

◆ Serialize() [9/25]

◆ Serialize() [10/25]

◆ Serialize() [11/25]

◆ Serialize() [12/25]

◆ Serialize() [13/25]

◆ Serialize() [14/25]

◆ Serialize() [15/25]

◆ Serialize() [16/25]

◆ Serialize() [17/25]

◆ Serialize() [18/25]

◆ Serialize() [19/25]

◆ Serialize() [20/25]

◆ Serialize() [21/25]

◆ Serialize() [22/25]

◆ Serialize() [23/25]

◆ Serialize() [24/25]

◆ Serialize() [25/25]

◆ Serialize_impl() [1/4]

◆ Serialize_impl() [2/4]

◆ Serialize_impl() [3/4]

◆ Serialize_impl() [4/4]

◆ SerializeMany() [1/2]

◆ SerializeMany() [2/2]

◆ SerReadWriteMany() [1/2]

◆ SerReadWriteMany() [2/2]

◆ Unserialize() [1/24]