libnop: C++ 本机对象协议

libnop 是一个仅包含头文件的库，用于在没有外部代码生成器或运行时支持库的情况下序列化和反序列化 C++ 数据类型。唯一的强制要求是支持 C++14 标准的编译器。

注意：目前这不是官方支持的 Google 产品。

目标

libnop 有以下目标：

  • 使简单的序列化任务变得容易，复杂的任务变得可行。
  • 消除使用代码生成器和模式文件来描述数据类型、格式和协议的需要：在 C++ 语言中自然执行这些任务。
  • 避免序列化的额外运行时支持要求。
  • 提供当代功能，如双向二进制兼容性、数据验证、类型安全性和类型可互换性。
  • 以最小的工作量处理内部类型、常见 STL 类型和容器以及用户定义的类型。
  • 生成易于分析和剖析的优化代码。 -在可能的情况下避免内部动态内存分配。

入门指南

请查看《入门指南》以了解该库的简介。

快速示例

这里是一系列快速示例，演示了如何使用 libnop。您可以在存储库的 examples/ 目录下找到更多示例。

将 STL 容器写入流中

  1. #include <iostream>
  2. #include <map>
  3. #include <sstream>
  4. #include <utility>
  5. #include <vector>
  7. #include <nop/serializer.h>
  8. #include <nop/utility/stream_writer.h>
  10. int main(int argc, char** argv) {
  11.   using Writer = nop::StreamWriter<std::stringstream>;
  12.   nop::Serializer<Writer> serializer;
  14.   serializer.Write(std::vector<int>{1, 2, 3, 4});
  15.   serializer.Write(std::vector<std::string>{"foo", "bar", "baz"});
  17.   using MapType =
  18.       std::map<std::uint32_t, std::pair<std::uint64_t, std::string>>;
  19.   serializer.Write(
  20.       MapType{{0, {10, "foo"}}, {1, {20, "bar"}}, {2, {30, "baz"}}});
  22.   const std::string data = serializer.writer().stream().str();
  23.   std::cout << "Wrote " << data.size() << " bytes." << std::endl;
  24.   return 0;
  25. }

简单自定义类型

  1. #include <cstdint>
  2. #include <iostream>
  3. #include <sstream>
  4. #include <string>
  5. #include <vector>
  7. #include <nop/serializer.h>
  8. #include <nop/structure.h>
  9. #include <nop/utility/stream_writer.h>
  11. namespace example {
  13. struct Person {
  14.   std::string name;
  15.   std::uint32_t age_years;
  16.   std::uint8_t height_inches;
  17.   std::uint16_t weight_pounds;
  18.   NOP_STRUCTURE(Person, name, age_years, height_inches, weight_pounds);
  19. };
  21. }  // namespace example
  23. int main(int argc, char** argv) {
  24.   using Writer = nop::StreamWriter<std::stringstream>;
  25.   nop::Serializer<Writer> serializer;
  27.   serializer.Write(example::Person{"John Doe", 37, 72, 180});
  28.   serializer.Write(std::vector<example::Person>{
  29.       {"John Doe", 37, 72, 180}, {"Jane Doe", 36, 69, 130}});
  31.   const std::string data = serializer.writer().stream().str();
  32.   std::cout << "Wrote " << data.size() << " bytes." << std::endl;
  33.   return 0;
  34. }

复杂自定义类型

  1. #include <array>
  2. #include <iostream>
  3. #include <sstream>
  4. #include <string>
  6. #include <nop/serializer.h>
  7. #include <nop/structure.h>
  8. #include <nop/utility/stream_writer.h>
  10. namespace example {
  12. // Contrived template type with private members.
  13. template <typename T>
  14. struct UserDefined {
  15.  public:
  16.   UserDefined() = default;
  17.   UserDefined(std::string label, std::vector<T> vector)
  18.       : label_{std::move(label)}, vector_{std::move(vector)} {}
  20.   const std::string label() const { return label_; }
  21.   const std::vector<T>& vector() const { return vector_; }
  23.  private:
  24.   std::string label_;
  25.   std::vector<T> vector_;
  27.   NOP_STRUCTURE(UserDefined, label_, vector_);
  28. };
  30. }  // namespace example
  32. int main(int argc, char** argv) {
  33.   using Writer = nop::StreamWriter<std::stringstream>;
  34.   nop::Serializer<Writer> serializer;
  36.   serializer.Write(example::UserDefined<int>{"ABC", {1, 2, 3, 4, 5}});
  38.   using ArrayType = std::array<example::UserDefined<float>, 2>;
  39.   serializer.Write(
  40.       ArrayType{{{"ABC", {1, 2, 3, 4, 5}}, {"XYZ", {3.14, 2.72, 23.14}}}});
  42.   const std::string data = serializer.writer().stream().str();
  43.   std::cout << "Wrote " << data.size() << " bytes." << std::endl;
  44.   return 0;
  45. }

更加复杂的用户自定义类型

  1. #include <array>
  2. #include <iostream>
  3. #include <sstream>
  4. #include <string>
  6. #include <nop/serializer.h>
  7. #include <nop/structure.h>
  8. #include <nop/utility/stream_writer.h>
  10. namespace example {
  12. // Contrived template type with private members.
  13. template <typename T>
  14. struct UserDefined {
  15.  public:
  16.   UserDefined() = default;
  17.   UserDefined(std::string label, std::vector<T> vector)
  18.       : label_{std::move(label)}, vector_{std::move(vector)} {}
  20.   const std::string label() const { return label_; }
  21.   const std::vector<T>& vector() const { return vector_; }
  23.  private:
  24.   std::string label_;
  25.   std::vector<T> vector_;
  27.   NOP_STRUCTURE(UserDefined, label_, vector_);
  28. };
  30. }  // namespace example
  32. int main(int argc, char** argv) {
  33.   using Writer = nop::StreamWriter<std::stringstream>;
  34.   nop::Serializer<Writer> serializer;
  36.   serializer.Write(example::UserDefined<int>{"ABC", {1, 2, 3, 4, 5}});
  38.   using ArrayType = std::array<example::UserDefined<float>, 2>;
  39.   serializer.Write(
  40.       ArrayType{{{"ABC", {1, 2, 3, 4, 5}}, {"XYZ", {3.14, 2.72, 23.14}}}});
  42.   const std::string data = serializer.writer().stream().str();
  43.   std::cout << "Wrote " << data.size() << " bytes." << std::endl;
  44.   return 0;
  45. }