struct_pack

高性能，head-only，直接解析C++结构体的二进制序列化库。 更多...

类
struct	expected
	deserialize函数的返回值类型 更多...
struct	struct_pack::trivial_view< T >
	trivial_view<T> 是一个平凡结构体的视图，在类型系统上等价于T。 更多...
struct	struct_pack::compatible< T, version >
	兼容字段类型 更多...
struct	struct_pack::string_literal< CharType, Size >
	编译期字符串类型 更多...
struct	struct_pack::err_code
	struct_pack的错误码，存储了一个枚举值struct_pack::errc，可用于判断序列化是否成功。 更多...

枚举
enum class	struct_pack::errc {   ok = 0 , no_buffer_space , invalid_buffer , hash_conflict ,   invalid_width_of_container_length }
	struct_pack的错误值枚举 更多...
enum	struct_pack::sp_config : uint64_t {   DEFAULT = 0 , DISABLE_TYPE_INFO = 0b1 , ENABLE_TYPE_INFO = 0b10 , DISABLE_ALL_META_INFO = 0b11 ,   ENCODING_WITH_VARINT = 0b100 , USE_FAST_VARINT = 0b1000 }
	struct_pack的配置 更多...

函数
std::error_code	struct_pack::make_error_code (struct_pack::errc err)
	构造std::error_code
std::string	struct_pack::error_message (struct_pack::errc err)
	获取错误消息
template<typename... Args>
constexpr std::uint32_t	struct_pack::get_type_code ()
	获取类型校验码
template<typename... Args>
constexpr decltype(auto)	struct_pack::get_type_literal ()
template<typename... Args>
constexpr struct_pack::serialize_buffer_size	struct_pack::get_needed_size (const Args &...args)
	获取序列化长度
template<uint64_t conf = sp_config::DEFAULT, typename Writer , typename... Args>
void	struct_pack::serialize_to (Writer &writer, const Args &...args)
	将对象序列化并写入到给定的流/缓冲区。
template<uint64_t conf = sp_config::DEFAULT, typename... Args>
void	struct_pack::serialize_to (char *buffer, serialize_buffer_size len, const Args &...args)
	将对象序列化到给定的内存地址
template<uint64_t conf = sp_config::DEFAULT, detail::struct_pack_buffer Buffer, typename... Args>
void	struct_pack::serialize_to_with_offset (Buffer &buffer, std::size_t offset, const Args &...args)
	将序列化结果保存到给定缓冲区尾部，并在序列化结果的头部预留一段字节。
template<detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>
Buffer	struct_pack::serialize (const Args &...args)
	序列化对象并返回结果
template<detail::struct_pack_buffer Buffer = std::vector<char> typename... Args>
Buffer	struct_pack::serialize_with_offset (std::size_t offset, const Args &...args)
	将序列化结果保存到容器并返回，同时在序列化结果的头部预留一段字节。
template<uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>
Buffer	struct_pack::serialize (const Args &...args)
	按给定配置序列化对象并返回结果
template<uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>
Buffer	struct_pack::serialize_with_offset (std::size_t offset, const Args &...args)
	按给定配置将序列化结果保存到容器并返回，同时在序列化结果的头部预留一段字节。
template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::detail::deserialize_view View>
struct_pack::err_code	struct_pack::deserialize_to (T &t, const View &v, Args &...args)
	从视图中反序列化目的对象
template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args>
struct_pack::err_code	struct_pack::deserialize_to (T &t, const char *data, size_t size, Args &...args)
	将内存中的数据反序列化到目的对象
template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::reader_t Reader>
struct_pack::err_code	struct_pack::deserialize_to (T &t, Reader &reader, Args &...args)
	将输入流中的数据反序列化到目的对象
template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::detail::deserialize_view View>
struct_pack::err_code	struct_pack::deserialize_to_with_offset (T &t, const View &v, size_t &offset, Args &...args)
	从视图中反序列化目的对象，反序列化时跳过开头的若干字节
template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args>
struct_pack::err_code	struct_pack::deserialize_to_with_offset (T &t, const char *data, size_t size, size_t &offset, Args &...args)
	将内存中的数据反序列化到目的对象，反序列化时跳过开头的若干字节
