libcargo

C++ library for handling serialization. More...

Macros
#define	CARGO_REGISTER_EMPTY
	Register empty cargo class. More...
#define	CARGO_REGISTER(...)
	Registers cargo fields within class. More...
#define	CARGO_EXTEND(BASE)
	Registers new cargo fields within child class. More...

Detailed Description

C++ library for handling serialization.

cargo libraries usage example

#include "cargo/fields.hpp"
#include "cargo-gvariant/cargo-gvariant.hpp"
#include "cargo-json/cargo-json.hpp"
#include "cargo-sqlite/cargo-sqlite.hpp"
#include "cargo-sqlite-json/cargo-sqlite-json.hpp"
#include "cargo-fd/cargo-fd.hpp"
#include <iostream>
#include <cstdio>

struct Foo
{
    std::string bar = "plain-text";
    std::vector<int> tab = std::vector<int>{1, 2, 4, 8};
    double number = 3.14;

    CARGO_REGISTER
    (
        bar,
        tab,
        number
    )
};

int main()
{
    Foo foo;

    const std::string jsonString = cargo::saveToJsonString(foo);
    cargo::loadFromJsonString(jsonString, foo);

    const GVariant* gVariantPointer = cargo::saveToGVariant(foo);
    cargo::loadFromGVariant(gVariantPointer, foo);
    g_variant_unref(gVariantPointer);

    constexpr std::string jsonFile = "foo.json";
    cargo::saveToJsonFile(jsonFile, foo);
    cargo::loadFromJsonFile(jsonFile, foo);

    constexpr std::string kvDBPath = "kvdb";
    constexpr std::string key = "foo";
    cargo::saveToKVStore(kvDBPath, foo, key);
    cargo::loadFromKVStore(kvDBPath, foo, key);

    cargo::loadFromKVStoreWithJson(kvDBPath, jsonString, foo, key);
    cargo::loadFromKVStoreWithJsonFile(kvDBPath, jsonFile, foo, key);

    FILE* file = fopen("blob", "wb");
    if (!file)
    {
        return EXIT_FAILURE;
    }
    const int fd = ::fileno(file);
    cargo::saveToFD(fd, foo);
    ::fclose(file);
    file = ::fopen("blob", "rb");
    if(!file) {
        return EXIT_FAILURE;
    }
    cargo::loadFromFD(fd, foo);
    ::fclose(file);

    return 0;
}

Macro Definition Documentation

#define CARGO_EXTEND

(

BASE

)

Value:

typedef BASE ParentVisitor;                                    \
    __CARGO_EXTEND                                                 \

Registers new cargo fields within child class.

CARGO_REGISTER doesn't preserve cargo fields registered in the base class. Use this macro instead.

Example:

struct Foo
{
    std::string bar;
    std::vector<int> tab;

    // SubConfigA must also register config fields
    SubConfigA sub_a;

    // SubConfigB must also register config fields
    std::vector<SubConfigB> tab_sub;

    CARGO_REGISTER
    (
        bar,
        tab,
        sub_a
    )
};

struct FooChild : Foo
{
    std::string newField;

    CARGO_EXTEND(Foo)
    (
        newField
    )
};

#define CARGO_REGISTER

(

...

)

Value:

template<typename Visitor>                                     \
    void accept(Visitor v) {                                       \
        GENERATE_ELEMENTS__(__VA_ARGS__)                           \
    }                                                              \
    template<typename Visitor>                                     \
    void accept(Visitor v) const {                                 \
        GENERATE_ELEMENTS__(__VA_ARGS__)                           \
    }                                                              \

Registers cargo fields within class.

Example:

struct Foo
{
    std::string bar;
    std::vector<int> tab;

    // SubConfigA must also register config fields
    SubConfigA sub_a;

    // SubConfigB must also register config fields
    std::vector<SubConfigB> tab_sub;

    CARGO_REGISTER
    (
        bar,
        tab,
        sub_a
    )
};

#define CARGO_REGISTER_EMPTY

Value:

template<typename Visitor>                                     \
    static void accept(Visitor ) {                                 \
    }                                                              \

Register empty cargo class.