Small, light and easy to understand data serialization library for C .
This is an extract from the live source ofBvckup 2. It’s not meant to be an universal serialization library, but rather a real-life working example of one of many ways to do serialization. Doing itsimplyat that.
Quick intro
Given two processes that use the same data model and exchange parts of it with each other, this library helps packing and unpacking in-memory data structures to / from binary blobs withas little fuss as possible.
No separate schemas, no precompilation, no verbose description of protocols, etc.
Just define your data structures …
struct foo { bool aaa; mapbbb; };
… specify which fields to serialize …
OBJECT_SPEC (foo) __f (aaa), __f (bbb) END_OF_SPEC
… and you are done!
// store: data ->blob buffer buf; foo something; store (buf, something); // parse: blob ->data parser par; foo inbound; par.init (buf); parse (par, inbound); assert (parse.eof ());
How it works
The library revolves around two functions –store ()
andparse ()
.
Store
appends binary representation of its argument to an existing data blob.
Parse
extracts an instance of specified type from the blob.
The library knows how to serialize basic types likebool
,uint8_t
, etc. That is, it has overloaded versions of
void store (buffer & buf, const bool & v ); void store (buffer & buf, const uint8_t & v); ... bool parse (parser & par, bool & v); bool parse (parser & par, uint8_t & v); ...
It knows how to serializestring
,wstring
or any other specialization ofstd :: basic_string
.
It knows how to serializevector
,set
andmap
and it can be easily extended to support other container types likelist
andDeque
.
However, in order to serialize a container, it obviously needs to know how to store / parse the elements contained within. If they are of a known type, e.g.bool
, then we are good. But if their type is a class or a struct, then we need to teach the library how to handle them.
Serializing structs
If we havestruct foo
, then we can obviously implementstore (..., const foo &)
andparse (..., foo &)
and that will do it. That’s not terribly elegant though. *****
It is also too verbose. Both functions will end up lookingalmostthe same, except one will be callingstore
for every field and another –parse
.
It’s C , the most overpowered language in existence. We can do better.
Enterserialize_obj.h
Through a combination ofpointers to members,variadic templatesand a modest sprinkle of macros it coerces the compiler into auto-generatingstore
and (parse) ******************** (overloads from a plain list of struct members.)
So we can just go:
OBJECT_SPEC (foo) - the type we are describing __f (aaa), - field we want to be stored / parsed __f (bbb) - another field END_OF_SPEC - close all open brackets and what not
and we getstore (..., const foo &)
auto-generated as soon as we call it.
Magic.
Caveats
A quick list of cases that aren’t supported by the library:
-
Classes with complicated inheritance, members that are references, pointers, etc., i.e. cases that require some sort of pre- or post-processing when instantiating an object.
-
Classes that use getters and setters. Not hard to accommodate with a bit of extra code.
-
Serializing into a tagged format, like JSON or XML. Can be supported by capturing field names in
member_ptr
-
Storing integers in a network byte order. This too is very easy to support, but a pointless thing to do forIPCwithin the same host, which is what we have.
Footnotes
For a similar, but a bit more generic library seehttps://github.com/eliasdaler/MetaStuff
GIPHY App Key not set. Please check settings