yas源码解析 之 yas是什么

已于 2024-08-13 23:50:52 修改
阅读量1k 收藏 25
点赞数 7
分类专栏： yas源码解析 文章标签： c++ 序列化 json
于 2024-08-13 00:21:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013001137/article/details/141144824
版权

简介

github源码地址：

GitHub - niXman/yas: Yet Another SerializationYet Another Serialization. Contribute to niXman/yas development by creating an account on GitHub.icon-default.png?t=N7T8https://github.com/niXman/yas

个人注释gitee地址：yas_comment: 对yas源码进行注释icon-default.png?t=N7T8https://gitee.com/AriesSun/yas_comment

yas是Yet Another Serialization的简称，又一个序列化的库。yas是基于C++语言开发的header only的序列化的库，支持的归档类型包括二进制、json、文本文件等。

与之类似的序列化库包括：thrift、protobuf、boost、msgpack、cereal、avro、capnproto、flatbuffers等。

特点

  1. 为替代boost.serialization而创建，因为boost.serialization的序列化速度不够快
  2. header only library
  3. does not depend on third-party libraries or boost
  4. require C++11 support，至少C++ 11

支持的编译器

  • GCC : 4.8.5, ... - 32/64 bit
  • MinGW: 4.8.5, ... - 32/64 bit
  • Clang: 3.5, ... - 32/64 bit
  • Intel: (untested)
  • MSVC : 2017(in c++14 mode), ... - 32/64 bit
  • Emscripten: 1.38 (clang version 6.0.1)

支持序列化的数据类型

基础数据类型

  • 整型：[unsigned] char、[unsigned] short、[unsigned] int、[unsigned] long、[unsigned] long long
  • 浮点型：float、double
  • 布尔型：bool

C++ STL（25种）

  • std::array
  • std::bitset
  • std::chrono::duration
  • std::chrono::time_point
  • std::complex
  • std::deque
  • std::forward_list
  • std::list
  • std::map
  • std::multimap
  • std::multiset
  • std::optional
  • std::pair
  • std::set
  • std::string
  • std::string_view
  • std::tuple
  • std::unordered_map
  • std::unordered_multimap
  • std::unordered_multiset
  • std::unordered_set
  • std::variant
  • std::vector
  • std::wstring
  • boost::array

boost（31种）

  • boost::array
  • boost::chrono::duration
  • boost::chrono::time_point
  • boost::optional
  • boost::variant
  • boost::container::deque
  • boost::container::string
  • boost::container::wstring
  • boost::container::vector
  • boost::container::static_vector
  • boost::container::stable_vector
  • boost::container::list
  • boost::container::slist
  • boost::container::map
  • boost::container::multimap
  • boost::container::set

  • boost::container::multiset
  • boost::container::flat_map
  • boost::container::flat_multimap
  • boost::container::flat_set
  • boost::container::flat_multiset
  • boost::unordered_map
  • boost::unordered_multimap
  • boost::unordered_set
  • boost::unordered_multiset
  • boost::fusion::pair
  • boost::fusion::tuple
  • boost::fusion::vector
  • boost::fusion::list
  • boost::fusion::map
  • boost::fusion::set

Qt（6种）

  • QByteArray
  • QList
  • QMap
  • QString
  • QStringList
  • QVector

yas（2种）

  • yas::intrusive_buffer
  • yas::shared_buffer

Benchmark性能统计

引用：https://github.com/thekvs/cpp-serializers?tab=readme-ov-file

以下统计结果是在运行Ubuntu 16.04的英特尔酷睿i7处理器的典型台式计算机上运行1000000次串行化-去串行化操作50次，然后对结果求平均值而获得的。

使用的库的确切版本是:

  • thrift 0.12.0
  • protobuf 3.7.0
  • boost 1.69.0
  • msgpack 3.1.1
  • cereal 1.2.2
  • avro 1.8.2
  • capnproto 0.7.0
  • flatbuffers 1.10.0
  • YAS 7.0.2

序列化后对象字节总数柱状图如下

序列化平均总时间（ms）柱状图如下

示例代码

asis

asis在这里表示序列化时，数据按照它本来的样子输入、输出，不关心是否使用了压缩。

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct type {
    type()
        :c{1}
        ,i(33)
        ,u(44)
    {}

    std::uint8_t c;
    std::uint32_t i;
    std::uint64_t u;

    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT("type", c, yas::asis(i), u);
    }
};

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.c = 0;
    t2.u = 0;

    constexpr std::size_t flags = yas::mem|yas::binary|yas::compacted;

    auto buf = yas::save<flags>(t1);

    assert(buf.size == 7+1+4+1); // 7 - YAS header, 1 - uint8, 4 - nonpacked uint32, 1 - packed uint64

    yas::load<flags>(buf, t2);

    assert(t1.c == t2.c && t1.i == t2.i);
}

