Tree @HEAD (Download .tar.gz)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | # libnop: C++ Native Object Protocols libnop is a header-only library for serializing and deserializing C++ data types without external code generators or runtime support libraries. The only mandatory requirement is a compiler that supports the C++14 standard. Note: This is not an officially supported Google product at this time. ## Goals libnop has the following goals: * Make simple serialization tasks easy and complex tasks tractable. * Remove the need to use code generators and schema files to describe data types, formats, and protocols: perform these tasks naturally within the C++ language. * Avoid additional runtime support requirements for serialization. * Provide contemporary features such as bidirectional binary compatibility, data validation, type safety, and type fungibility. * Handle intrinsic types, common STL types and containers, and user-defined types with a minimum of effort. * Produce optimized code that is easy to analyze and profile. * Avoid internal dynamic memory allocation when possible. ## Getting Started Take a look at [Getting Started](docs/getting-started.md) for an introduction to the library. ## Quick Examples Here is a quick series of examples to demonstrate how libnop is used. You can find more examples in the repository under [examples/](examples/). ### Writing STL Containers to a Stream ```C++ #include <iostream> #include <map> #include <sstream> #include <utility> #include <vector> #include <nop/serializer.h> #include <nop/utility/stream_writer.h> int main(int argc, char** argv) { using Writer = nop::StreamWriter<std::stringstream>; nop::Serializer<Writer> serializer; serializer.Write(std::vector<int>{1, 2, 3, 4}); serializer.Write(std::vector<std::string>{"foo", "bar", "baz"}); using MapType = std::map<std::uint32_t, std::pair<std::uint64_t, std::string>>; serializer.Write( MapType{{0, {10, "foo"}}, {1, {20, "bar"}}, {2, {30, "baz"}}}); const std::string data = serializer.writer().stream().str(); std::cout << "Wrote " << data.size() << " bytes." << std::endl; return 0; } ``` ### Simple User-Defined Types ```C++ #include <cstdint> #include <iostream> #include <sstream> #include <string> #include <vector> #include <nop/serializer.h> #include <nop/structure.h> #include <nop/utility/stream_writer.h> namespace example { struct Person { std::string name; std::uint32_t age_years; std::uint8_t height_inches; std::uint16_t weight_pounds; NOP_STRUCTURE(Person, name, age_years, height_inches, weight_pounds); }; } // namespace example int main(int argc, char** argv) { using Writer = nop::StreamWriter<std::stringstream>; nop::Serializer<Writer> serializer; serializer.Write(example::Person{"John Doe", 37, 72, 180}); serializer.Write(std::vector<example::Person>{ {"John Doe", 37, 72, 180}, {"Jane Doe", 36, 69, 130}}); const std::string data = serializer.writer().stream().str(); std::cout << "Wrote " << data.size() << " bytes." << std::endl; return 0; } ``` ### More Complex User-Defined Types ```C++ #include <array> #include <iostream> #include <sstream> #include <string> #include <nop/serializer.h> #include <nop/structure.h> #include <nop/utility/stream_writer.h> namespace example { // Contrived template type with private members. template <typename T> struct UserDefined { public: UserDefined() = default; UserDefined(std::string label, std::vector<T> vector) : label_{std::move(label)}, vector_{std::move(vector)} {} const std::string label() const { return label_; } const std::vector<T>& vector() const { return vector_; } private: std::string label_; std::vector<T> vector_; NOP_STRUCTURE(UserDefined, label_, vector_); }; } // namespace example int main(int argc, char** argv) { using Writer = nop::StreamWriter<std::stringstream>; nop::Serializer<Writer> serializer; serializer.Write(example::UserDefined<int>{"ABC", {1, 2, 3, 4, 5}}); using ArrayType = std::array<example::UserDefined<float>, 2>; serializer.Write( ArrayType{{{"ABC", {1, 2, 3, 4, 5}}, {"XYZ", {3.14, 2.72, 23.14}}}}); const std::string data = serializer.writer().stream().str(); std::cout << "Wrote " << data.size() << " bytes." << std::endl; return 0; } ``` |
Commit History @HEAD
0
»»
- Cherry-pick upstream patch to fix FTBFS on 32-bit archs. (Closes: #973799) Mo Zhou 3 years ago
- dch: finalize and upload to unstable Mo Zhou 3 years ago
- gbp-dch: finalize and upload to experimental Mo Zhou 3 years ago
- add copyright and install Mo Zhou 3 years ago
- debianiazation Mo Zhou 3 years ago
- New upstream version 0.0~git20200728.45dfe0f Mo Zhou 3 years ago
0
»»