QMetaEnum and strong typed enum - c++

Question

With plain enums I was able to access Q_ENUMS properties and specific, the character represenation of enums, with following code:
// in .h
class EnumClass : public QObject
{
Q_OBJECT
public:
enum MyEnumType { TypeA, TypeB };
Q_ENUMS(MyEnumType)
private:
MyEnumType m_type;
};
// in .cpp
m_type = TypeA;
...
const QMetaObject &mo = EnumClass::staticMetaObject;
int index = mo.indexOfEnumerator("MyEnumType");
QMetaEnum metaEnum = mo.enumerator(index);
QString enumString = metaEnum.valueToKey(m_type); // contains "TypeA"
If I want to use the c++11 feature for strong typed enums like
enum class MyEnumType { TypeA, TypeB };
accessing the meta information does not work anymore. I guess, that Qt does not recognize it as an enum anymore.
Is there any solution to access the character represenation of an enum while using strong typed enums?

Answer 1

Q_ENUMS is obsolete, and Q_ENUM should be used instead, but the following code works for me with either of them (Qt 5.5, your issue might be caused by an old Qt version; also this question is relevant):
.h:
#include <QObject>
class EnumClass : public QObject
{
Q_OBJECT
public:
enum class MyEnumType { TypeA, TypeB };
EnumClass();
Q_ENUM(MyEnumType)
private:
MyEnumType m_type;
};
.cpp:
#include <QDebug>
#include <QMetaEnum>
#include <QMetaObject>
EnumClass::EnumClass()
{
m_type = MyEnumType::TypeA;
const QMetaObject &mo = EnumClass::staticMetaObject;
int index = mo.indexOfEnumerator("MyEnumType");
QMetaEnum metaEnum = mo.enumerator(index);
// note the explicit cast:
QString enumString = metaEnum.valueToKey(static_cast<int>(m_type));
qDebug() << enumString;
}
main:
int main()
{
EnumClass asd;
return 0;
}
output:
"TypeA"

Answer 2

You can use Q_ENUM macro and template with QMetaEnum:
in.h:
#pragma once
#include <QObject>
#include <QString>
#include <QMetaEnum>
template<typename T>
QString enumToString(T value)
{
int castValue = static_cast<int>(value);
return QMetaEnum::fromType<T>().valueToKey(castValue);
}
class Enum : public QObject
{
Q_OBJECT
public:
enum class Color {
NO_COLOR = 0,
RED,
GREEN,
BLUE,
};
Q_ENUM(Color)
Enum();
Enum(Color color);
QString toString();
private:
Color m_value {Color::NO_COLOR};
};
in.cpp:
#include "in.h"
Enum::Enum()
{
}
Enum::Enum(Color color = Color::NO_COLOR) : m_value(color)
{
}
QString Enum::toString()
{
return enumToString(m_value);
}
main.cpp
#include "in.h"
#include <QDebug>
int main()
{
Enum none;
Enum red(Enum::Color::RED);
Enum green(Enum::Color::GREEN);
Enum blue(Enum::Color::BLUE);
qDebug() << none.toString();
qDebug() << red.toString() << green.toString() << blue.toString();
return 0;
}
output:
"NO_COLOR"
"RED" "GREEN" "BLUE"

Answer 3

When using enum class , cast the type to int in valueToKey():
For a QObject class , we ca directly use QMetaEnum , this direct approach should and actually works, both getting key and value ; tested Qt_5_10
declaration:
class EnumClass : public QObject
{
Q_OBJECT
public:
enum class MyEnumType { TypeA, TypeB };
Q_ENUM(MyEnumType)
...
};
Usage:
QMetaEnum metaEnum = QMetaEnum::fromType<EnumClass::MyEnumType>();
qDebug() << metaEnum.valueToKey(static_cast<int>(EnumClass::MyEnumType::TypeA));
qDebug() << metaEnum.keyToValue("TypeB");
...
result :
"TypeA"
1