A Thin Binary Serialization Mechanism

So this time I was playing around serializing things in binary files. Because who doesn’t want to read back the data in a form ready-to-be-consumed by his/her program with a single line of code?

Step zero is the obligatory Note that I’m in no way a C++ expert and the code you see might be a big mess. Born to improve nonetheless…

As a first step we need a simple interface to know what can be serialized. Add in this a forward declaration for our Serializer. Something like…

class Serializer; class Serializable { public: virtual void SaveTo (Serializer *s) const = 0; virtual void LoadFrom (Serializer *s) = 0; };

Any object that wants to be serialized needs to implement those 2 methods and declare what needs saving and loading. For example our game’s Character class may do:

void SaveTo(Serializer *s) const { s->Write(mName); s->Write(mCombatStats.ArmorClass); s->Write(mCombatStats.AttackBase); s->Write(mCombatStats.AttackSpeed); s->Write(mMainWeapon); s->Write(mSecondaryWeapon); } void LoadFrom(Serializer *s) { s->Read(mName); s->Read(mCombatStats.ArmorClass); s->Read(mCombatStats.AttackBase); s->Read(mCombatStats.AttackSpeed); s->Read(mMainWeapon); s->Read(mSecondaryWeapon); }

In this example mName is of std::string type. mCombatStats is a struct that has many attributes but we want to track only those 3. Finally mMainWeapon and mSecondaryWeapon are instances of a Weapon class that implements the Serializable interface too.

The second step is defining how the Serializer works. That is how those Write and Read methods are implemented. Let’s focus on these and leave the actual file handling aside… (full source link at the end of the post)

template<class T> using IsScalar = typename std::enable_if< std::is_scalar::value >::type*; template<class T> using IsSerializable = typename std::enable_if< std::is_base_of::value, Serializable >::type*; template<class T> using IsString = typename std::enable_if< std::is_base_of::value, std::string >::type*; class Serializer { public: //[...] // * Writing methods... template<class T, IsScalar<T> = nullptr> void Write (const T& value) { //[...] fwrite(&value, sizeof(T), 1, mpFile); } template<class T, IsSerializable<T> = nullptr> void Write (const T& value) { //[...] value.SaveTo(this); } template<class T, IsString<T> = nullptr> void Write (const T& value) { //[...] int size = value.size(); fwrite(&size, sizeof(int), 1, mpFile); fwrite(value.c_str(), size, 1, mpFile); } // * Reading methods... template<class T, IsScalar<T> = nullptr> void Read (T &value) { //[...] fread(&value, sizeof(T), 1, mpFile); } template<class T, IsSerializable<T> = nullptr> void Read (T &value) { //[...] value.LoadFrom(this); } template<class T, IsString<T> = nullptr> void Read (T &value) { //[...] int size; fread(&size, sizeof(int), 1, mpFile); char* tmp = new char[size+1]; tmp[size] = '\0'; fread(tmp, size, 1, mpFile); value.assign(tmp); delete[] tmp; } //[...] };

Using SFINAE through C++11’s std::enable_if (header <type_traits>) and some extra trait classes like std::is_scalar and std::is_base_of we are able to provide a different implementation for each type of attribute that is being written on the file.

Scalars like int, float, bool, enumerations etc are detected and handed on the proper Write or Read method through

template<class T, IsScalar<T> = nullptr>

which expands into

template<class T, typename std::enable_if< std::is_scalar<T>::value >::type* = nullptr>

by the using… alias-declarations defined right before the class.

Using the same technique we handle std::strings and all objects that are based on the Serializable class by delegating the Writing/Reading to their respective methods.

This way a whole hierarchy of composed objects can be serialized and de-serialized to/from a single binary file using one line of code!

// Write character Character ch; ch.mName = "Aneleith the Legendary Ranger" ch.mCombatStats.ArmorClass = 16; ch.mMainWeapon = Weapon("Bow of the Relentless Bear"); Serializer ser; ser.SetFile("character.dat"); ch.SaveTo(ser); // <<< All is needed to save // Read character Character ch; Serializer ser; ser.SetFile("character.dat"); ch.LoadFrom(ser); // <<< All is needed to load

I think this is pretty straight forward and simple though needs some more stuff to actually be useful. One major feature needed is handling collections like arrays/vectors and dictionaries/maps. Which will keep me messing with it for some more time…

Anyway, a Gist with the full source code can be found here

If you made it this far, thank you very much for reading and I would like to see your constructive critique in the comments section that follows…

I want to get my hands on this book sometime. I hope that a more solid knowledge of the topics covered will give me a better direction coding graphics stuff. Following the try-and-fail-until-you-succeed method -like I have done lately- doesn’t make you feel really productive when thinking the time spent. Although the “aha” moments are bold and plenty.