/***************************************************************************/

serialize成员函数，如何序列化这个类的成员。

yas::mem：表示内存流

yas::binary：表示归档类型为二进制

yas::compacted：表示序列化时对数据进行压缩（实际yas只支持整型数据的压缩，后面在单独文章中分析yas压缩的原理）

大家肯定对YAS_OBJECT这个宏做了什么，感到特别好奇，请看下图将其展开后的内容。

make_object会生成一个object对象，make_val会生成一个value对象

在yas的底层，有针对object和value对象专门的结构体模板特化序列化结构体。

那么object和value到底是什么呢？请看下图：

之所以它们的结构体中都有key和klen，主要是在归档为json时需要。

base/derived

下面的代码主要展示存在继承关系的结构体，怎么进行实现序列化函数。

#include <yas/serialize.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct base {
    std::uint32_t x;

    base()
        :x()
    {}

    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT(nullptr /* reserved */, x);
    }
};

struct derived: base {
    std::uint32_t y;

    derived()
        :y()
    {}

    template<typename Ar>
    void serialize(Ar &ar) {
        auto &x = yas::base_object<base>(*this);
        ar & YAS_OBJECT(nullptr /* reserved */, y, x);
    }
};

/***************************************************************************/

int main() {
    derived t1, t2;
    t1.x = 33;
    t1.y = 44;

    constexpr std::size_t flags = yas::mem|yas::json;

    yas::shared_buffer buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    assert(t2.x == 33 && t2.y == 44);
}

/***************************************************************************/

这段代码的核心就是在derived的serialize的函数中加一行 auto &x = yas::base_object<base>(*this); 并将x添加到序列化列表中。

nested

下面这段代码主要针对类/结构体之间存在has-a关系时，如果进行序列化。

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct data {
    data()
        :s("33")
    {}

    std::string s;

    // one member-function for save/load
    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT("data", s);
    }
};

struct type {
    type()
        :i(33)
        ,d()
    {}

    std::uint32_t i;
    data d;

    // one member-function for save/load
    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT("type", i, d);
    }
};

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.d.s.clear();

    constexpr std::size_t flags = yas::mem|yas::json;

    auto buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    assert(t1.i == t2.i && t1.d.s == t2.d.s);
}

/***************************************************************************/

free function

free function的含义，其实是相对member function来说的，也就是serialize函数在结构体外部实现

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct type {
    type()
        :i(33)
        ,d(.34)
        ,s("35")
        ,v({36, 37, 38})
    {}

    std::uint32_t i;
    double d;
    std::string s;
    std::vector<std::uint32_t> v;
};

// one free-function serializer/deserializer
template<typename Ar>
void serialize(Ar &ar, type &t) {
    ar & YAS_OBJECT_NVP(
        "type"
        ,("i", t.i)
        ,("d", t.d)
        ,("s", t.s)
        ,("v", t.v)
    );
}

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.d = 0;
    t2.s.clear();
    t2.v.clear();

    constexpr std::size_t flags = yas::mem|yas::json;

    auto buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    // TODO: stackoverflow.com/questions/17333
    assert(t1.i == t2.i && t1.d == t2.d && t1.s == t2.s && t1.v == t2.v);
}

/***************************************************************************/

one free-function serializer/deserializer

下面的代码主要描述在一个free function中如何分别实现序列化和反序列化

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct type {
    type()
        :i(33)
        ,d(.34)
        ,s("35")
        ,v({36, 37, 38})
    {}

    std::uint32_t i;
    double d;
    std::string s;
    std::vector<int> v;
};

// one free-function serializer/deserializer
template<typename Ar>
void serialize(Ar &ar, type &t) {
    if ( Ar::is_writable() ) { // constexpr
        ar & YAS_OBJECT_NVP(
            "type"
            ,("i", t.i)
            ,("d", t.d)
            ,("s", t.s)
            ,("v", t.v)
        );
    } else {
        ar & YAS_OBJECT_NVP(
            "type"
            ,("i", t.i)
            ,("d", t.d)
            ,("s", t.s)
            ,("v", t.v)
        );
    }
}

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.d = 0;
    t2.s.clear();
    t2.v.clear();

    constexpr std::size_t flags = yas::mem|yas::json;

    auto buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    // TODO: stackoverflow.com/questions/17333
    assert(t1.i == t2.i && t1.d == t2.d && t1.s == t2.s && t1.v == t2.v);
}