template<typename... Args, struct_pack::detail::deserialize_view View>
auto	struct_pack::deserialize (const View &v)
	反序列化视图中的数据，并按值返回
template<typename... Args>
auto	struct_pack::deserialize (const char *data, size_t size)
	反序列化内存中的数据，并按值返回
template<typename... Args, struct_pack::reader_t Reader>
auto	struct_pack::deserialize (Reader &v)
	反序列化输入流中的数据，并按值返回
template<typename... Args, struct_pack::detail::deserialize_view View>
auto	struct_pack::deserialize (const View &v, size_t &consume_len)
	反序列化视图中的数据，并按值返回，并在参数中返回消耗的数据长度。
template<typename... Args>
auto	struct_pack::deserialize (const char *data, size_t size, size_t &consume_len)
	反序列化内存中的数据，并按值返回，并在参数中返回消耗的数据长度。
template<uint64_t conf, typename... Args, struct_pack::detail::deserialize_view View>
auto	struct_pack::deserialize (const View &v)
	按给定配置反序列化视图中的数据，并按值返回
template<uint64_t conf, typename... Args>
auto	struct_pack::deserialize (const char *data, size_t size)
	按给定配置反序列化内存中的数据，并按值返回
template<uint64_t conf, typename... Args, struct_pack::reader_t Reader>
auto	struct_pack::deserialize (Reader &v)
	按给定配置反序列化输入流中的数据，并按值返回
template<uint64_t conf, typename... Args, struct_pack::detail::deserialize_view View>
auto	struct_pack::deserialize (const View &v, size_t &consume_len)
	按给定配置反序列化视图中的数据，并按值返回，并在参数中返回消耗的数据长度。
template<uint64_t conf, typename... Args>
auto	struct_pack::deserialize (const char *data, size_t size, size_t &consume_len)
	按给定配置反序列化内存中的数据，并按值返回，并在参数中返回消耗的数据长度。
template<typename... Args, struct_pack::detail::deserialize_view View>
auto	struct_pack::deserialize_with_offset (const View &v, size_t &offset)
	从视图中反序列化目的对象并保存到返回值，反序列化时跳过开头的若干字节
template<typename... Args>
auto	struct_pack::deserialize_with_offset (const char *data, size_t size, size_t &offset)
	从内存中反序列化目的对象并保存到返回值，反序列化时跳过开头的若干字节
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field , struct_pack::detail::deserialize_view View>
struct_pack::err_code	struct_pack::get_field_to (Field &dst, const View &v)
	从视图中反序列化一个字段并保存到目的对象
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field >
struct_pack::err_code	struct_pack::get_field_to (Field &dst, const char *data, size_t size)
	从内存中反序列化一个字段并保存到目的对象
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field , struct_pack::reader_t Reader>
struct_pack::err_code	struct_pack::get_field_to (Field &dst, Reader &reader)
	从输入流中反序列化一个字段并保存到目的对象
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, struct_pack::detail::deserialize_view View>
auto	struct_pack::get_field (const View &v)
	从视图中反序列化一个字段并返回
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT>
auto	struct_pack::get_field (const char *data, size_t size)
	从内存中反序列化一个字段并返回
template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, struct_pack::reader_t Reader>
auto	struct_pack::get_field (Reader &reader)
	从输入流中反序列化一个字段并返回
template<typename BaseClass , typename... DerivedClasses, struct_pack::detail::deserialize_view View>
struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code >	struct_pack::deserialize_derived_class (const View &v)
	从视图中反序列化派生类到基类的指针
template<typename BaseClass , typename... DerivedClasses>
struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code >	struct_pack::deserialize_derived_class (const char *data, size_t size)
	从内存中反序列化派生类到基类的指针
template<typename BaseClass , typename... DerivedClasses, struct_pack::reader_t Reader>
struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code >	struct_pack::deserialize_derived_class (Reader &reader)
	从输入流中反序列化派生类到基类的指针

变量
template<typename T >
constexpr std::size_t	struct_pack::members_count
	手动标注结构体成员个数

详细描述

高性能，head-only，直接解析C++结构体的二进制序列化库。

