Convert an instance of QObject to JSON

Question

I have some code that I am using to convert arbitrary QObject subclasses to JSON. I able to convert them if they are pointers to a subclass, but am curious whether it is possible to convert instances (provided the subclass implements a copy constructor). Is there some crazy way to use something like templates or the type information provided by QMetaType to copy an instance of a QObject subclass without knowing what it is? The ToJson code is in a class that has no knowledge of the subclass.

I think it might be possible with QMetaType::create or something similar but I haven't been able to figure out how to actually copy the properties of the subclass instance.

Here's my code for converting:

QJsonValue ToJson(QVariant value){
    switch(value.type()){
    case QVariant::Int:
    case QVariant::Double:
        return value.toDouble();

    ////Other cases, etc...
    case QVariant::UserType:
        QObject* obj_ptr = qvariant_cast<QObject*>(value);
        if(obj_ptr) // value was originally a pointer to a QObject, works correctly
            return ToJson(obj_ptr);
        else { // value was orginally an instance of a QObject subclass
            std::string t = value.typeName(); //returns "MyQObject"
            int id = QMetaType::type(t.c_str()); //returns the id of the derived class
            void* v = QMetaType::create(id, &value); //passing &value does nothing
            obj_ptr = static_cast<QObject*>(v);
            return ToJson(obj_ptr); //works, but resulting fields are all default 
        }
    }
}

QJsonObject ToJson(QObject* o){
    QJsonObject obj;

    auto mo = o->metaObject();
    for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i){
        QVariant value = o->property(mo->property(i).name());
        obj[mo->property(i).name()] = ToJson(value);
    }
    return obj;
}

Sample code use case:

qRegisterMetaType<MyQObject>();
MyQObject obj;
obj.db = 11.1;

QVariant test1 = QVariant::fromValue(obj);
QVariant test2 = QVariant::fromValue(&obj);
QJsonValue v1 = ToJson(test1);  // default constructed values
QJsonValue v2 = ToJson(test2);  // db = 11.1

Sample QObject subclass:

class MyQObject : public QObject {
    Q_OBJECT
    Q_PROPERTY(double DB MEMBER db)
    Q_PROPERTY(int I MEMBER i)
    public:
        MyQObject();
        MyQObject(const MyQObject& other) : QObject() { 
            i = other.i;
            db = other.db;
        }
        int i = 50;
        double db = 1.5;
};
Q_DECLARE_METATYPE(MyQObject)

Is there any way to handle the case illustrated by test1 above?

Answer 1

Long-story-short: nope. There is no way to store QObjects by value in containers or QVariant.

Qt forbids the copy of QObjects and all inheriting classes. The mandatory the Q_OBJECT macro will disable any copy constructor also in newly defined classes.

The copy constructor that you are defining in the MyObject class is missing the base class constructor call. If QObject had a copy constructor it would be something like this:

MyQObject(const MyQObject& other) :
    QObject(other) // this will NEVER compile
{ 
   i = other.i;
   db = other.db;
}

Probably, the compiler is giving you a warning, but allows you to have such a constructor, even if it will result in undefined behavior or slicing an instance of MyObject every time it is passed by value.

Furthermore, the Qt docs states the following:

The values stored in the various containers can be of any assignable data type. To qualify, a type must provide a default constructor, a copy constructor, and an assignment operator. This covers most data types you are likely to want to store in a container, including basic types such as int and double, pointer types, and Qt data types such as QString, QDate, and QTime, but it doesn't cover QObject or any QObject subclass (QWidget, QDialog, QTimer, etc.).

So you can't store QObject and derived classes inside a Qt container unless you store them as pointers, as copy of QObjects is disabled by design.

Furthermore, if you want to exploit polymorphic behavior you must use pointers, even if there is no explicit need to cast to derived classes in your code, as far as I can see. If you really need to resort to casting in some place, you could consider making your ToJson a template function.

Answer 2

There is a solution, but use caution as it is only reasonable/applicable in the following scenario:

• Classes in question are primarily data storage classes
• The classes in question would be entirely copy-able if they didn't inherit from QObject
• Most importantly, the ONLY reason you have the class inherit from QObject is so that it can have meta properties.

If your code uses the class as a QObject for any reason other than to get meta information, you are almost certainly using it incorrectly if you are trying to store it by value (as explained by G. Giordano in their answer).

Misuse considerations aside, in order to JSON-ify a QVariant that stores a QObject subclass by value, you can use the QMetaType::create method and pass it the user type id and yourQVariant.constData().

Example:

MyQObject obj;
obj.db = 11.1;
QVariant value = QVariant::fromValue(obj);

std::string t = value.typeName();
int id = QMetaType::type(t.c_str());
void* v = QMetaType::create(id, value.constData());
obj_ptr = static_cast<QObject*>(v);
QJsonValue json = ToJson(obj_ptr); //json contains db = 11.1