/***************************************************************************/

one member-function for save/load

在成员函数中实现序列化和反序列化。

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/
struct type {
    type()
        :i(33)
        ,d(.33)
        ,s("33")
        ,v({33, 33, 33})
    {}

    std::uint32_t i;
    double d;
    std::string s;
    std::vector<int> v;

    // one member-function for save/load
    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT_NVP(
            "type"
            ,("i", i)
            ,("d", d)
            ,("s", s)
            ,("v", v)
        );
    }
};

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.d = 0;
    t2.s.clear();
    t2.v.clear();

    constexpr std::size_t flags = yas::mem|yas::json;

    auto buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    // TODO: stackoverflow.com/questions/17333
    assert(t1.i == t2.i && t1.d == t2.d && t1.s == t2.s && t1.v == t2.v);
}

/***************************************************************************/

大家不要被YAS_OBJECT_NVP吓到，它是另外一个类似YAS_OBJECT的宏，区别是最后多了NVP，NVP可以理解为name value pair，使用这个宏，需用手动写key的字符串，因此手动写，使得用户可以根据自己的喜好，定义一个与变量名不同的key。值得注意的是，如果归档为json，序列化和反序列化要使用相同的key。

split member-functions for save/load

使用分离的serialize成员函数实现数据的序列化和反序列化。值得注意的是，如果归档为json，序列化和反序列化要使用相同的key。

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

#undef NDEBUG
#include <cassert>

/***************************************************************************/

struct type {
    type()
        :i(33)
        ,d(.34)
        ,s("35")
        ,v({36, 37, 38})
    {}

    std::uint32_t i;
    double d;
    std::string s;
    std::vector<int> v;

    // split member-functions for save/load

    // save
    template<typename Ar>
    void serialize(Ar &ar) const {
        ar & YAS_OBJECT_NVP(
            "type"
            ,("i", i)
            ,("d", d)
            ,("s", s)
            ,("v", v)
        );
    }
    // load
    template<typename Ar>
    void serialize(Ar &ar) {
        ar & YAS_OBJECT_NVP(
            "type"
            ,("i", i)
            ,("d", d)
            ,("s", s)
            ,("v", v)
        );
    }
};

/***************************************************************************/

int main() {
    type t1, t2;
    t2.i = 0;
    t2.d = 0;
    t2.s.clear();
    t2.v.clear();

    constexpr std::size_t flags = yas::mem|yas::json;

    auto buf = yas::save<flags>(t1);

    yas::load<flags>(buf, t2);

    // TODO: stackoverflow.com/questions/17333
    assert(t1.i == t2.i && t1.d == t2.d && t1.s == t2.s && t1.v == t2.v);
}

/***************************************************************************/

总结

通过上面的分享，相信你对yas是什么及怎么使用，已经有了大致的了解，如果想了解更多关于源码的分析，可以我注释后的源码（yas_comment: 对yas源码进行注释）。

也可以关注我，等待我后续关于源码的解析文章。