枚举类型说明

errc

enum class struct_pack::errc

strong

struct_pack的错误值枚举

struct_pack的错误值枚举，各枚举值解释如下：

1. ok，代表无错误。
2. no_buffer_space，缓冲区耗尽，未能完成所有字段的反序列化。
3. invalid_buffer，读取到非法数据，无法将数据反序列化到指定类型。
4. hash_conflict, 侦测到哈希冲突，该错误仅在序列化数据中存在完整类型信息时才可能出现。代表尽管类型校验哈希码相同，但反序列化的目的类型和数据的实际类型依然不同，两类型的校验值之间发生了哈希冲突。 5. invalid_width_of_container_length，容器长度的位数不合法，例如，当字符串/容器长度大于2的32次方时，序列化数据的二进制格式使用64位的容器长度来存储数据，将该数据保存到文件中，并在32位系统上反序列化，即会返回该错误，因为32位系统不支持如此之大的数据。

sp_config

enum struct_pack::sp_config : uint64_t

struct_pack的配置

struct_pack的编译期配置，用户可通过或运算组合各枚举值，以决定struct_pack的序列化行为。

具体说明详见：序列化设置

函数说明

deserialize() [1/10]

template<typename... Args>

auto struct_pack::deserialize	(	const char *	data,
		size_t	size
	)

反序列化内存中的数据，并按值返回

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化

参数

data	起始地址
size	数据长度

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
auto p2 = struct_pack::deserialize<person>(buffer.data(), buffer.size());
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize() [2/10]

template<uint64_t conf, typename... Args>

auto struct_pack::deserialize	(	const char *	data,
		size_t	size
	)

按给定配置反序列化内存中的数据，并按值返回

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化

参数

data	起始地址
size	数据长度

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
auto p2 = struct_pack::deserialize<person>(buffer.data(), buffer.size());
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize() [3/10]

template<typename... Args>

auto struct_pack::deserialize	(	const char *	data,
		size_t	size,
		size_t &	consume_len
	)

反序列化内存中的数据，并按值返回，并在参数中返回消耗的数据长度。

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化

参数

data	起始地址
size	数据长度
consume_len	出参，保存消耗的数据长度。

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

当错误发生时，consume_len会被设为0。

deserialize() [4/10]

template<uint64_t conf, typename... Args>

auto struct_pack::deserialize	(	const char *	data,
		size_t	size,
		size_t &	consume_len
	)

按给定配置反序列化内存中的数据，并按值返回，并在参数中返回消耗的数据长度。

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化

参数

data	起始地址
size	数据长度
consume_len	出参，保存消耗的数据长度。

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

当错误发生时，consume_len会被设为0。

deserialize() [5/10]

template<typename... Args, struct_pack::detail::deserialize_view View>

auto struct_pack::deserialize

(

const View &

v

)

反序列化视图中的数据，并按值返回

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v	存有struct_pack序列化数据的视图

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
auto p2 = struct_pack::deserialize<person>(buffer);
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize() [6/10]

template<uint64_t conf, typename... Args, struct_pack::detail::deserialize_view View>

auto struct_pack::deserialize

(

const View &

v

)

按给定配置反序列化视图中的数据，并按值返回

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v	存有struct_pack序列化数据的视图

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
auto p2 = struct_pack::deserialize<person>(buffer);
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize() [7/10]

template<typename... Args, struct_pack::detail::deserialize_view View>

auto struct_pack::deserialize	(	const View &	v,
		size_t &	consume_len
	)

反序列化视图中的数据，并按值返回，并在参数中返回消耗的数据长度。

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v	存有struct_pack序列化数据的视图
consume_len	出参，保存消耗的数据长度。

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

当错误发生时，consume_len会被设为0。

deserialize() [8/10]

template<uint64_t conf, typename... Args, struct_pack::detail::deserialize_view View>

auto struct_pack::deserialize	(	const View &	v,
		size_t &	consume_len
	)

按给定配置反序列化视图中的数据，并按值返回，并在参数中返回消耗的数据长度。

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v	存有struct_pack序列化数据的视图
consume_len	出参，保存消耗的数据长度。

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

