https://github.com/onyazuka/serializer
Simple C++ serializer
https://github.com/onyazuka/serializer
containers cpp cpp17 deserialization fast serialization
Last synced: 10 days ago
JSON representation
Simple C++ serializer
- Host: GitHub
- URL: https://github.com/onyazuka/serializer
- Owner: onyazuka
- License: mit
- Created: 2019-04-05T08:06:46.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2020-02-25T12:44:53.000Z (over 6 years ago)
- Last Synced: 2025-05-15T17:13:48.134Z (about 1 year ago)
- Topics: containers, cpp, cpp17, deserialization, fast, serialization
- Language: C++
- Size: 17.6 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Serializer
Simple C++ serializer
Description
Simple c++ serialization library.
It allows you to serialize such types:
- Simple arithmetic types
- Arrays
- All std containers
- Your custom types
It makes a std::string, filled with binary data, on output. Why use std::string? Later, you can write it to a file or make some manipulations and write it somewhere after that.
Requirements
It is just one header, without any dependencies. So, any c++ compiler that supports c++17 should be ok, but I have only tested it with g++.
Examples
First of all you should include "serializer.hpp" header and, if you want, do "using namespace Serialization;".
Then, let's try to serialize some simple type:
```Cpp
int i = 5; // your value
std::string buf; // your buffer
BytesCount b = Serializer::SerializeUnit::serializeUnit(buf, &i);
```
Here, 'b' is the number of bytes that was read;
And after that, you can try to get your number back:
```Cpp
int i1;
b = Deserializer::DeserializeUnit::deserializeUnit(buf, 0, &i);
```
Here, the second argument of deserializeUnit is the offset, from which value in the 'buf' will be looked for.
It is very convenient to use the 'serializeAll' function. It uses variadic templates, and with it you could serialize a bunch of things just in one line:
```Cpp
buf.clear();
double d = 1.1;
std::unordered_map um{{1, "neko"}, {2, "wanko"}, {3, "manko"}};
std::vector> vvs{{"some", "thing"}, {"some", "other", "thing"}};
b = Serializer::serializeAll(buf, &um, &d, &vvs);
// getting back
decltype(um) um1;
decltype(vvs) vvs1;
decltype(d) d1;
b = Deserializer::deserializeAll(buf, 0, &um1, &d1, &vvs1);
```
To serialize array types(including std::array), you shoud use ArrayWrapper from Serialization namespace:
```Cpp
buf.clear();
int* pi = new int[10];
... // initializng 'i'
ArrayWrapper aw{pi, 10};
b = Serializer::serializeAll(buf, &aw);
```
As you can see, pointers are used as arguments, so if you try to pass a raw pointer as a parameter, just the first value of this type starting from the passed address will be processed.
And, to get it back, we should use ArrayWrapper again.
WARNING: before deserialization, memory for array should be already allocated:
```Cpp
ArrayWrapper aw1;
aw11.start = new int[5];
b = Deserializer::deserializeAll(buf, 0, &aw1);
```
And, of course, you can serialize your own objects. Here you have two options:
- If serialization/deserialization of your object can be done only in one way, you should inherit Serializable/Deserializable class(or both):
```Cpp
struct User : public Serialization::Serializable, public Serialization::Deserializable
{
std::string name;
int age;
std::vector hobbies;
S::BytesCount serialize(std::string &buf)
{
return S::Serializer::serializeAll(buf, &name, &age, &hobbies);
}
S::BytesCount deserialize(const std::string& buf, S::BytesCount offset)
{
return S::Deserializer::deserializeAll(buf, offset, &name, &age, &hobbies);
}
};
...
User user;
user.age = 22;
user.name = "Vasya";
user.hobbies = {"swimming", "anime", "fishing"};
std::string buf;
BytesCount b = Serializer::serializeAll(buf, &user);
```
- If serialization/deserialization of your object can be done in multiple ways, you should inherit MultipleSerializable/MultipleDeserializable(or both):
```Cpp
struct Cat : public MultipleSerializable, public MultipleDeserializable
{
enum {NameLegsSerializer, AllSerializer, NameLegsDeserializer, AllDeserializer};
Cat()
: MultipleSerializable{}, MultipleDeserializable{}
{
registerSerializer(SerializerId(NameLegsSerializer), [this](std::string& buf) { return Serializer::serializeAll(buf, &name, &legs); } );
registerSerializer(SerializerId(AllSerializer), [this](std::string& buf) { return Serializer::serializeAll(buf, &name, &legs, &age, &places_to_sleep); } );
registerDeserializer(SerializerId(NameLegsDeserializer), [this](const std::string& buf, BytesCount offset) { return Deserializer::deserializeAll(buf, offset, &name, &legs); } );
registerDeserializer(SerializerId(AllDeserializer), [this](const std::string& buf, BytesCount offset) { return Deserializer::deserializeAll(buf, offset, &name, &legs, &age, &places_to_sleep); } );
}
std::string name;
int legs;
short age;
std::vector places_to_sleep;
};
...
Cat cat;
cat.age = 5;
cat.legs = 4;
cat.name = "Sugrob";
cat.places_to_sleep = std::move(std::vector{"chair", "laptop", "my head"});
cat.setSerializerId((SerializerId)(Cat::AllSerializer));
Serializer::serializeAll(buf, &cat);
```