Custom Containers & Inheritance about qtjsonserializer HOT 6 CLOSED

class Foobar
{
    Q_GADGET

    Q_PROPERTY(QString Name MEMBER Name)

public:
    QString Name;
};
Q_DECLARE_METATYPE(Foobar)

class FoobarList : public QList<Foobar>
{
    Q_GADGET

public:
    static void registerMetaType()
    {
        QtJsonSerializer::JsonSerializer::registerListConverters<Foobar>();
    }

    FoobarList(const QList<Foobar> &a = QList<Foobar>())
        : QList(a)
    {}
};
Q_DECLARE_METATYPE(FoobarList)

namespace
{
    void registerMetaType()
    {
        FoobarList::registerMetaType();
    }
} // namespace
Q_COREAPP_STARTUP_FUNCTION(registerMetaType)

#define JSON_PRINT(x) QJsonDocument(x).toJson().constData()

QtJsonSerializer::JsonSerializer s;

FoobarList a;

// populating
for (int i = 0; i < 3; ++i)
{
    a.append(Foobar{
        .Name = QString("Foo%1").arg(i, 4, 10, QLatin1Char('0')),
    });
}

auto printDebug = [&s](const FoobarList &o, const QString &typeName) {
    qDebug() << typeName << o.length() << JSON_PRINT(s.serialize(o));

    for (int i = 0; i < o.length(); ++i)
        qDebug() << QString("%1: %2").arg(i).arg(o.at(i).Name);
};

{ // QVariant
    QVariant v;
    v.setValue(a);
    FoobarList o = v.value<FoobarList>();
    printDebug(o, "QVariant"); // success
}

{ // QtJsonSerializer
    FoobarList o = s.deserialize<FoobarList>(s.serialize(a));
    printDebug(o, "QtJsonSerializer"); // failure
}

class FoobarListConverter : public QtJsonSerializer::TypeConverter
{
    Q_GADGET

public:
    QByteArray name() const override
    {
        return staticMetaObject.className();
    }
    QCborTag tag() const
    {
        static QCborTag r(QCborValue::fromVariant(QVariant::fromValue(FoobarList())).tag());
        return r;
    }
    bool canConvert(int metaTypeId) const override
    {
        return metaTypeId == qMetaTypeId<FoobarList>();
    }
    QList<QCborValue::Type> allowedCborTypes(int metaTypeId, QCborTag tag) const override
    {
        Q_UNUSED(metaTypeId)
        Q_UNUSED(tag)
        return {QCborValue::Array};
    }
    QCborValue serialize(int propertyType, const QVariant &value) const override
    {
        QCborArray r;

        for (const auto &v : value.value<FoobarList>())
        {
            // we know Foobar is properly serialized, so let's make use of that
            r.append(helper()->serializeSubtype(qMetaTypeId<Foobar>(), QVariant::fromValue(v)));
        }

        // add extra for the sake of it
        r.append(helper()->serializeSubtype(qMetaTypeId<Foobar>(), QVariant::fromValue(Foobar{
            .Name = "FoobarListConverter's Visit Card",
            .Text = "It reads: \"FoobarListConverter was here.\"",
        })));
        
        return QCborValue(r);
    }
    QVariant deserializeCbor(int propertyType, const QCborValue &value, QObject *parent) const override
    {
        Q_UNUSED(propertyType)
        Q_UNUSED(parent)

        qDebug() << "deserializeCbor" << value.type() << value;

        FoobarList r;

        for (const auto &v : value.toArray())
        {
            r.append(helper()->deserializeSubtype(qMetaTypeId<Foobar>(), v, nullptr).value<Foobar>());
        }

        return QVariant::fromValue(r);
    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QtJsonSerializer::JsonSerializer s;
    /**
    * I have to keep in mind addJsonTypeConverter
    * that is NOT a global register.
    * 
    * Might need a global instance of the serializer
    * for this.
    */
    s.addJsonTypeConverter<FoobarListConverter>();

    FoobarList a;
    a.append(Foobar{
        .Name = "My Name!",
    });

    /**
     * The method QtJsonSerializer::JsonSerializer::serialize
     * always seems to return a QJsonObject for some reason
     * despite the documentation stating otherwise and returning
     * a QJsonValue, not a QJsonObject. Is the QJsonValue wrapped
     * the QJsonObject itself? It seemed empty.
     *
     * To add to the issue, QtJsonSerializer::JsonSerializer::deserialize
     * also only accepts QObjects which is very odd considering that once
     * again, the document tell us that it accept a QJsonValue.
     *
     * Doc: https://skycoder42.github.io/QtJsonSerializer/class_qt_json_serializer_1_1_json_serializer.html#adde044d01cf8e1705ee672562495ad6f
     */
    auto i = s.serialize(a); // ALWAYS recover a QJsonObject no matter what I do
    qDebug() << "Is the object empty?" << i.isEmpty();
    
    /**
     * This method work.
     */
    auto j = s.serializeGeneric(QVariant::fromValue(a)); // recover QJsonValue which contains QJsonArray
    qDebug() << "QJsonArray" << JSON_PRINT(std::get<QJsonValue>(j).toArray());

    auto b = s.deserialize(std::get<QJsonValue>(j).toArray(), qMetaTypeId<FoobarList>()).value<FoobarList>(); // HELP
    for (int i = 0; i < b.length(); ++i)
    {
        const auto &v = b.at(i);
        qDebug() << i << v.Name << v.Text << v.Bool;
    }
    return 0;
}

// QJsonArray i = s.serialize(a).toArray(); // doesn't work, always return a QJsonObject 
QJsonValue i = s.serialize(QVariant::fromValue(a)); // works, recover QJsonArray as QJsonValue rather than a QJsonObject that has an immediate conversion to QJsonValue
qDebug() << JSON_PRINT(i.toArray());

// FoobarList k = s.deserialize<FoobarList>(i); // can't take QJsonValue or QJsonArray as parameters; only QJsonObject
FoobarList k = s.deserialize(i, qMetaTypeId<FoobarList>()).value<FoobarList>(); // works, obviously
for (int i = 0; i < k.length(); ++i)
{
    const auto &v = k.at(i);
    qDebug() << i << v.Name << v.Text << v.Bool;
}