当错误发生时，consume_len会被设为0。

deserialize() [9/10]

template<typename... Args, struct_pack::reader_t Reader>

auto struct_pack::deserialize

(

Reader &

v

)

反序列化输入流中的数据，并按值返回

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
Reader	输入流类型Reader，该类型需要满足约束struct_pack::reader_t

参数

v

输入流

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
std::ifstream ifs("struct_pack_demo.data",
                   std::ofstream::in | std::ofstream::binary);
auto p2 = struct_pack::deserialize<person>(ifs);
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize() [10/10]

template<uint64_t conf, typename... Args, struct_pack::reader_t Reader>

auto struct_pack::deserialize

(

Reader &

v

)

按给定配置反序列化输入流中的数据，并按值返回

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
Reader	输入流类型Reader，该类型需要满足约束struct_pack::reader_t

参数

v

输入流

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

person p;
std::ifstream ifs("struct_pack_demo.data",
                   std::ofstream::in | std::ofstream::binary);
auto p2 = struct_pack::deserialize<person>(ifs);
assert(p2);  // check if no error
assert(p2.value() == p2); // check if value equal.

deserialize_derived_class() [1/3]

template<typename BaseClass , typename... DerivedClasses>

struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code > struct_pack::deserialize_derived_class	(	const char *	data,
		size_t	size
	)

从内存中反序列化派生类到基类的指针

模板参数

BaseClass	基类类型
DerivedClasses	所有可能的派生类类型

参数

data	起始地址
size	数据长度

返回

struct_pack::expected<std::unique_ptr<BaseClass>, struct_pack::err_code> 类型，该类型存储了反序列化结果（std::unique_ptr<BaseClass>）或struct_pack::err_code类型的错误码。详见struct_pack::expected

本函数用于在不知道派生类具体类型的情况下，将其反序列化到基类的指针。

样例代码

 //    base
 //   /   |
 //  obj1 obj2
 //  |
 //  obj3
 auto ret = struct_pack::serialize(obj3{});
 auto result =
     struct_pack::deserialize_derived_class<base, obj1, obj2, obj3>(ret.data(),
ret.size());
 assert(result.has_value());   // check deserialize ok
 std::unique_ptr<base> ptr = std::move(result.value());
 assert(ptr != nullptr);

deserialize_derived_class() [2/3]

template<typename BaseClass , typename... DerivedClasses, struct_pack::detail::deserialize_view View>

struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code > struct_pack::deserialize_derived_class

(

const View &

v

)

从视图中反序列化派生类到基类的指针

模板参数

BaseClass	基类类型
DerivedClasses	所有可能的派生类类型
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v

视图

返回

struct_pack::expected<std::unique_ptr<BaseClass>, struct_pack::err_code> 类型，该类型存储了反序列化结果（std::unique_ptr<BaseClass>）或struct_pack::err_code类型的错误码。详见struct_pack::expected

本函数用于在不知道派生类具体类型的情况下，将其反序列化到基类的指针。

样例代码

//    base
//   /   |
//  obj1 obj2
//  |
//  obj3
auto ret = struct_pack::serialize(obj3{});
auto result =
    struct_pack::deserialize_derived_class<base, obj1, obj2, obj3>(ret);
assert(result.has_value());   // check deserialize ok
std::unique_ptr<base> ptr = std::move(result.value());
assert(ptr != nullptr);

deserialize_derived_class() [3/3]

template<typename BaseClass , typename... DerivedClasses, struct_pack::reader_t Reader>

struct_pack::expected< std::unique_ptr< BaseClass >, struct_pack::err_code > struct_pack::deserialize_derived_class

(

Reader &

reader

)

从输入流中反序列化派生类到基类的指针

模板参数

BaseClass	基类类型
DerivedClasses	所有可能的派生类类型
Reader	输入流类型，需要满足struct_pack::reader_t约束

参数

reader

返回

struct_pack::expected<std::unique_ptr<BaseClass>, struct_pack::err_code> 类型，该类型存储了反序列化结果（std::unique_ptr<BaseClass>）或struct_pack::err_code类型的错误码。详见struct_pack::expected

deserialize_to() [1/3]

template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args>

