Emitting enum class in namespace not working

Palli

I ran into something weird today, maybe someone can explain what is going on.

This is more or less my settup:

my_class.h:

namespace my_namespace {
    enum class my_enum : uint64_t { one, two three};

    class my_class : public QObject
    {
        Q_OBJECT

    signals:
        void EmittMyEnum(my_enum);
    }
}

Then there is a function registerAllOfTheThings that is called from main:

meta_register.h:

#include "my_class.h"
Q_DECLARE_METATYPE(my_namespace ::BathyHint)

void registerAllOfTheThings()
{
    qRegisterMetaType<my_namespace ::BathyHint>();
}

Now when I emit EmittMyEnum it doesn't get emitted between threads. I get this message to the console:

QObject::connect: Cannot queue arguments of type 'my_enum'
(Make sure 'my_enum' is registered using qRegisterMetaType().)

But if I change the Q_DECLARE_METATYPE call to:

namespace my_namespace {
    Q_DECLARE_METATYPE(BathyHint)
}

everything workes fine.

But the thing is, I have done this before:

Q_DECLARE_METATYPE(somenamespace::sometype)

Where sometype is a class or a struct and it workes fine, just doesn't seem to work for enum.

BTW, running on Windows 10, compiling with Visual Studio 2019 and Qt 5.14.1

Christian Ehrlicher

Please show your connect statement. Looks like you're using the old style connect and forgot to add the namespace to your signal - otherwise there would have been a warning about my_namespace ::my_enum and not my_enum. Fix your signal and use the new style connect.

Palli

@Christian-Ehrlicher
The connection is something like this

QObject::connet(my_class_ptr, &my_class::EmittMyEnum,
some_other_class_ptr, &some_other_class::other_class_slot);

But this connection is made in my_namespace , but some_other_class is not in my_namespace.

Christian Ehrlicher

Your code above is not consistent with the enum naming and others. Please provide a minimal, compilable example so we can reproduce the issue.

Palli

@Christian-Ehrlicher

Code: https://github.com/Drllap/EmitEnumFromNamspaceTest

Looks like I was wrong about this working with structs:
MyEnum and MyStruct are metatype declared with:

namespace MyNamespace {
    Q_DECLARE_METATYPE(MyEnum)
    Q_DECLARE_METATYPE(MyStruct)
}

and are successfully sent between threads but MyEnum2, MyStruct2

Q_DECLARE_METATYPE(MyNamespace::MyEnum2)
Q_DECLARE_METATYPE(MyNamespace::MyStruct2)

are not sent between threads.

Then there is another problem, this:

namespace MyNamespace {
    Q_DECLARE_METATYPE(MyEnum)
    Q_DECLARE_METATYPE(MyStruct)
}

doesn't compile on Ubuntu18 with GCC

Christian Ehrlicher

@Palli said in Emitting enum class in namespace not working:

are not sent between threads.

They are, please recheck.

doesn't compile on Ubuntu18 with GCC

Because you use the macro wrong:

If MyStruct is in a namespace, the Q_DECLARE_METATYPE() macro has to be outside the namespace.

This works as expected (and shown in the documentation)


Q_DECLARE_METATYPE(MyNamespace::MyEnum)
Q_DECLARE_METATYPE(MyNamespace::MyEnum2)
Q_DECLARE_METATYPE(MyNamespace::MyStruct)
Q_DECLARE_METATYPE(MyNamespace::MyStruct2)

void MetaRegister::RegisterAllOfTheThings()
{
    qDebug() << "Registering meta type: " << qRegisterMetaType<MyNamespace::MyEnum>();
    qDebug() << "Registering meta type: " << qRegisterMetaType<MyNamespace::MyEnum2>();
    qDebug() << "Registering meta type: " << qRegisterMetaType<MyNamespace::MyStruct>();
    qDebug() << "Registering meta type: " << qRegisterMetaType<MyNamespace::MyStruct2>();
}

Palli

@Christian-Ehrlicher

They are, please recheck.

I did, and they are not.

Because you use the macro wrong:

I know I'm using the macro wrong, but it is the only way I have found to get the signaling between threads to work.

Q_DECLARE_METATYPE(MyNamespace::MyEnum)
Q_DECLARE_METATYPE(MyNamespace::MyEnum2)
Q_DECLARE_METATYPE(MyNamespace::MyStruct)
Q_DECLARE_METATYPE(MyNamespace::MyStruct2)

void MetaRegister::RegisterAllOfTheThings()
{
qDebug() << "Registering meta type: " << qRegisterMetaTypeMyNamespace::MyEnum();
qDebug() << "Registering meta type: " << qRegisterMetaTypeMyNamespace::MyEnum2();
qDebug() << "Registering meta type: " << qRegisterMetaTypeMyNamespace::MyStruct();
qDebug() << "Registering meta type: " << qRegisterMetaTypeMyNamespace::MyStruct2();
}

If I use this code above, I get this:
alt text

Christian Ehrlicher

Please push the code with my changes so others can test it

Palli

@Christian-Ehrlicher Done

Christian Ehrlicher

Ah, you still forget to fully qualify the enums in the slots as I said in my first post. I did this locally.

Palli

@Christian-Ehrlicher

I don't quite follow, are you talking about in the Receiver class?

class Receiver : public QObject
{
    Q_OBJECT

    public slots:
        void OnGettingEnum(MyNamespace::MyEnum e) {
            qDebug() << "Received on thread: " << QThread::currentThread();
            qDebug() << "Got the MyEnum: " << static_cast<int>(e);
        }
        void OnGettingEnum2(MyNamespace::MyEnum2 e) {
            qDebug() << "Received on thread: " << QThread::currentThread();
            qDebug() << "Got the MyEnum2: " << static_cast<int>(e);
        }
        void OnGettingStruct(MyNamespace::MyStruct s) {
            qDebug() << "Received on thread: " << QThread::currentThread();
            qDebug() << "Got the MyStruct";
        }
        void OnGettingStruct2(MyNamespace::MyStruct2 s) {
            qDebug() << "Received on thread: " << QThread::currentThread();
            qDebug() << "Got the MyStruct2";
        }
};

Palli

@Christian-Ehrlicher

Ok, you are talking about the signals in the Sender class?

Changing this

    class Sender : public QObject
    {
        Q_OBJECT
    signals:
        void EmitEnum(MyEnum);
        void EmitEnum2(MyEnum2);
        void EmitStruct(MyStruct);
        void EmitStruct2(MyStruct2);
    };

to this

    class Sender : public QObject
    {
        Q_OBJECT
    signals:
        void EmitEnum(MyNamespace::MyEnum);
        void EmitEnum2(MyNamespace::MyEnum2);
        void EmitStruct(MyNamespace::MyStruct);
        void EmitStruct2(MyNamespace::MyStruct2);
    };

fixes it.

Christian Ehrlicher

@Palli said in Emitting enum class in namespace not working:

Ok, you are talking about the signals in the Sender class?

Yes:

forgot to add the namespace to your signal - otherwise there would have been a warning about my_namespace ::my_enum and not my_enum.

Please mark the topic as solved then.

Palli

@Christian-Ehrlicher Done, thanks for you help