Meta-type id of an object

? Offline

Hi! Your function void QMpiNode::send(const QMpiMessage * message, bool synchronous) seems to be the place where you want to serialize message into payload, right? Why can't message do it by itself? like QByteArray QMpiMessage::serialize() const?

Chris Kawa

Q_DECLARE_METATYPE only registers a type in meta type system. It's not enough to get reflection features out of a type this way (it does not create a QMetaObject), so for the thing to be useful at all you need at least Q_GADGET in both base and derived classes.

Assuming base and derived are Q_GADGETs you want to get a static member (staticMetaObject) of a derived class having only a pointer to the base class. The only way to go "up" in the inheritance chain in c++, when you don't know types at compile time, is via virtualization, and since Q_GADGET does not provide any, you need to provide it yourself (pretty much one of the things Q_OBJECT does).

For example:

#define FOO Q_GADGET \
public : \
virtual const QMetaObject* metaObject() { return &staticMetaObject; }

class Base
{
    FOO
};

class Derived : public Base
{
    FOO
};

With this you can introspect both derived and base like this:

Base* ptr = new Derived();
qDebug() << ptr->metaObject()->className(); //prints "Derived"
qDebug() << ptr->metaObject()->superClass()->className(); //prints "Base"

kshegunov

Hello,
I most certainly was not expecting such interest, based on my other questions, and so much good advice. I want to thank you in advance, before going in to respond in turn to each of you.

@Wieland

Your function void QMpiNode::send(const QMpiMessage * message, bool synchronous) seems to be the place where you want to serialize message into payload, right?

This is exactly correct. I'm planing to serialize the message inside the send function.

Why can't message do it by itself? like QByteArray QMpiMessage::serialize() const?

It will, and it should, since as far as I can see there's no other way to delegate the responsibility through the inherited classes, and naturally the base class couldn't possibly know how to serialize the derived classes' data. I actually think of implementing a "virtual stream operator" of sorts, something like this:

QDataStream & operator << (QDataStream & stream, QMpiMessage & message)
{
    stream << messageTypeId; //< This is why I want to retrieve the meta-type id for the QMpiMessage derived classes.
    message.serialize(stream);
}

where one'd have virtual void QMpiMessage::serialize(QDataStream &) const = 0 in the base class.

@Chris-Kawa

Q_DECLARE_METATYPE only registers a type in meta type system. It's not enough to get reflection features out of a type this way (it does not create a QMetaObject), so for the thing to be useful at all you need at least Q_GADGET in both base and derived classes.

You're right of course, it seems I wasn't much thinking when I wrote the post ... :|

Assuming base and derived are Q_GADGETs you want to get a static member (staticMetaObject) of a derived class having only a pointer to the base class. The only way to go "up" in the inheritance chain in c++, when you don't know types at compile time, is via virtualization, and since Q_GADGET does not provide any, you need to provide it yourself (pretty much one of the things Q_OBJECT does).

Right, so what about making my own macro instead that shouldn't even depend on Q_GADGET that'd do the virtual's overriding? Something like this:

#define MPI_MESSAGE(ClassName) \
    virtual int metaTypeId() const {  return qMetaTypeId<ClassName>(); }

class MyMpiMessage : public QMpiMessage
{
    MPI_MESSAGE(MyMpiMessage)
}

With the understanding that all of QMpiMessage descendants must be declared with the meta-type system? This would also allow me to not worry about the base class being passed as a pointer. Additionally, It will permit to change the send() prototype to:

void QMpiNode::send(const QMpiMessage &, bool synchronous = false);

and leave the user to worry about memory management of the messages?

Thanks again guys for the input!
Kind regards.

? Offline

@kshegunov said:

#define MPI_MESSAGE(ClassName)
virtual int metaTypeId() const { return qMetaTypeId<ClassName>(); }

This won't work because you can't use qMetaTypeId<>() before Q_DECLARE_METATYPE<>. Thus you need to use the runtime check QMetaType::type(). The following should work:

#define xstr(s) stringify(s)
#define stringify(s) #s
#define MPI_MESSAGE(ClassName) \
    virtual int metaTypeId() const { return QMetaType::type( stringify(ClassName) ); }

Note that you also have to call qRegisterMetaType<MyMpiMessage>(); before you use the function the first time (you'd usually do it in main.cpp).

kshegunov

@Wieland
I don't understand. The macro will be expanded before compilation and will generate the virtual override for the method. Said override will not be called until the program is run and the meta-type id is actually needed (in the QMpiNode::send() function). So I don't see a reason why a function call would be made before the Q_DECLARE_METATYPE macro expansion.

Note that you also have to call qRegisterMetaType<MyMpiMessage>(); before you use the function the first time (you'd usually do it in main.cpp).

I believe qMetaTypeId<MyMpiMessage>() automatically registers the template argument with the runtime, but I might be wrong. I'll have to check.

Kind regards.

? Offline

qMetaTypeId will break the compilation if used before Q_DECLARE_METATYPE. I tested it before I posted my reply to avoid talking bullsh.. :-)

qmpimessage.h

#ifndef QMPIMESSAGE_H
#define QMPIMESSAGE_H

#include <QString>

#define xstr(s) stringify(s)
#define stringify(s) #s
#define MPI_MESSAGE(ClassName) \
    virtual int metaTypeId() const { return QMetaType::type( stringify(ClassName) ); }

class QMpiMessage
{
public:
    QMpiMessage();

    virtual QString sayHi() const;
};

#endif // QMPIMESSAGE_H

qpimessage.cpp

#include "qmpimessage.h"

QMpiMessage::QMpiMessage()
{
}

QString QMpiMessage::sayHi() const
{
    return "base";
}

mympimessage.h

#ifndef MYMPIMESSAGE_H
#define MYMPIMESSAGE_H

#include <QMetaType>
#include "qmpimessage.h"

class MyMpiMessage : public QMpiMessage
{
public:
    MPI_MESSAGE(MyMpiMessage)
    MyMpiMessage();
    QString sayHi() const;
};

Q_DECLARE_METATYPE(MyMpiMessage)

#endif // MYMPIMESSAGE_H

mympimessage.cpp

#include "mympimessage.h"

MyMpiMessage::MyMpiMessage()
    : QMpiMessage()
{
}

QString MyMpiMessage::sayHi() const
{
    return "derived";
}

main.cpp

#include <QApplication>
#include <QDebug>
#include "mympimessage.h"

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

    qRegisterMetaType<MyMpiMessage>();

    MyMpiMessage mmm;
    qDebug() << mmm.sayHi();
    qDebug() << mmm.metaTypeId();
    qDebug() << qMetaTypeId<MyMpiMessage>();

    return 0;
}

kshegunov

@Wieland
Damn! You're obviously right and I think the Q_DECL_CONSTEXPR is the reason for this somewhat curious behavior:

template <typename T>
inline Q_DECL_CONSTEXPR int qMetaTypeId();

Although, I think your macro could be simplified a bit (unless I'm completely clueless again):

#define MPI_MESSAGE(ClassName) \
    virtual int metaTypeId() const { return QMetaType::type("##ClassName##"); }

Note that you also have to call qRegisterMetaType<MyMpiMessage>();

This also makes much more sense to me now ...

? Offline

@kshegunov said:

Although, I think your macro could be simplified a bit

This might be true. To be honest, I have a cheat book for preprocessor magic because I find it too hard to make things right without. ;-)

kshegunov

@Wieland said:

This might be true. To be honest, I have a cheat book for preprocessor magic because I find it too hard to make things right without.

One of the reasons I hate macros in the first place, they expand and reexpand themselves endlessly it seems ... :D

kshegunov

Well, just letting you know that Chris' suggestion seems the most painless way to do the thing I need, so I'm going with it.
Thanks all!