struct_pack::err_code struct_pack::deserialize_to	(	T &	t,
		const char *	data,
		size_t	size,
		Args &...	args
	)

将内存中的数据反序列化到目的对象

模板参数

conf	序列化配置，详见struct_pack::sp_config
T	对象的类型T
Args	对象的类型Args,当Args不为空时，会将数据按std::tuple<T,Args...>格式将数据反序列化保存到参数中。

参数

t	待反序列化的对象t
data	起始地址
size	数据的长度
args	待反序列化的对象args

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。 样例代码：

person p{20, "tom"};
auto buffer = struct_pack::serialize(p);
person p2;
auto ec = struct_pack::deserialize_to(p2, buffer.data(), buffer.size());
assert(!ec);
assert(p == p2);

deserialize_to() [2/3]

template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::detail::deserialize_view View>

struct_pack::err_code struct_pack::deserialize_to	(	T &	t,
		const View &	v,
		Args &...	args
	)

从视图中反序列化目的对象

模板参数

conf	序列化配置，详见struct_pack::sp_config
T	对象的类型T
Args	对象的类型Args,当Args不为空时，会将数据按std::tuple<T,Args...>格式将数据反序列化保存到参数中。
View	视图类型，需满足struct_pack::detail::deserialize_view约束 约束，如std::string_view

参数

t	待反序列化的对象t
v	存有struct_pack序列化数据的视图
args	待反序列化的对象args

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。 样例代码：

person p{20, "tom"};
auto buffer = struct_pack::serialize(p);
person p2;
auto ec = struct_pack::deserialize_to(p2, buffer);
assert(!ec);
assert(p == p2);

deserialize_to() [3/3]

template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::reader_t Reader>

struct_pack::err_code struct_pack::deserialize_to	(	T &	t,
		Reader &	reader,
		Args &...	args
	)

将输入流中的数据反序列化到目的对象

模板参数

conf	序列化配置，详见struct_pack::sp_config
T	对象的类型T
Args	对象的类型Args,当Args不为空时，会将数据按std::tuple<T,Args...>格式将数据反序列化保存到参数中。
Reader	输入流类型Reader，该类型需要满足约束struct_pack::reader_t

参数

t	待反序列化的对象t
reader	输入流
args

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败。

当反序列化失败时，t的值可能被部分修改。

deserialize_to_with_offset() [1/2]

template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args>

struct_pack::err_code struct_pack::deserialize_to_with_offset	(	T &	t,
		const char *	data,
		size_t	size,
		size_t &	offset,
		Args &...	args
	)

将内存中的数据反序列化到目的对象，反序列化时跳过开头的若干字节

模板参数

conf	序列化配置，详见struct_pack::sp_config
T	对象的类型T
Args	对象的类型Args,当Args不为空时，会将数据按std::tuple<T,Args...>格式将数据反序列化保存到参数中。

参数

t	待反序列化的对象t
data	起始地址
size	数据长度
offset	跳过开头字节的长度
args	待反序列化的对象args

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。

deserialize_to_with_offset() [2/2]

template<uint64_t conf = sp_config::DEFAULT, typename T , typename... Args, struct_pack::detail::deserialize_view View>

struct_pack::err_code struct_pack::deserialize_to_with_offset	(	T &	t,
		const View &	v,
		size_t &	offset,
		Args &...	args
	)

从视图中反序列化目的对象，反序列化时跳过开头的若干字节

模板参数

conf	序列化配置，详见struct_pack::sp_config
T	对象的类型T
Args	对象的类型Args,当Args不为空时，会将数据按std::tuple<T,Args...>格式将数据反序列化保存到参数中。
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

t	待反序列化的对象t
v	存有struct_pack序列化数据的视图
offset	跳过开头字节的长度
args	待反序列化的对象args

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。

deserialize_with_offset() [1/2]

template<typename... Args>

auto struct_pack::deserialize_with_offset	(	const char *	data,
		size_t	size,
		size_t &	offset
	)

从内存中反序列化目的对象并保存到返回值，反序列化时跳过开头的若干字节

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化

参数

data	起始地址
size	数据长度
offset	反序列化起始位置的偏移量

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码：