哎哟哟爱民谣
关注
专栏目录
序列化和压缩
m0_47130698的博客
09-14 669
hadoop需要处理P、T级别的数据，所以在org.apache.hadoop.io中包含一些面向海量数据处理的基本工具。 1、序列化 对象的序列化（Serialization）用于将对象编码成一个字节流，以及从字节流中重新构建一个对象。相反的，处理过程称为反序列化（Deserializing） 序列化有三种主要的用途： 作为一种持久化格式，一个对象被序列化后，他的编码可以被存储在磁盘上，供以后反序列化使用 作为一种通信数据格式：序列化结果可以从一个虚拟机通过网络传到另一个虚拟机上 作为一种拷贝，克隆
yas3fs-cluster-tester:测试工具以诱导和验证跨多节点 yas3fs 集群的活动
06-14
yas3fs-cluster-tester 测试工具以在 N 个对等节点上诱导文件 io 并验证集群活动。 这对于想要验证/测试以查看它在负载下的行为以及 N 对等方的所有管理文件在同一个 S3 存储桶中的行为的人可能很有用。 这已被...
[原译]YAXLib---- XML序列化神器
weixin_33701564的博客
10-05 149
今天早上翻译了Yet-Another-XML-Serialization-Library-for-the-NET，将近4个小时把30页的文档翻译完了。因为文章很长。重新排版压力太大。。我把翻译好的做成了pdf，所以本文只列出前两部分。如果不符合规则。请管理员撤下。 文档下载：XML序列化神器 整个文档目录如下： 目录 1介绍... 1 2 为什么使用YAXLib. 2 3 YAXLib...
利用yaml-cpp库对数据结构序列化
junior19的博客
07-12 975
有时候我们要将一个int、float、bool转成字符串，这个用boost能简单地实现，但是一些复杂的数据结构比如STL的vector、map、list、set甚至是组合的vector<vector<int> >、map<string, vector<list<double> > >数据结构，可以通过yaml库来实现序列化成字符串，下面简...
YAZI序列化工具
qq_57283958的博客
12-31 437
序列化
序列化与压缩
konstantin的博客
08-17 2167
对象的序列化（Serialization）用于将对象编译成一个字节流，以及从字节流里重新构建对象，将一个对象编码成一个字节流为欸序列化该对象；相反处理为反序列化（Deserializing）； 序列化有三种主要途径： 作为一种持久化格式：一个对象序列化以后他的编码吗可以存储在磁盘上；供以以后反序列化使用； 作为一种通信数据格式：序列化结果可以从一个正在运行的虚拟机通过网络被传递到另一个虚拟机
yas.zip_PCM编码_Yas_yas.zip
09-23
在“yas.zip_PCM编码_Yas_yas.zip”这个压缩包中，我们可以看到与PCM编码相关的资源和配置文件，这可能是为了实现一个特定的音频播放功能或优化音频质量。 首先，`cmp.js`可能是一个JavaScript文件，用于控制音乐...
yas3fs-test:yas3fs-测试
07-13
在深入探讨 yas3fs 和如何测试之前，我们先来了解一下什么是文件系统以及 Amazon S3。 文件系统是操作系统用来组织、存储和检索数据的一种方式。在本地计算机上，文件系统通常指的是硬盘上的文件结构。而 Amazon S3...
YAS-108使用说明书-雅马哈.pdf
03-05
YAS-108使用说明书-雅马哈.pdf
matlabicp源码-yas:另一个扫描仪
06-03
icp源码亚斯 概述 介绍 理论 有关基础理论的详细信息，请参见 J. Balzer、M. Peters、S. Soatto：体积重建应用于尺寸和重量的感知研究，IEEE WACV，2014 年。 可以使用预印本。 如果您在自己发表的作品中使用该软件...
cpp-serializers：比较各种C ++数据序列化库（节俭，protobuf等）的基准
01-28
cpp-serializers：比较各种C ++数据序列化库（节俭，protobuf等）的基准
c++数据序列化
xiaolangge666的博客
06-19 184
C++数据序列化是指将一个内存中的对象转换成一串字节数据（通常存储在一个字节数组中），以便于保存到本地文件或通过网络进行传输。这个过程将对象的状态信息转换为一种可以存储或传输的形式。简单来说，序列化就是将对象实例的状态转换为可保持或可传输的格式的过程。总的来说，C++数据序列化是一种强大的技术，它允许程序员轻松地保存、加载和传输对象的状态，从而简化了应用程序的开发过程。
数据序列化搜集的一些资料
u013597671的专栏
01-11 741
一、序列化类型 protobuf ，还可去（官网 须墙） FlatBuffers：很多场景其实用FlatBuffers也许就够了。不过官方的性能测试值得怀疑，还是需要自己测测。 Thrift：性能还可以，但是资料比较少，适用于服务器和客户端的通信，一般通信不知道好不好用。 YAS：挺有意思的一个序列化，据说性能不错，不过语法用起来有点繁琐，而且没看到多option字段是如何支持的。 capnpr...
探索技术之美：yas - 一个高效、灵活的YAML解析库
gitblog_00070的博客
04-13 379
探索技术之美：yas - 一个高效、灵活的YAML解析库 项目地址:https://gitcode.com/niXman/yas 项目简介 yas 是一个由 niXman 开发的轻量级C++库，专注于解析和生成YAML格式的数据。YAML是一种流行的元数据标记语言，常用于配置文件、数据交换或序列化。yas项目旨在为开发者提供简单、高效的接口，使得在C++应用中处理YAML数据变得轻松。 技术分析 ...
JSON-B和Yasson详解
chszs的专栏
01-14 3815
JSON-B和Yasson详解 2018.1.14 版权声明：本文为博主chszs的原创文章，未经博主允许不得转载。 JSON-B是Java EE 8规范中的新API之一。它用于解决标准化Java对象如何在JSON中进行序列化。 JSON-B，即Java API for JSON Binding，用于JSON绑定的Java API，是一套最新的API，也是Java EE 8规范的一部分。
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1108
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 273
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 530
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值