Serialize/Deserialize JSON Representations to Qt Objects (QObject's) in C++

Calls to HTTP servers are very frequent nowadays, and JSON is frequently used when dealing with structured data. When I write applications in Java/Kotlin, I always use retrofit2 with gson integration, or similar approaches. It is very comfortable to be able to serialize/deserialize to Java objects automatically. I tried to find something similar for Qt, but I couldn't find much. JSON support in Qt is good, but does not seem to be able to map QOject's to QJSonObject. I also could not find other C++ libraries doing this. Probably the difficulty of implementing reflection in C++ would make the implementation a bit convoluted. A good candidate I found is this: https://github.com/Loki-Astari/ThorsSerializer, which seems not to require much boilerplate code, not too verbose and no generated code.

However, Qt includes the meta object system (https://doc.qt.io/qt-5/metaobjects.html), and therefore I tried to use it to get the desired result. In a couple of hours I got to a pretty decent result: https://github.com/carlonluca/lqobjectserializer. It is far from perfect, but it seems to work. Have a look at the readme or the unit tests to know more.

The draft is free to use: you can contribute, report bugs etc...

For instance, a JSON object like this:

{"menu": {

    "header": "SVG Viewer",

    "items": [

        {"id": "Open"},

        {"id": "OpenNew", "label": "Open New"},

        null,

        {"id": "ZoomIn", "label": "Zoom In"},

        {"id": "ZoomOut", "label": "Zoom Out"},

        {"id": "OriginalView", "label": "Original View"},

        null,

        {"id": "Quality"},

        {"id": "Pause"},

        {"id": "Mute"},

        null,

        {"id": "Find", "label": "Find..."},

        {"id": "FindAgain", "label": "Find Again"},

        {"id": "Copy"},

        {"id": "CopyAgain", "label": "Copy Again"},

        {"id": "CopySVG", "label": "Copy SVG"},

        {"id": "ViewSVG", "label": "View SVG"},

        {"id": "ViewSource", "label": "View Source"},

        {"id": "SaveAs", "label": "Save As"},

        null,

        {"id": "Help"},

        {"id": "About", "label": "About Adobe CVG Viewer..."}

    ]

}}

can be deserialized to a QObject simply by defining the classes (macros here are inherited by my other project https://github.com/carlonluca/lqtutils, but this is not mandatory):

L_BEGIN_CLASS(Item)

L_RW_PROP(QString, id, setId, QString())

L_RW_PROP(QString, label, setLabel, QString())

L_END_CLASS

L_BEGIN_CLASS(Menu)

L_RW_PROP(QString, header, setHeader)

L_RW_PROP_ARRAY_WITH_ADDER(Item*, items, setItems)

L_END_CLASS

L_BEGIN_CLASS(MenuRoot)

L_RW_PROP(Menu*, menu, setMenu, nullptr)

L_END_CLASS

and by writing these few lines:

LDeserializer<MenuRoot> deserializer(factory);

QScopedPointer<MenuRoot> g(deserializer.deserialize(jsonString));

Please leave a comment if you know of other tools in this context, serializing and deserializing JSON is very frequent.

Bye! ;-)

Synthesize Qt Settings

I frequently create classes that I use as an interface to settings in my apps. Using a single class with accessors makes the code readable, safer and simple to maintain. Unfortunately, doing this requires to create getters and setters for every entry in the settings file, which is a bit bothering. Also, QSettings is not a QObject and cannot provide signals to notify changes.

My use cases are typically very simple, so I created a couple of macros that synthesise classes for me. Macros synthesise a reentrant class that can be used to access settings and a notifier, that can be used to get notifications of the changes. An example of definition of the class is:

L_DECLARE_SETTINGS(LSettingsTest, new QSettings("settings.ini", QSettings::IniFormat))

L_DEFINE_VALUE(QString, string1, QString("string1"), toString)

L_DEFINE_VALUE(QSize, size, QSize(100, 100), toSize)

L_DEFINE_VALUE(double, temperature, -1, toDouble)

L_DEFINE_VALUE(QByteArray, image, QByteArray(), toByteArray)

L_END_CLASS

L_DECLARE_SETTINGS(LSettingsTestSec1, new QSettings("settings.ini", QSettings::IniFormat), "SECTION_1")

L_DEFINE_VALUE(QString, string2, QString("string2"), toString)

L_END_CLASS

this will let you instantiate objects of class LSettingsTest and LSettingsTestSec1, and access entries with strong typed methods. Also, by calling LSettingsTest::notifier(), you can get a reference to the unique notifier. By setting an instance as a context property, you can get notifications and you can update settings from QML. You can find some more info in the repo https://github.com/carlonluca/lqtutils and an example using Qt Quick here: https://github.com/carlonluca/lqtutils/tree/master/LQtUtilsQuick.

Bye! ;-)

Synthesize Qt properties

The are some utils that I use in most of my Qt projects. I'm a bit fed up of copy-pasting those every time I need something, so I created a project containing tools that are of frequent use when I write Qt apps, regardless of the type of app.

The only interesting tool I added yet is the synthesizer of Q_PROPERTY's. You can use the macros:

L_RW_PROP
L_RO_PROP

to synthétise props, with getter, setter and notifications. Each macro is overloaded: with 3 params, you do not have initialisation, adding a 4th param, also initialises the variable to the provided value. Also, I frequently need QObject that are just containers of properties, to be used in QML. I added these two macros to spare some lines:

L_BEGIN_CLASS(<class_name>)
L_END_CLASS

A class like:

class Fraction : public QObject
{
    Q_OBJECT
    Q_PROPERTY(double numerator READ numerator WRITE setNumerator NOTIFY numeratorChanged)
    Q_PROPERTY(double denominator READ denominator WRITE setDenominator NOTIFY denominatorChanged)
public:
    Fraction(QObject* parent = nullptr) : QObject(parent) {}
    double numerator() const {
        return m_numerator;
    }
    double denominator() const {
        return m_denominator;
    }
public slots:
    void setNumerator(double numerator) {
        if (m_numerator == numerator)
            return;
        m_numerator = numerator;
        emit numeratorChanged(numerator);
    }
    void setDenominator(double denominator) {
        if (m_denominator == denominator)
            return;
        m_denominator = denominator;
        emit denominatorChanged(denominator);
    }
signals:
    void numeratorChanged(double numerator);
    void denominatorChanged(double denominator);
private:
    double m_numerator;
    double m_denominator;
};

can be simplified to:

L_BEGIN_CLASS(Fraction)
L_RW_PROP(double, numerator, setNumerator)
L_RW_PROP(double, denominator, setDenominator)
L_END_CLASS

I'm sure there are other similar approaches out there, but if you need it, you can simply add this repo as a submodule like I do: https://github.com/carlonluca/lqtutils.

Bye! ;-)