std::string hi = "Hello struct_pack";
std::vector<char> ho;
for (int i = 0; i < 100; ++i) {
  struct_pack::serialize_to(ho, hi + std::to_string(i));
}
for (size_t i = 0, offset = 0; i < 100; ++i) {
  auto ret = struct_pack::deserialize_with_offset<std::string>(ho, offset);
  CHECK(ret.has_value());
  CHECK(ret.value == hi + std::to_string(i));
}

deserialize_with_offset() [2/2]

template<typename... Args, struct_pack::detail::deserialize_view View>

auto struct_pack::deserialize_with_offset	(	const View &	v,
		size_t &	offset
	)

从视图中反序列化目的对象并保存到返回值，反序列化时跳过开头的若干字节

模板参数

Args	反序列化对象的类型，至少应填写一个，当填写多个时，按std::tuple<Args...>类型反序列化
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v	存有struct_pack序列化数据的视图
offset	反序列化起始位置的偏移量

返回

struct_pack::expected<Args, struct_pack::err_code> 类型，当Args有多个参数时，返回值类型为struct_pack::expected<std::tuple<Args...>, struct_pack::err_code>。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

error_message()

std::string struct_pack::error_message ( struct_pack::errc  err )

inline

获取错误消息

参数

err

返回

std::string 错误消息

本函数获取struct_pack::errc对应的错误消息。

