Plain Old Data Serializer (PODS)

Feature List

• header only
• high performance (perhaps binary serialization is the fastest on the Earth)
• optional values
• supported archive formats:
  • JSON
  • MsgPack
• serialization from/to:
  • memory buffer
  • resizable memory buffer
  • standard C++ streams

Benchmarks

Comparison with memcpy

MacBook Pro, 2017
3.5 GHz Intel Core i7
16 Gb 2133 MHz LPDDR3

data size: 11520
serialized data size: 11632
memcpy
    total: 27465 Mb
    total time: 2396.19 ms
    speed: 11461.9 Mb/s
serialization
    total: 27732 Mb
    total time: 3502.93 ms
    speed: 7916.8 Mb/s
deserialization
    total: 27732 Mb
    total time: 3200.15 ms
    speed: 8665.83 Mb/s

Comparison with other libraries

performing 100000 iterations
thrift-binary: version = 0.10.0
thrift-binary: size = 17017 bytes
thrift-binary: time = 2259 milliseconds
protobuf: version = 3001000
protobuf: size = 16116 bytes
protobuf: time = 2797 milliseconds
capnproto: version = 6001
capnproto: size = 17768 bytes
capnproto: time = 486 milliseconds
boost: version = 106200
boost: size = 17470 bytes
boost: time = 1365 milliseconds
msgpack: version = 2.1.3
msgpack: size = 13402 bytes
msgpack: time = 3638 milliseconds
cereal: size = 17416 bytes
cereal: time = 1034 milliseconds
avro: size = 16384 bytes
avro: time = 4780 milliseconds
flatbuffers: size = 17632 bytes
flatbuffers: time = 433 milliseconds
yas: version = 6.0.2
yas: size = 17416 bytes
yas: time = 317 milliseconds
pods: size = 17012 bytes
pods: time = 235 milliseconds

Using PODS

MsgPack serialization

#include <iostream>
#include <pods/pods.h>
#include <pods/msgpack.h>
#include <pods/buffers.h>
// just a struct for serialization
struct Server
{
    std::string address;        // no default value
    uint16_t port = 8080;       // default value
    PODS_SERIALIZABLE(
        PODS_MDR(address),      // mandatory field
        PODS_OPT(port))         // optional field
};
int main(int /*argc*/, char** /*argv*/)
{
    const Server original;
    pods::ResizableOutputBuffer out;
    pods::MsgPackSerializer<decltype(out)> serializer(out);
    if (serializer.save(original) != pods::Error::NoError)
    {
        std::cerr << "serialization error\n";
        return EXIT_FAILURE;
    }
    Server loaded = {};
    pods::InputBuffer in(out.data(), out.size());
    pods::MsgPackDeserializer<decltype(in)> deserializer(in);
    if (deserializer.load(loaded) != pods::Error::NoError)
    {
        std::cerr << "deserialization error\n";
        return EXIT_FAILURE;
    }
    if (original.address != loaded.address
        || original.port != loaded.port)
    {
        std::cerr << "corrupted archive\n";
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

JSON serialization

#include <iostream>
#include <pods/pods.h>
#include <pods/json.h>
#include <pods/buffers.h>
// just a struct for serialization
struct Server
{
    std::string address;        // no default value
    uint16_t port = 8080;       // default value
    PODS_SERIALIZABLE(
        PODS_MDR(address),      // mandatory field
        PODS_OPT(port))         // optional field
};
struct ServerList
{
    std::vector<Server> servers =
    {
        // this is default values
        Server { "localhost", 8080 },
        Server { "my.com", 2018 }
    };
    PODS_SERIALIZABLE(
        PODS_MDR(servers))
};
int main(int /*argc*/, char** /*argv*/)
{
    const ServerList original;
    pods::ResizableOutputBuffer out;
    pods::PrettyJsonSerializer<decltype(out)> serializer(out);
    if (serializer.save(original) != pods::Error::NoError)
    {
        std::cerr << "serialization error\n";
        return EXIT_FAILURE;
    }
    ServerList loaded;
    loaded.servers.clear();
    pods::InputBuffer in(out.data(), out.size());
    pods::JsonDeserializer<decltype(in)> deserializer(in);
    if (deserializer.load(loaded) != pods::Error::NoError)
    {
        std::cerr << "deserialization error\n";
        return EXIT_FAILURE;
    }
    const std::string json(out.data(), out.size());
    std::cout << json << '\n';
    return EXIT_SUCCESS;
}

Output:

{
    "servers": [
        {
            "address": "localhost",
            "port": 8080
        },
        {
            "address": "my.com",
            "port": 2018
        }
    ]
}

Standard streams

#include <iostream>
#include <sstream>
#include <pods/pods.h>
#include <pods/msgpack.h>
#include <pods/streams.h>
// just a struct for serialization
struct Server
{
    std::string address;        // no default value
    uint16_t port = 8080;       // default value
    PODS_SERIALIZABLE(
        PODS_MDR(address),      // mandatory field
        PODS_OPT(port))         // optional field
};
int main(int /*argc*/, char** /*argv*/)
{
    const Server original;
    std::stringstream buffer;
    pods::OutputStream out(buffer);
    pods::MsgPackSerializer<decltype(out)> serializer(out);
    if (serializer.save(original) != pods::Error::NoError)
    {
        std::cerr << "serialization error\n";
        return EXIT_FAILURE;
    }
    Server loaded = {};
    pods::InputStream in(buffer);
    pods::MsgPackDeserializer<decltype(in)> deserializer(in);
    if (deserializer.load(loaded) != pods::Error::NoError)
    {
        std::cerr << "deserialization error\n";
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}