get_field() [1/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT>

auto struct_pack::get_field	(	const char *	data,
		size_t	size
	)

从内存中反序列化一个字段并返回

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config

参数

data	起始地址
size	数据长度

返回

struct_pack::expected<TI, struct_pack::err_code> 类型，其中TI代表T的第I个字段。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码

person p{20, "tom"};
auto buffer = serialize(p);
std::string name;
auto result = get_field_to<person, 1>(name, buffer.data(), buffer.size());
CHECK(result);
CHECK(result.value() == "tom");

get_field() [2/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, struct_pack::detail::deserialize_view View>

auto struct_pack::get_field

(

const View &

v

)

从视图中反序列化一个字段并返回

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

v

视图

返回

struct_pack::expected<TI, struct_pack::err_code> 类型，其中TI代表T的第I个字段。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

样例代码

person p{20, "tom"};
auto buffer = serialize(p);
std::string name;
auto result = get_field_to<person, 1>(name, buffer);
CHECK(result);
CHECK(result.value() == "tom");

get_field() [3/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, struct_pack::reader_t Reader>

auto struct_pack::get_field

(

Reader &

reader

)

从输入流中反序列化一个字段并返回

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config
Reader	输入流类型，需要满足struct_pack::reader_t约束

参数

reader

输入流

返回

struct_pack::expected<TI, struct_pack::err_code> 类型，其中TI代表T的第I个字段。该类型存储了反序列化结果或struct_pack::err_code类型的错误码。详见struct_pack::expected

get_field_to() [1/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field >

struct_pack::err_code struct_pack::get_field_to	(	Field &	dst,
		const char *	data,
		size_t	size
	)

从内存中反序列化一个字段并保存到目的对象

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config
Field	字段类型

参数

dst	目的对象
v	数据视图
data	起始地址
size	数据长度

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。 样例代码

person p{20, "tom"};
auto buffer = serialize(p);
std::string name;
auto ec = get_field_to<person, 1>(name, buffer.data(), buffer.size());
CHECK(!ec);
CHECK(name == "tom");

get_field_to() [2/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field , struct_pack::detail::deserialize_view View>

struct_pack::err_code struct_pack::get_field_to	(	Field &	dst,
		const View &	v
	)

从视图中反序列化一个字段并保存到目的对象

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config
Field	字段类型
View	视图类型，需满足struct_pack::detail::deserialize_view约束

参数

dst	目的对象
v	数据视图

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。

样例代码

person p{20, "tom"};
auto buffer = serialize(p);
int age;
auto ec = get_field_to<person, 0>(age, buffer);
CHECK(!ec);
CHECK(age == 20);

get_field_to() [3/3]

template<typename T , size_t I, uint64_t conf = sp_config::DEFAULT, typename Field , struct_pack::reader_t Reader>

struct_pack::err_code struct_pack::get_field_to	(	Field &	dst,
		Reader &	reader
	)

从输入流中反序列化一个字段并保存到目的对象

模板参数

T	反序列化对象的类型
I	反序列化对象的第I个字段（从0开始计数）
conf	序列化配置，详见struct_pack::sp_config
Field	字段类型
Reader	输入流类型，需要满足struct_pack::reader_t约束

参数

dst	目的对象
reader	输入流

返回

struct_pack::err_code 返回错误码，如果返回值不等于struct_pack::errc::ok，说明反序列化失败

当反序列化失败时，t的值可能被部分修改。

get_needed_size()

template<typename... Args>

constexpr struct_pack::serialize_buffer_size struct_pack::get_needed_size ( const Args &...  args )

constexpr

获取序列化长度

模板参数

Args

参数

args

返回

serialize_buffer_size 序列化所需的buffer的长度。

用于预先分配好合适长度的内存，通常配合struct_pack::serialize_to函数使用。 如果类型允许，该计算可能在编译期完成。

样例代码：

std::map<std::string, std::string> obj{{"hello", "struct pack"}};
auto size=struct_pack::get_needed_size(obj);
auto array=std::make_unique<char[]>(size);
struct_pack::serialize_to(array.get(),size);

get_type_code()

template<typename... Args>

constexpr std::uint32_t struct_pack::get_type_code ( )

constexpr

获取类型校验码

模板参数

Args

返回

编译期计算出的类型名

返回Args的31位类型校验码。当传入的参数多于一个时，返回类型std::tuple<Args...>的校验码

样例代码：

static_assert(
    get_type_code<std::deque<int>>() == get_type_code<std::vector<int>>(),
    "different class accord with container concept should get same MD5");
static_assert(
    get_type_code<std::map<int,int>>() != get_type_code<std::vector<int>>(),
    "different class accord with different concept should get different MD5");

模板参数

Args

返回

编译期计算出的类型哈希校验码。

get_type_literal()

template<typename... Args>

constexpr decltype(auto) struct_pack::get_type_literal ( )

constexpr

本函数返回编译期计算出的类型名，并按struct_pack::string_literal<char,N>类型返回。 当传入的参数多于一个时，返回类型std::tuple<T...>的类型名。

样例代码：

auto str = get_type_literal<tuple<int, int, short>>();
CHECK(str.size() == 5);
string_literal<char, 5> val{{(char)-2, 1, 1, 7, (char)-1}};
//{struct_begin,int32_t,int32_t,int16_t,struct_end};
CHECK(str == val);

make_error_code()

std::error_code struct_pack::make_error_code ( struct_pack::errc  err )

inline

构造std::error_code

参数

err	error code.

返回

std::error_code

通过struct_pack::errc构造std::error_code

serialize() [1/2]

template<detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>

Buffer struct_pack::serialize

(

const Args &...

args

)

序列化对象并返回结果

模板参数

Buffer	需要序列化的对象类型，默认为std::vector<char>，需要满足detail::struct_pack_buffer约束，可以为内存连续的字节容器(如std::vector,std::string)。
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

args

待序列化的对象

返回

Buffer 返回序列化的结果

序列化对象并返回结果

person p{20, "tom"};
auto buffer = struct_pack::serialize(p);

serialize() [2/2]

template<uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>

Buffer struct_pack::serialize

(

const Args &...

args

)

按给定配置序列化对象并返回结果

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Buffer	需要序列化的对象类型，默认为std::vector<char>，需要满足detail::struct_pack_buffer约束，可以为内存连续的字节容器(如std::vector,std::string)。
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

args

待序列化的对象

返回

Buffer 返回序列化的结果

serialize_to() [1/2]

template<uint64_t conf = sp_config::DEFAULT, typename... Args>

void struct_pack::serialize_to	(	char *	buffer,
		serialize_buffer_size	len,
		const Args &...	args
	)

将对象序列化到给定的内存地址

模板参数

conf	序列化配置，详见struct_pack::sp_config
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

buffer	内存首地址
len	序列化所需长度，该长度可通过struct_pack::get_needed_size计算得到
args	待序列化的对象

样例代码：

auto size = struct_pack::get_needed_size(p);
auto array = std::make_unique<char[]>(size);
struct_pack::serialize_to(array.get(), size, p);

serialize_to() [2/2]

template<uint64_t conf = sp_config::DEFAULT, typename Writer , typename... Args>

void struct_pack::serialize_to	(	Writer &	writer,
		const Args &...	args
	)

将对象序列化并写入到给定的流/缓冲区。

模板参数

conf	序列化配置，详见struct_pack::sp_config
Writer	输出流/缓冲区容器类型，对于缓冲区容器需要满足detail::struct_pack_buffer约束，可以为内存连续的字节容器(如std::vector,std::string)。 ，对于流需要满足struct_pack::writer_t约束的类型(如std::ostream)
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

writer	输出缓冲区
args	待序列化的对象

需要注意的是，该函数不会清空写入的容器/流，而是会将数据附加到缓冲区尾部。

样例代码：

std::string buffer = "The next line is struct_pack data.\n";
struct_pack::serialize_to(buffer, p);

std::ofstream writer("struct_pack_demo.data",
                      std::ofstream::out | std::ofstream::binary);
struct_pack::serialize_to(writer, p);

serialize_to_with_offset()

template<uint64_t conf = sp_config::DEFAULT, detail::struct_pack_buffer Buffer, typename... Args>

void struct_pack::serialize_to_with_offset	(	Buffer &	buffer,
		std::size_t	offset,
		const Args &...	args
	)

将序列化结果保存到给定缓冲区尾部，并在序列化结果的头部预留一段字节。

模板参数

conf	序列化配置，详见struct_pack::sp_config
Buffer	序列化缓冲区类型，需要满足detail::struct_pack_buffer约束，缓冲区可以为内存连续的字节容器(如std::vector,std::string)。
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

buffer	输出缓冲区
offset	头部偏移的空闲字节长度
args	待序列化的对象

需要注意的是，出于性能优化考虑，预留的字节可能未被初始化，不应假设其被初始化为0。

serialize_with_offset() [1/2]

template<detail::struct_pack_buffer Buffer = std::vector<char> typename... Args>

Buffer struct_pack::serialize_with_offset	(	std::size_t	offset,
		const Args &...	args
	)

将序列化结果保存到容器并返回，同时在序列化结果的头部预留一段字节。

模板参数

Buffer	序列化的容器（缓冲区）类型，需要满足detail::struct_pack_buffer约束，可以为内存连续的字节容器(如std::vector,std::string)。
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

offset	头部偏移的空闲字节长度
args	待序列化的对象

返回

Buffer 将结果保存为容器类型，按值返回。

serialize_with_offset() [2/2]

template<uint64_t conf, detail::struct_pack_buffer Buffer = std::vector<char>, typename... Args>

Buffer struct_pack::serialize_with_offset	(	std::size_t	offset,
		const Args &...	args
	)

按给定配置将序列化结果保存到容器并返回，同时在序列化结果的头部预留一段字节。

模板参数

conf	显式指定的序列化配置，详见struct_pack::sp_config
Buffer	序列化的容器（缓冲区）类型，需要满足detail::struct_pack_buffer约束，可以为内存连续的字节容器(如std::vector,std::string)。
Args	需要序列化的对象类型。当传入多个序列化对象时，函数会将其打包合并，按std::tuple类型的格式序列化。

参数

offset	头部偏移的空闲字节长度
args	待序列化的对象

返回

Buffer 将结果保存为容器类型，按值返回。

变量说明

members_count

template<typename T >

constexpr std::size_t struct_pack::members_count

constexpr

手动标注结构体成员个数

模板参数

T

待纠正的结构体

某些特殊情况下，struct_pack可能无法正确计算结构体内的元素个数并导致编译期错误。 此时请特化模板struct_pack::members_count，并手动标明结构体内元素的个数。

样例代码：

struct bug_member_count_struct1 {
int i;
std::string j;
double k = 3;
};
 
struct bug_member_count_struct2 : bug_member_count_struct1 {};
 
template <>
constexpr size_t struct_pack::members_count<bug_member_count_struct2> = 3;