diff options
Diffstat (limited to 'sources/shiboken6/ApiExtractor')
21 files changed, 538 insertions, 322 deletions
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp index d84aa0f37..da086053e 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp @@ -73,7 +73,6 @@ AbstractMetaBuilderPrivate::AbstractMetaBuilderPrivate() : AbstractMetaBuilderPrivate::~AbstractMetaBuilderPrivate() { - qDeleteAll(m_globalEnums); qDeleteAll(m_globalFunctions); qDeleteAll(m_templates); qDeleteAll(m_smartPointers); @@ -115,11 +114,15 @@ const AbstractMetaEnumList &AbstractMetaBuilder::globalEnums() const return d->m_globalEnums; } -AbstractMetaEnum *AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const +std::optional<AbstractMetaEnum> + AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const { if (typeEntry && typeEntry->isFlags()) typeEntry = static_cast<const FlagsTypeEntry *>(typeEntry)->originator(); - return d->m_enums.value(typeEntry); + const auto it = d->m_enums.constFind(typeEntry); + if (it == d->m_enums.constEnd()) + return {}; + return it.value(); } void AbstractMetaBuilderPrivate::checkFunctionModifications() @@ -401,10 +404,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) ReportHandler::startProgress("Generating enum model (" + QByteArray::number(enums.size()) + ")..."); for (const EnumModelItem &item : enums) { - AbstractMetaEnum *metaEnum = traverseEnum(item, nullptr, QSet<QString>()); - if (metaEnum) { + auto metaEnum = traverseEnum(item, nullptr, QSet<QString>()); + if (metaEnum.has_value()) { if (metaEnum->typeEntry()->generateCode()) - m_globalEnums << metaEnum; + m_globalEnums << metaEnum.value(); } } @@ -529,7 +532,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses, name); const bool enumFound = cls - ? cls->findEnum(entry->targetLangEntryName()) != nullptr + ? cls->findEnum(entry->targetLangEntryName()).has_value() : m_enums.contains(entry); if (!enumFound) { @@ -629,8 +632,8 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) ReportHandler::endProgress(); } -static bool metaEnumLessThan(const AbstractMetaEnum *e1, const AbstractMetaEnum *e2) -{ return e1->fullName() < e2->fullName(); } +static bool metaEnumLessThan(const AbstractMetaEnum &e1, const AbstractMetaEnum &e2) +{ return e1.fullName() < e2.fullName(); } static bool metaClassLessThan(const AbstractMetaClass *c1, const AbstractMetaClass *c2) { return c1->fullName() < c2->fullName(); } @@ -768,9 +771,10 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel return metaClass; } -AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem, - AbstractMetaClass *enclosing, - const QSet<QString> &enumsDeclarations) +std::optional<AbstractMetaEnum> + AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem, + AbstractMetaClass *enclosing, + const QSet<QString> &enumsDeclarations) { QString qualifiedName = enumItem->qualifiedName().join(colonColon()); @@ -806,7 +810,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & if (typeEntry) typeEntry->setCodeGeneration(TypeEntry::GenerateNothing); m_rejectedEnums.insert(qualifiedName + rejectReason, AbstractMetaBuilder::GenerationDisabled); - return nullptr; + return {}; } const bool rejectionWarning = !enclosing || enclosing->typeEntry()->generateCode(); @@ -815,7 +819,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & if (rejectionWarning) qCWarning(lcShiboken, "%s", qPrintable(msgNoEnumTypeEntry(enumItem, className))); m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem); - return nullptr; + return {}; } if (!typeEntry->isEnum()) { @@ -824,28 +828,28 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & qPrintable(msgNoEnumTypeConflict(enumItem, className, typeEntry))); } m_rejectedEnums.insert(qualifiedName, AbstractMetaBuilder::NotInTypeSystem); - return nullptr; + return {}; } - auto *metaEnum = new AbstractMetaEnum; - metaEnum->setEnumKind(enumItem->enumKind()); - metaEnum->setSigned(enumItem->isSigned()); + AbstractMetaEnum metaEnum; + metaEnum.setEnumKind(enumItem->enumKind()); + metaEnum.setSigned(enumItem->isSigned()); if (enumsDeclarations.contains(qualifiedName) || enumsDeclarations.contains(enumName)) { - metaEnum->setHasQEnumsDeclaration(true); + metaEnum.setHasQEnumsDeclaration(true); } auto *enumTypeEntry = static_cast<EnumTypeEntry *>(typeEntry); - metaEnum->setTypeEntry(enumTypeEntry); + metaEnum.setTypeEntry(enumTypeEntry); switch (enumItem->accessPolicy()) { case CodeModel::Public: - *metaEnum += AbstractMetaAttributes::Public; + metaEnum += AbstractMetaAttributes::Public; break; case CodeModel::Protected: - *metaEnum += AbstractMetaAttributes::Protected; + metaEnum += AbstractMetaAttributes::Protected; break; case CodeModel::Private: - *metaEnum += AbstractMetaAttributes::Private; + metaEnum += AbstractMetaAttributes::Private; typeEntry->setCodeGeneration(TypeEntry::GenerateNothing); break; default: @@ -855,21 +859,19 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & const EnumeratorList &enums = enumItem->enumerators(); for (const EnumeratorModelItem &value : enums) { - auto *metaEnumValue = new AbstractMetaEnumValue; - metaEnumValue->setName(value->name()); + AbstractMetaEnumValue metaEnumValue; + metaEnumValue.setName(value->name()); // Deciding the enum value... - metaEnumValue->setStringValue(value->stringValue()); - metaEnumValue->setValue(value->value()); - metaEnum->addEnumValue(metaEnumValue); + metaEnumValue.setStringValue(value->stringValue()); + metaEnumValue.setValue(value->value()); + metaEnum.addEnumValue(metaEnumValue); } - m_enums.insert(typeEntry, metaEnum); - - if (!metaEnum->typeEntry()->include().isValid()) - setInclude(metaEnum->typeEntry(), enumItem->fileName()); + if (!metaEnum.typeEntry()->include().isValid()) + setInclude(metaEnum.typeEntry(), enumItem->fileName()); - metaEnum->setOriginalAttributes(metaEnum->attributes()); + metaEnum.setOriginalAttributes(metaEnum.attributes()); // Register all enum values on Type database const bool isScopedEnum = enumItem->enumKind() == EnumClass; @@ -884,6 +886,9 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & enumTypeEntry->setNullValue(enumValue); } + metaEnum.setEnclosingClass(enclosing); + m_enums.insert(typeEntry, metaEnum); + return metaEnum; } @@ -1448,10 +1453,9 @@ void AbstractMetaBuilderPrivate::traverseEnums(const ScopeModelItem &scopeItem, const EnumList &enums = scopeItem->enums(); const QSet<QString> enumsDeclarationSet(enumsDeclarations.cbegin(), enumsDeclarations.cend()); for (const EnumModelItem &enumItem : enums) { - AbstractMetaEnum* metaEnum = traverseEnum(enumItem, metaClass, enumsDeclarationSet); - if (metaEnum) { - metaClass->addEnum(metaEnum); - metaEnum->setEnclosingClass(metaClass); + auto metaEnum = traverseEnum(enumItem, metaClass, enumsDeclarationSet); + if (metaEnum.has_value()) { + metaClass->addEnum(metaEnum.value()); } } } @@ -2321,14 +2325,15 @@ qint64 AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringV return 0; } - AbstractMetaEnumValue *enumValue = AbstractMetaClass::findEnumValue(m_metaClasses, stringValue); - if (enumValue) { + auto enumValue = AbstractMetaClass::findEnumValue(m_metaClasses, stringValue); + if (enumValue.has_value()) { ok = true; return enumValue->value().value(); } - for (AbstractMetaEnum *metaEnum : qAsConst(m_globalEnums)) { - if (const AbstractMetaEnumValue *ev = metaEnum->findEnumValue(stringValue)) { + for (const AbstractMetaEnum &metaEnum : qAsConst(m_globalEnums)) { + auto ev = metaEnum.findEnumValue(stringValue); + if (ev.has_value()) { ok = true; return ev->value().value(); } diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h index 09c49b4fb..a11f2ec4f 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.h @@ -37,6 +37,8 @@ #include <QFileInfoList> +#include <optional> + QT_FORWARD_DECLARE_CLASS(QIODevice) class AbstractMetaBuilderPrivate; @@ -68,7 +70,7 @@ public: const AbstractMetaClassList &smartPointers() const; const AbstractMetaFunctionList &globalFunctions() const; const AbstractMetaEnumList &globalEnums() const; - AbstractMetaEnum *findEnum(const TypeEntry *typeEntry) const; + std::optional<AbstractMetaEnum> findEnum(const TypeEntry *typeEntry) const; /** * Sorts a list of classes topologically. diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h index 948593766..b943ad628 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h +++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h @@ -92,8 +92,9 @@ public: bool setupInheritance(AbstractMetaClass *metaClass); AbstractMetaClass *traverseNamespace(const FileModelItem &dom, const NamespaceModelItem &item); - AbstractMetaEnum *traverseEnum(const EnumModelItem &item, AbstractMetaClass *enclosing, - const QSet<QString> &enumsDeclarations); + std::optional<AbstractMetaEnum> traverseEnum(const EnumModelItem &item, + AbstractMetaClass *enclosing, + const QSet<QString> &enumsDeclarations); void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent, const QStringList &enumsDeclarations); AbstractMetaFunctionList classFunctionList(const ScopeModelItem &scopeItem, @@ -204,7 +205,7 @@ public: RejectMap m_rejectedFunctions; RejectMap m_rejectedFields; - QHash<const TypeEntry *, AbstractMetaEnum *> m_enums; + QHash<const TypeEntry *, AbstractMetaEnum> m_enums; QVector<NamespaceModelItem> m_scopes; diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp index 5075836d3..0f1470272 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.cpp @@ -27,103 +27,284 @@ ****************************************************************************/ #include "abstractmetaenum.h" +#include "abstractmetalang.h" +#include "documentation.h" #include "typesystem.h" +#include "parser/enumvalue.h" #include <QtCore/QDebug> -AbstractMetaEnum::AbstractMetaEnum() : - m_hasQenumsDeclaration(false), m_signed(true) +class AbstractMetaEnumValueData : public QSharedData +{ +public: + QString m_name; + QString m_stringValue; + EnumValue m_value; + Documentation m_doc; +}; + +AbstractMetaEnumValue::AbstractMetaEnumValue() : + d(new AbstractMetaEnumValueData) { } -AbstractMetaEnum::~AbstractMetaEnum() +AbstractMetaEnumValue::AbstractMetaEnumValue(const AbstractMetaEnumValue &) = default; +AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(const AbstractMetaEnumValue &) = default; +AbstractMetaEnumValue::AbstractMetaEnumValue(AbstractMetaEnumValue &&) = default; +AbstractMetaEnumValue &AbstractMetaEnumValue::operator=(AbstractMetaEnumValue &&) = default; +AbstractMetaEnumValue::~AbstractMetaEnumValue() = default; + +EnumValue AbstractMetaEnumValue::value() const { - qDeleteAll(m_enumValues); + return d->m_value; } -template <class String> -AbstractMetaEnumValue *findMatchingEnumValue(const AbstractMetaEnumValueList &list, const String &value) +void AbstractMetaEnumValue::setValue(EnumValue value) +{ + if (d->m_value != value) + d->m_value = value; +} + +QString AbstractMetaEnumValue::stringValue() const +{ + return d->m_stringValue; +} + +void AbstractMetaEnumValue::setStringValue(const QString &v) +{ + if (d->m_stringValue != v) + d->m_stringValue = v; +} + +QString AbstractMetaEnumValue::name() const +{ + return d->m_name; +} + +void AbstractMetaEnumValue::setName(const QString &name) +{ + if (d->m_name != name) + d->m_name = name; +} + +Documentation AbstractMetaEnumValue::documentation() const +{ + return d->m_doc; +} + +void AbstractMetaEnumValue::setDocumentation(const Documentation &doc) +{ + if (d->m_doc != doc) + d->m_doc = doc; +} + +// --------------------- AbstractMetaEnum + +class AbstractMetaEnumData : public QSharedData { - for (AbstractMetaEnumValue *enumValue : list) { - if (enumValue->name() == value) +public: + AbstractMetaEnumData() : m_hasQenumsDeclaration(false), m_signed(true) + { + } + + AbstractMetaEnumValueList m_enumValues; + + EnumTypeEntry *m_typeEntry = nullptr; + Documentation m_doc; + + EnumKind m_enumKind = CEnum; + uint m_hasQenumsDeclaration : 1; + uint m_signed : 1; +}; + +AbstractMetaEnum::AbstractMetaEnum() : d(new AbstractMetaEnumData) +{ +} + +AbstractMetaEnum::AbstractMetaEnum(const AbstractMetaEnum &) = default; +AbstractMetaEnum &AbstractMetaEnum::operator=(const AbstractMetaEnum&) = default; +AbstractMetaEnum::AbstractMetaEnum(AbstractMetaEnum &&) = default; +AbstractMetaEnum &AbstractMetaEnum::operator=(AbstractMetaEnum &&) = default; +AbstractMetaEnum::~AbstractMetaEnum() = default; + +const AbstractMetaEnumValueList &AbstractMetaEnum::values() const +{ + return d->m_enumValues; +} + +void AbstractMetaEnum::addEnumValue(const AbstractMetaEnumValue &enumValue) +{ + d->m_enumValues << enumValue; +} + +std::optional<AbstractMetaEnumValue> + findMatchingEnumValue(const AbstractMetaEnumValueList &list, QStringView value) +{ + for (const AbstractMetaEnumValue &enumValue : list) { + if (enumValue.name() == value) return enumValue; } - return nullptr; + return {}; } // Find enum values for "enum Enum { e1 }" either for "e1" or "Enum::e1" -AbstractMetaEnumValue *AbstractMetaEnum::findEnumValue(const QString &value) const +std::optional<AbstractMetaEnumValue> + AbstractMetaEnum::findEnumValue(QStringView value) const { if (isAnonymous()) - return findMatchingEnumValue(m_enumValues, value); + return findMatchingEnumValue(d->m_enumValues, value); const int sepPos = value.indexOf(QLatin1String("::")); if (sepPos == -1) - return findMatchingEnumValue(m_enumValues, value); - return name() == QStringView{value}.left(sepPos) - ? findMatchingEnumValue(m_enumValues, QStringView{value}.right(value.size() - sepPos - 2)) - : nullptr; + return findMatchingEnumValue(d->m_enumValues, value); + if (name() == value.left(sepPos)) + return findMatchingEnumValue(d->m_enumValues, value.right(value.size() - sepPos - 2)); + return {}; } QString AbstractMetaEnum::name() const { - return m_typeEntry->targetLangEntryName(); + return d->m_typeEntry->targetLangEntryName(); +} + +QString AbstractMetaEnum::qualifiedCppName() const +{ + return enclosingClass() + ? enclosingClass()->qualifiedCppName() + QLatin1String("::") + name() + : name(); +} + +const Documentation &AbstractMetaEnum::documentation() const +{ + return d->m_doc; +} + +void AbstractMetaEnum::setDocumentation(const Documentation &doc) +{ + if (d->m_doc != doc) + d->m_doc = doc; } QString AbstractMetaEnum::qualifier() const { - return m_typeEntry->targetLangQualifier(); + return d->m_typeEntry->targetLangQualifier(); } QString AbstractMetaEnum::package() const { - return m_typeEntry->targetLangPackage(); + return d->m_typeEntry->targetLangPackage(); +} + +QString AbstractMetaEnum::fullName() const +{ + return package() + QLatin1Char('.') + qualifier() + QLatin1Char('.') + name(); +} + +EnumKind AbstractMetaEnum::enumKind() const +{ + return d->m_enumKind; +} + +void AbstractMetaEnum::setEnumKind(EnumKind kind) +{ + if (d->m_enumKind != kind) + d->m_enumKind = kind; +} + +bool AbstractMetaEnum::isAnonymous() const +{ + return d->m_enumKind == AnonymousEnum; +} + +bool AbstractMetaEnum::hasQEnumsDeclaration() const +{ + return d->m_hasQenumsDeclaration; +} + +void AbstractMetaEnum::setHasQEnumsDeclaration(bool on) +{ + if (d->m_hasQenumsDeclaration != on) + d->m_hasQenumsDeclaration = on; +} + +EnumTypeEntry *AbstractMetaEnum::typeEntry() const +{ + return d->m_typeEntry; +} + +void AbstractMetaEnum::setTypeEntry(EnumTypeEntry *entry) +{ + if (d->m_typeEntry != entry) + d->m_typeEntry = entry; +} + +bool AbstractMetaEnum::isSigned() const +{ + return d->m_signed; +} + +void AbstractMetaEnum::setSigned(bool s) +{ + if (d->m_signed != s) + d->m_signed = s; } #ifndef QT_NO_DEBUG_STREAM -static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue *v) +static void formatMetaEnumValue(QDebug &d, const AbstractMetaEnumValue &v) { - const QString &name = v->stringValue(); + const QString &name = v.stringValue(); if (!name.isEmpty()) d << name << '='; - d << v->value(); + d << v.value(); } -QDebug operator<<(QDebug d, const AbstractMetaEnumValue *v) +QDebug operator<<(QDebug d, const AbstractMetaEnumValue &v) { QDebugStateSaver saver(d); d.noquote(); d.nospace(); d << "AbstractMetaEnumValue("; - if (v) - formatMetaEnumValue(d, v); - else - d << '0'; + formatMetaEnumValue(d, v); d << ')'; return d; } +static void formatMetaEnum(QDebug &d, const AbstractMetaEnum &e) +{ + d << e.fullName(); + if (!e.isSigned()) + d << " (unsigned) "; + d << '['; + const AbstractMetaEnumValueList &values = e.values(); + for (int i = 0, count = values.size(); i < count; ++i) { + if (i) + d << ' '; + formatMetaEnumValue(d, values.at(i)); + } + d << ']'; +} + QDebug operator<<(QDebug d, const AbstractMetaEnum *ae) { QDebugStateSaver saver(d); d.noquote(); d.nospace(); d << "AbstractMetaEnum("; - if (ae) { - d << ae->fullName(); - if (!ae->isSigned()) - d << " (unsigned) "; - d << '['; - const AbstractMetaEnumValueList &values = ae->values(); - for (int i = 0, count = values.size(); i < count; ++i) { - if (i) - d << ' '; - formatMetaEnumValue(d, values.at(i)); - } - d << ']'; - } else { + if (ae) + formatMetaEnum(d, *ae); + else d << '0'; - } + d << ')'; + return d; +} + +QDebug operator<<(QDebug d, const AbstractMetaEnum &ae) +{ + QDebugStateSaver saver(d); + d.noquote(); + d.nospace(); + d << "AbstractMetaEnum("; + formatMetaEnum(d, ae); d << ')'; return d; } diff --git a/sources/shiboken6/ApiExtractor/abstractmetaenum.h b/sources/shiboken6/ApiExtractor/abstractmetaenum.h index 1ee4f61b8..062ed2aaa 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetaenum.h +++ b/sources/shiboken6/ApiExtractor/abstractmetaenum.h @@ -1,4 +1,4 @@ -/**************************************************************************** +/**************************************************************************** ** ** Copyright (C) 2020 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ @@ -31,100 +31,98 @@ #include "abstractmetalang_typedefs.h" #include "abstractmetaattributes.h" -#include "documentation.h" #include "enclosingclassmixin.h" #include "parser/codemodel_enums.h" -#include "parser/enumvalue.h" +#include <QtCore/QSharedDataPointer> #include <QtCore/QString> +#include <optional> + QT_FORWARD_DECLARE_CLASS(QDebug) +class AbstractMetaEnumData; +class AbstractMetaEnumValueData; +class Documentation; +class EnumValue; class EnumTypeEntry; class AbstractMetaEnumValue { public: - AbstractMetaEnumValue() = default; + AbstractMetaEnumValue(); + AbstractMetaEnumValue(const AbstractMetaEnumValue &); + AbstractMetaEnumValue &operator=(const AbstractMetaEnumValue &); + AbstractMetaEnumValue(AbstractMetaEnumValue &&); + AbstractMetaEnumValue &operator=(AbstractMetaEnumValue &&); + ~AbstractMetaEnumValue(); - EnumValue value() const { return m_value; } - void setValue(EnumValue value) { m_value = value; } + EnumValue value() const; + void setValue(EnumValue value); - QString stringValue() const { return m_stringValue; } - void setStringValue(const QString &v) { m_stringValue = v; } + QString stringValue() const; + void setStringValue(const QString &v); - QString name() const { return m_name; } - void setName(const QString &name) { m_name = name; } + QString name() const; + void setName(const QString &name); - Documentation documentation() const { return m_doc; } - void setDocumentation(const Documentation& doc) { m_doc = doc; } + Documentation documentation() const; + void setDocumentation(const Documentation& doc); private: - QString m_name; - QString m_stringValue; - - EnumValue m_value; - - Documentation m_doc; + QSharedDataPointer<AbstractMetaEnumValueData> d; }; class AbstractMetaEnum : public AbstractMetaAttributes, public EnclosingClassMixin { public: AbstractMetaEnum(); + AbstractMetaEnum(const AbstractMetaEnum &); + AbstractMetaEnum &operator=(const AbstractMetaEnum &); + AbstractMetaEnum(AbstractMetaEnum &&); + AbstractMetaEnum &operator=(AbstractMetaEnum &&); ~AbstractMetaEnum(); - const AbstractMetaEnumValueList &values() const { return m_enumValues; } + const AbstractMetaEnumValueList &values() const; + void addEnumValue(const AbstractMetaEnumValue &enumValue); - void addEnumValue(AbstractMetaEnumValue *enumValue) - { - m_enumValues << enumValue; - } - - AbstractMetaEnumValue *findEnumValue(const QString &value) const; + std::optional<AbstractMetaEnumValue> findEnumValue(QStringView value) const; QString name() const; + QString qualifiedCppName() const; - const Documentation &documentation() const { return m_doc; } - void setDocumentation(const Documentation& doc) { m_doc = doc; } + const Documentation &documentation() const; + void setDocumentation(const Documentation& doc); QString qualifier() const; QString package() const; - QString fullName() const - { - return package() + QLatin1Char('.') + qualifier() + QLatin1Char('.') + name(); - } + QString fullName() const; - EnumKind enumKind() const { return m_enumKind; } - void setEnumKind(EnumKind kind) { m_enumKind = kind; } + EnumKind enumKind() const; + void setEnumKind(EnumKind kind); - bool isAnonymous() const { return m_enumKind == AnonymousEnum; } + bool isAnonymous() const; // Has the enum been declared inside a Q_ENUMS() macro in its enclosing class? - bool hasQEnumsDeclaration() const { return m_hasQenumsDeclaration; } - void setHasQEnumsDeclaration(bool on) { m_hasQenumsDeclaration = on; } - - EnumTypeEntry *typeEntry() const { return m_typeEntry; } + bool hasQEnumsDeclaration() const; + void setHasQEnumsDeclaration(bool on); - void setTypeEntry(EnumTypeEntry *entry) { m_typeEntry = entry; } + EnumTypeEntry *typeEntry() const; + void setTypeEntry(EnumTypeEntry *entry); - bool isSigned() const { return m_signed; } - void setSigned(bool s) { m_signed = s; } + bool isSigned() const; + void setSigned(bool s); private: - AbstractMetaEnumValueList m_enumValues; - EnumTypeEntry *m_typeEntry = nullptr; - Documentation m_doc; - - EnumKind m_enumKind = CEnum; - uint m_hasQenumsDeclaration : 1; - uint m_signed : 1; + QSharedDataPointer<AbstractMetaEnumData> d; }; #ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug d, const AbstractMetaEnumValue &ae); QDebug operator<<(QDebug d, const AbstractMetaEnum *ae); +QDebug operator<<(QDebug d, const AbstractMetaEnum &ae); #endif #endif // ABSTRACTMETAENUM_H diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp index f5f8412c8..d7393d82a 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp @@ -28,7 +28,6 @@ #include "abstractmetalang.h" #include "abstractmetalang_helpers.h" -#include "abstractmetaenum.h" #include "abstractmetafunction.h" #include "abstractmetafield.h" #include "modifications.h" @@ -65,7 +64,6 @@ AbstractMetaClass::AbstractMetaClass() AbstractMetaClass::~AbstractMetaClass() { qDeleteAll(m_functions); - qDeleteAll(m_enums); qDeleteAll(m_propertySpecs); } @@ -640,32 +638,37 @@ std::optional<AbstractMetaField> return AbstractMetaField::find(m_fields, name); } -AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName) +std::optional<AbstractMetaEnum> + AbstractMetaClass::findEnum(const QString &enumName) const { - if (AbstractMetaEnum *e = findByName(m_enums, enumName)) - return e; - return nullptr; + for (const auto &e : m_enums) { + if (e.name() == enumName) + return e; + } + return {}; } /*! Recursively searches for the enum value named \a enumValueName in this class and its superclasses and interfaces. */ -AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValueName) +std::optional<AbstractMetaEnumValue> + AbstractMetaClass::findEnumValue(const QString &enumValueName) const { - for (AbstractMetaEnum *e : qAsConst(m_enums)) { - if (AbstractMetaEnumValue *v = e->findEnumValue(enumValueName)) + for (const AbstractMetaEnum &e : qAsConst(m_enums)) { + auto v = e.findEnumValue(enumValueName); + if (v.has_value()) return v; } if (baseClass()) return baseClass()->findEnumValue(enumValueName); - return nullptr; + return {}; } void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const { - for (AbstractMetaEnum *metaEnum : m_enums) { - if (!metaEnum->isPrivate() && metaEnum->typeEntry()->generateCode()) + for (const AbstractMetaEnum &metaEnum : m_enums) { + if (!metaEnum.isPrivate() && metaEnum.typeEntry()->generateCode()) enumList->append(metaEnum); } } @@ -915,8 +918,9 @@ void AbstractMetaClass::fixFunctions() */ -AbstractMetaEnum *AbstractMetaClass::findEnum(const AbstractMetaClassList &classes, - const EnumTypeEntry *entry) +std::optional<AbstractMetaEnum> + AbstractMetaClass::findEnum(const AbstractMetaClassList &classes, + const EnumTypeEntry *entry) { Q_ASSERT(entry->isEnum()); @@ -939,14 +943,15 @@ AbstractMetaEnum *AbstractMetaClass::findEnum(const AbstractMetaClassList &class qCWarning(lcShiboken).noquote().nospace() << QStringLiteral("AbstractMeta::findEnum(), unknown class '%1' in '%2'") .arg(className, entry->qualifiedCppName()); - return nullptr; + return {}; } return metaClass->findEnum(enumName); } -AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassList &classes, - const QString &name) +std::optional<AbstractMetaEnumValue> + AbstractMetaClass::findEnumValue(const AbstractMetaClassList &classes, + const QString &name) { const auto lst = QStringView{name}.split(u"::"); @@ -958,13 +963,14 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassL } for (AbstractMetaClass *metaClass : classes) { - if (AbstractMetaEnumValue *enumValue = metaClass->findEnumValue(name)) + auto enumValue = metaClass->findEnumValue(name); + if (enumValue.has_value()) return enumValue; } qCWarning(lcShiboken).noquote().nospace() << QStringLiteral("no matching enum '%1'").arg(name); - return nullptr; + return {}; } /*! diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h index 111552432..8de86ed2a 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h @@ -31,6 +31,7 @@ #include "abstractmetalang_typedefs.h" #include "abstractmetaattributes.h" +#include "abstractmetaenum.h" #include "abstractmetafield.h" #include "enclosingclassmixin.h" #include "documentation.h" @@ -170,11 +171,12 @@ public: std::optional<AbstractMetaField> findField(const QString &name) const; const AbstractMetaEnumList &enums() const { return m_enums; } + AbstractMetaEnumList &enums() { return m_enums; } void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; } - void addEnum(AbstractMetaEnum *e) { m_enums << e; } + void addEnum(const AbstractMetaEnum &e) { m_enums << e; } - AbstractMetaEnum *findEnum(const QString &enumName); - AbstractMetaEnumValue *findEnumValue(const QString &enumName); + std::optional<AbstractMetaEnum> findEnum(const QString &enumName) const; + std::optional<AbstractMetaEnumValue> findEnumValue(const QString &enumName) const; void getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const; void getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const; @@ -338,10 +340,10 @@ public: const QString &name); static AbstractMetaClass *findClass(const AbstractMetaClassList &classes, const TypeEntry* typeEntry); - static AbstractMetaEnumValue *findEnumValue(const AbstractMetaClassList &classes, - const QString &string); - static AbstractMetaEnum *findEnum(const AbstractMetaClassList &classes, - const EnumTypeEntry *entry); + static std::optional<AbstractMetaEnumValue> findEnumValue(const AbstractMetaClassList &classes, + const QString &string); + static std::optional<AbstractMetaEnum> findEnum(const AbstractMetaClassList &classes, + const EnumTypeEntry *entry); SourceLocation sourceLocation() const; void setSourceLocation(const SourceLocation &sourceLocation); diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h index 88b96cd8e..a79cdbab3 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang_typedefs.h @@ -42,8 +42,8 @@ class AbstractMetaType; using AbstractMetaArgumentList = QVector<AbstractMetaArgument>; using AbstractMetaClassList = QVector<AbstractMetaClass *>; -using AbstractMetaEnumList = QVector<AbstractMetaEnum *>; -using AbstractMetaEnumValueList = QVector<AbstractMetaEnumValue *>; +using AbstractMetaEnumList = QList<AbstractMetaEnum>; +using AbstractMetaEnumValueList = QList<AbstractMetaEnumValue>; using AbstractMetaFieldList = QList<AbstractMetaField>; using AbstractMetaFunctionList = QVector<AbstractMetaFunction *>; using AbstractMetaFunctionCList = QVector<const AbstractMetaFunction *>; diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp index aa552cdd3..a6bdd3edb 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.cpp +++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp @@ -161,7 +161,8 @@ ContainerTypeEntryList ApiExtractor::containerTypes() const return TypeDatabase::instance()->containerTypes(); } -const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const +std::optional<AbstractMetaEnum> + ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const { return m_builder->findEnum(typeEntry); } diff --git a/sources/shiboken6/ApiExtractor/apiextractor.h b/sources/shiboken6/ApiExtractor/apiextractor.h index 3168894e7..f9a33ae60 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.h +++ b/sources/shiboken6/ApiExtractor/apiextractor.h @@ -38,6 +38,8 @@ #include <QFileInfoList> #include <QStringList> +#include <optional> + class AbstractMetaBuilder; class AbstractMetaClass; class AbstractMetaEnum; @@ -88,7 +90,7 @@ public: PrimitiveTypeEntryList primitiveTypes() const; ContainerTypeEntryList containerTypes() const; - const AbstractMetaEnum* findAbstractMetaEnum(const TypeEntry* typeEntry) const; + std::optional<AbstractMetaEnum> findAbstractMetaEnum(const TypeEntry* typeEntry) const; int classCount() const; diff --git a/sources/shiboken6/ApiExtractor/doxygenparser.cpp b/sources/shiboken6/ApiExtractor/doxygenparser.cpp index 435447133..723a5f022 100644 --- a/sources/shiboken6/ApiExtractor/doxygenparser.cpp +++ b/sources/shiboken6/ApiExtractor/doxygenparser.cpp @@ -202,15 +202,15 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass) } //Enums - for (AbstractMetaEnum *meta_enum : metaClass->enums()) { + for (AbstractMetaEnum &meta_enum : metaClass->enums()) { QString query = QLatin1String("/doxygen/compounddef/sectiondef/memberdef[@kind=\"enum\"]/name[text()=\"") - + meta_enum->name() + QLatin1String("\"]/.."); + + meta_enum.name() + QLatin1String("\"]/.."); QString doc = getDocumentation(xquery, query, DocModificationList()); if (doc.isEmpty()) { qCWarning(lcShibokenDoc, "%s", qPrintable(msgCannotFindDocumentation(doxyFilePath, metaClass, meta_enum, query))); } - meta_enum->setDocumentation(doc); + meta_enum.setDocumentation(doc); } } diff --git a/sources/shiboken6/ApiExtractor/messages.cpp b/sources/shiboken6/ApiExtractor/messages.cpp index 6c8d19601..3447873f7 100644 --- a/sources/shiboken6/ApiExtractor/messages.cpp +++ b/sources/shiboken6/ApiExtractor/messages.cpp @@ -421,11 +421,11 @@ QString msgCannotFindDocumentation(const QString &fileName, QString msgCannotFindDocumentation(const QString &fileName, const AbstractMetaClass *metaClass, - const AbstractMetaEnum *e, + const AbstractMetaEnum &e, const QString &query) { return msgCannotFindDocumentation(fileName, "enum", - metaClass->name() + QLatin1String("::") + e->name(), + metaClass->name() + QLatin1String("::") + e.name(), query); } diff --git a/sources/shiboken6/ApiExtractor/messages.h b/sources/shiboken6/ApiExtractor/messages.h index 54e961237..60c14fc15 100644 --- a/sources/shiboken6/ApiExtractor/messages.h +++ b/sources/shiboken6/ApiExtractor/messages.h @@ -144,7 +144,7 @@ QString msgCannotFindDocumentation(const QString &fileName, QString msgCannotFindDocumentation(const QString &fileName, const AbstractMetaClass *metaClass, - const AbstractMetaEnum *e, + const AbstractMetaEnum &e, const QString &query); QString msgCannotFindDocumentation(const QString &fileName, diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp index 513bb3532..2ee7398ea 100644 --- a/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp +++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.cpp @@ -50,6 +50,13 @@ void EnumValue::setUnsignedValue(quint64 v) m_type = Unsigned; } +bool EnumValue::equals(const EnumValue &rhs) const +{ + if (m_type != rhs.m_type) + return false; + return m_type == Signed ? m_value == rhs.m_value : m_unsignedValue == rhs.m_unsignedValue; +} + #ifndef QT_NO_DEBUG_STREAM QDebug operator<<(QDebug d,const EnumValue &v) { diff --git a/sources/shiboken6/ApiExtractor/parser/enumvalue.h b/sources/shiboken6/ApiExtractor/parser/enumvalue.h index ea30c39bb..3cd7d01a4 100644 --- a/sources/shiboken6/ApiExtractor/parser/enumvalue.h +++ b/sources/shiboken6/ApiExtractor/parser/enumvalue.h @@ -54,6 +54,8 @@ public: void setValue(qint64 v); void setUnsignedValue(quint64 v); + bool equals(const EnumValue &rhs) const; + private: #ifndef QT_NO_DEBUG_STREAM friend QDebug operator<<(QDebug, const EnumValue &); @@ -68,4 +70,9 @@ private: Type m_type = Signed; }; +inline bool operator==(const EnumValue &e1, const EnumValue &e2) +{ return e1.equals(e2); } +inline bool operator!=(const EnumValue &e1, const EnumValue &e2) +{ return !e1.equals(e2); } + #endif // ENUMVALUE_H diff --git a/sources/shiboken6/ApiExtractor/qtdocparser.cpp b/sources/shiboken6/ApiExtractor/qtdocparser.cpp index 0df8fff4a..6ce3432d7 100644 --- a/sources/shiboken6/ApiExtractor/qtdocparser.cpp +++ b/sources/shiboken6/ApiExtractor/qtdocparser.cpp @@ -289,16 +289,16 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass) } #endif // Enums - for (AbstractMetaEnum *meta_enum : metaClass->enums()) { + for (AbstractMetaEnum &meta_enum : metaClass->enums()) { query.clear(); QTextStream(&query) << classQuery << "/enum[@name=\"" - << meta_enum->name() << "\"]/description"; + << meta_enum.name() << "\"]/description"; doc.setValue(getDocumentation(xquery, query, DocModificationList())); if (doc.isEmpty()) { qCWarning(lcShibokenDoc, "%s", qPrintable(msgCannotFindDocumentation(sourceFileName, metaClass, meta_enum, query))); } - meta_enum->setDocumentation(doc); + meta_enum.setDocumentation(doc); } } diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp index fd50bf2ba..df6280725 100644 --- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp @@ -33,6 +33,7 @@ #include <abstractmetafunction.h> #include <abstractmetalang.h> #include <typesystem.h> +#include <parser/enumvalue.h> void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger() { @@ -128,10 +129,10 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue() AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - AbstractMetaEnum* someEnum = classA->findEnum(QLatin1String("SomeEnum")); - QVERIFY(someEnum); - AbstractMetaEnumValue *nvalues = classA->findEnumValue(QLatin1String("NValues")); - QVERIFY(nvalues); + auto someEnum = classA->findEnum(QLatin1String("SomeEnum")); + QVERIFY(someEnum.has_value()); + auto nvalues = classA->findEnumValue(QLatin1String("NValues")); + QVERIFY(nvalues.has_value()); const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg.type().isArray()); @@ -159,10 +160,9 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - AbstractMetaEnum *someEnum = builder->globalEnums().constFirst(); - QVERIFY(someEnum); - const AbstractMetaEnumValue *nvalues = someEnum->findEnumValue(QLatin1String("NValues")); - QVERIFY(nvalues); + AbstractMetaEnum someEnum = builder->globalEnums().constFirst(); + auto nvalues = someEnum.findEnumValue(u"NValues"); + QVERIFY(nvalues.has_value()); const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg.type().isArray()); diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp index 7e98cdf40..20b0c12e0 100644 --- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp @@ -88,7 +88,7 @@ void TestDropTypeEntries::testDropEntries() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("EnumA")); + QCOMPARE(globalEnums.constFirst().name(), QLatin1String("EnumA")); TypeDatabase* td = TypeDatabase::instance(); QVERIFY(td->findType(QLatin1String("funcA"))); diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp index 39bf7931a..710361b47 100644 --- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp @@ -33,6 +33,7 @@ #include <abstractmetafunction.h> #include <abstractmetalang.h> #include <typesystem.h> +#include <parser/enumvalue.h> void TestEnum::testEnumCppSignature() { @@ -60,7 +61,7 @@ void TestEnum::testEnumCppSignature() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("GlobalEnum")); + QCOMPARE(globalEnums.constFirst().name(), QLatin1String("GlobalEnum")); // enum as parameter of a function AbstractMetaFunctionList functions = builder->globalFunctions(); @@ -85,11 +86,12 @@ void TestEnum::testEnumCppSignature() QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum")); AbstractMetaEnumList classEnums = classA->enums(); - QCOMPARE(classEnums.constFirst()->name(), QLatin1String("ClassEnum")); - AbstractMetaEnumValue *e = AbstractMetaClass::findEnumValue(classes, QLatin1String("CA")); - QVERIFY(e); + QVERIFY(!classEnums.isEmpty()); + QCOMPARE(classEnums.constFirst().name(), QLatin1String("ClassEnum")); + auto e = AbstractMetaClass::findEnumValue(classes, QLatin1String("CA")); + QVERIFY(e.has_value()); e = AbstractMetaClass::findEnumValue(classes, QLatin1String("ClassEnum::CA")); - QVERIFY(e); + QVERIFY(e.has_value()); } void TestEnum::testEnumWithApiVersion() @@ -139,43 +141,43 @@ void TestEnum::testAnonymousEnum() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.constFirst()->typeEntry()->qualifiedCppName(), + QCOMPARE(globalEnums.constFirst().typeEntry()->qualifiedCppName(), QLatin1String("Global0")); - QVERIFY(globalEnums.constFirst()->isAnonymous()); + QVERIFY(globalEnums.constFirst().isAnonymous()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.count(), 1); QCOMPARE(classes[0]->enums().count(), 2); - AbstractMetaEnum* anonEnumA1 = classes[0]->findEnum(QLatin1String("A1")); - QVERIFY(anonEnumA1); + auto anonEnumA1 = classes[0]->findEnum(QLatin1String("A1")); + QVERIFY(anonEnumA1.has_value()); QVERIFY(anonEnumA1->isAnonymous()); QCOMPARE(anonEnumA1->typeEntry()->qualifiedCppName(), QLatin1String("A::A1")); - AbstractMetaEnumValue* enumValueA0 = anonEnumA1->values().constFirst(); - QCOMPARE(enumValueA0->name(), QLatin1String("A0")); - QCOMPARE(enumValueA0->value().value(), 0); - QCOMPARE(enumValueA0->stringValue(), QString()); + AbstractMetaEnumValue enumValueA0 = anonEnumA1->values().constFirst(); + QCOMPARE(enumValueA0.name(), QLatin1String("A0")); + QCOMPARE(enumValueA0.value().value(), 0); + QCOMPARE(enumValueA0.stringValue(), QString()); - AbstractMetaEnumValue *enumValueA1 = anonEnumA1->values().constLast(); - QCOMPARE(enumValueA1->name(), QLatin1String("A1")); - QCOMPARE(enumValueA1->value().value(), 1); - QCOMPARE(enumValueA1->stringValue(), QString()); + AbstractMetaEnumValue enumValueA1 = anonEnumA1->values().constLast(); + QCOMPARE(enumValueA1.name(), QLatin1String("A1")); + QCOMPARE(enumValueA1.value().value(), 1); + QCOMPARE(enumValueA1.stringValue(), QString()); - AbstractMetaEnum* anonEnumIsThis = classes[0]->findEnum(QLatin1String("isThis")); - QVERIFY(anonEnumIsThis); + auto anonEnumIsThis = classes[0]->findEnum(QLatin1String("isThis")); + QVERIFY(anonEnumIsThis.has_value()); QVERIFY(anonEnumIsThis->isAnonymous()); QCOMPARE(anonEnumIsThis->typeEntry()->qualifiedCppName(), QLatin1String("A::isThis")); - AbstractMetaEnumValue* enumValueIsThis = anonEnumIsThis->values().constFirst(); - QCOMPARE(enumValueIsThis->name(), QLatin1String("isThis")); - QCOMPARE(enumValueIsThis->value().value(), static_cast<int>(true)); - QCOMPARE(enumValueIsThis->stringValue(), QLatin1String("true")); + AbstractMetaEnumValue enumValueIsThis = anonEnumIsThis->values().constFirst(); + QCOMPARE(enumValueIsThis.name(), QLatin1String("isThis")); + QCOMPARE(enumValueIsThis.value().value(), static_cast<int>(true)); + QCOMPARE(enumValueIsThis.stringValue(), QLatin1String("true")); - AbstractMetaEnumValue *enumValueIsThat = anonEnumIsThis->values().constLast(); - QCOMPARE(enumValueIsThat->name(), QLatin1String("isThat")); - QCOMPARE(enumValueIsThat->value().value(), static_cast<int>(false)); - QCOMPARE(enumValueIsThat->stringValue(), QLatin1String("false")); + AbstractMetaEnumValue enumValueIsThat = anonEnumIsThis->values().constLast(); + QCOMPARE(enumValueIsThat.name(), QLatin1String("isThat")); + QCOMPARE(enumValueIsThat.value().value(), static_cast<int>(false)); + QCOMPARE(enumValueIsThat.stringValue(), QLatin1String("false")); } void TestEnum::testGlobalEnums() @@ -195,31 +197,31 @@ void TestEnum::testGlobalEnums() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 2); - AbstractMetaEnum *enumA = globalEnums.constFirst(); - QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); + AbstractMetaEnum enumA = globalEnums.constFirst(); + QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); - AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst(); - QCOMPARE(enumValueA0->name(), QLatin1String("A0")); - QCOMPARE(enumValueA0->value().value(), 0); - QCOMPARE(enumValueA0->stringValue(), QString()); + AbstractMetaEnumValue enumValueA0 = enumA.values().constFirst(); + QCOMPARE(enumValueA0.name(), QLatin1String("A0")); + QCOMPARE(enumValueA0.value().value(), 0); + QCOMPARE(enumValueA0.stringValue(), QString()); - AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast(); - QCOMPARE(enumValueA1->name(), QLatin1String("A1")); - QCOMPARE(enumValueA1->value().value(), 1); - QCOMPARE(enumValueA1->stringValue(), QString()); + AbstractMetaEnumValue enumValueA1 = enumA.values().constLast(); + QCOMPARE(enumValueA1.name(), QLatin1String("A1")); + QCOMPARE(enumValueA1.value().value(), 1); + QCOMPARE(enumValueA1.stringValue(), QString()); - AbstractMetaEnum *enumB = globalEnums.constLast(); - QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("EnumB")); + AbstractMetaEnum enumB = globalEnums.constLast(); + QCOMPARE(enumB.typeEntry()->qualifiedCppName(), QLatin1String("EnumB")); - AbstractMetaEnumValue* enumValueB0 = enumB->values().constFirst(); - QCOMPARE(enumValueB0->name(), QLatin1String("B0")); - QCOMPARE(enumValueB0->value().value(), 2); - QCOMPARE(enumValueB0->stringValue(), QLatin1String("2")); + AbstractMetaEnumValue enumValueB0 = enumB.values().constFirst(); + QCOMPARE(enumValueB0.name(), QLatin1String("B0")); + QCOMPARE(enumValueB0.value().value(), 2); + QCOMPARE(enumValueB0.stringValue(), QLatin1String("2")); - AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast(); - QCOMPARE(enumValueB1->name(), QLatin1String("B1")); - QCOMPARE(enumValueB1->value().value(), 4); - QCOMPARE(enumValueB1->stringValue(), QLatin1String("0x4")); + AbstractMetaEnumValue enumValueB1 = enumB.values().constLast(); + QCOMPARE(enumValueB1.name(), QLatin1String("B1")); + QCOMPARE(enumValueB1.value().value(), 4); + QCOMPARE(enumValueB1.stringValue(), QLatin1String("0x4")); } void TestEnum::testEnumValueFromNeighbourEnum() @@ -244,33 +246,33 @@ void TestEnum::testEnumValueFromNeighbourEnum() QCOMPARE(classes.count(), 1); QCOMPARE(classes[0]->enums().count(), 2); - AbstractMetaEnum* enumA = classes[0]->findEnum(QLatin1String("EnumA")); - QVERIFY(enumA); + auto enumA = classes[0]->findEnum(QLatin1String("EnumA")); + QVERIFY(enumA.has_value()); QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumA")); - AbstractMetaEnumValue* enumValueA0 = enumA->values().constFirst(); - QCOMPARE(enumValueA0->name(), QLatin1String("ValueA0")); - QCOMPARE(enumValueA0->value().value(), 0); - QCOMPARE(enumValueA0->stringValue(), QString()); + AbstractMetaEnumValue enumValueA0 = enumA->values().constFirst(); + QCOMPARE(enumValueA0.name(), QLatin1String("ValueA0")); + QCOMPARE(enumValueA0.value().value(), 0); + QCOMPARE(enumValueA0.stringValue(), QString()); - AbstractMetaEnumValue* enumValueA1 = enumA->values().constLast(); - QCOMPARE(enumValueA1->name(), QLatin1String("ValueA1")); - QCOMPARE(enumValueA1->value().value(), 1); - QCOMPARE(enumValueA1->stringValue(), QString()); + AbstractMetaEnumValue enumValueA1 = enumA->values().constLast(); + QCOMPARE(enumValueA1.name(), QLatin1String("ValueA1")); + QCOMPARE(enumValueA1.value().value(), 1); + QCOMPARE(enumValueA1.stringValue(), QString()); - AbstractMetaEnum* enumB = classes[0]->findEnum(QLatin1String("EnumB")); - QVERIFY(enumB); + auto enumB = classes[0]->findEnum(QLatin1String("EnumB")); + QVERIFY(enumB.has_value()); QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumB")); - AbstractMetaEnumValue *enumValueB0 = enumB->values().constFirst(); - QCOMPARE(enumValueB0->name(), QLatin1String("ValueB0")); - QCOMPARE(enumValueB0->value().value(), 1); - QCOMPARE(enumValueB0->stringValue(), QLatin1String("A::ValueA1")); + AbstractMetaEnumValue enumValueB0 = enumB->values().constFirst(); + QCOMPARE(enumValueB0.name(), QLatin1String("ValueB0")); + QCOMPARE(enumValueB0.value().value(), 1); + QCOMPARE(enumValueB0.stringValue(), QLatin1String("A::ValueA1")); - AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast(); - QCOMPARE(enumValueB1->name(), QLatin1String("ValueB1")); - QCOMPARE(enumValueB1->value().value(), 0); - QCOMPARE(enumValueB1->stringValue(), QLatin1String("ValueA0")); + AbstractMetaEnumValue enumValueB1 = enumB->values().constLast(); + QCOMPARE(enumValueB1.name(), QLatin1String("ValueB1")); + QCOMPARE(enumValueB1.value().value(), 0); + QCOMPARE(enumValueB1.stringValue(), QLatin1String("ValueA0")); } void TestEnum::testEnumValueFromExpression() @@ -305,60 +307,60 @@ void TestEnum::testEnumValueFromExpression() AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - AbstractMetaEnum* enumA = classA->findEnum(QLatin1String("EnumA")); - QVERIFY(enumA); + auto enumA = classA->findEnum(QLatin1String("EnumA")); + QVERIFY(enumA.has_value()); QVERIFY(!enumA->isSigned()); QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumA")); - AbstractMetaEnumValue* valueA0 = enumA->values().at(0); - QCOMPARE(valueA0->name(), QLatin1String("ValueA0")); - QCOMPARE(valueA0->stringValue(), QLatin1String("3u")); - QCOMPARE(valueA0->value().unsignedValue(), 3u); - - AbstractMetaEnumValue* valueA1 = enumA->values().at(1); - QCOMPARE(valueA1->name(), QLatin1String("ValueA1")); - QCOMPARE(valueA1->stringValue(), QLatin1String("~3u")); - QCOMPARE(valueA1->value().unsignedValue(), ~3u); - - AbstractMetaEnumValue* valueA2 = enumA->values().at(2); - QCOMPARE(valueA2->name(), QLatin1String("ValueA2")); - QCOMPARE(valueA2->stringValue(), QLatin1String("0xffffffff")); - QCOMPARE(valueA2->value().unsignedValue(), 0xffffffffu); - - AbstractMetaEnumValue* valueA3 = enumA->values().at(3); - QCOMPARE(valueA3->name(), QLatin1String("ValueA3")); - QCOMPARE(valueA3->stringValue(), QLatin1String("0xf0")); - QCOMPARE(valueA3->value().unsignedValue(), 0xf0u); - - AbstractMetaEnumValue* valueA4 = enumA->values().at(4); - QCOMPARE(valueA4->name(), QLatin1String("ValueA4")); - QCOMPARE(valueA4->stringValue(), QLatin1String("8 |ValueA3")); - QCOMPARE(valueA4->value().unsignedValue(), 8|0xf0u); - - AbstractMetaEnumValue* valueA5 = enumA->values().at(5); - QCOMPARE(valueA5->name(), QLatin1String("ValueA5")); - QCOMPARE(valueA5->stringValue(), QLatin1String("ValueA3|32")); - QCOMPARE(valueA5->value().unsignedValue(), 0xf0u|32); - - AbstractMetaEnumValue* valueA6 = enumA->values().at(6); - QCOMPARE(valueA6->name(), QLatin1String("ValueA6")); - QCOMPARE(valueA6->stringValue(), QLatin1String("ValueA3 >> 1")); - QCOMPARE(valueA6->value().unsignedValue(), 0xf0u >> 1); - - AbstractMetaEnumValue* valueA7 = enumA->values().at(7); - QCOMPARE(valueA7->name(), QLatin1String("ValueA7")); - QCOMPARE(valueA7->stringValue(), QLatin1String("ValueA3 << 1")); - QCOMPARE(valueA7->value().unsignedValue(), 0xf0u << 1); - - const AbstractMetaEnum *enumB = classA->findEnum(QLatin1String("EnumB")); - QVERIFY(enumB); + AbstractMetaEnumValue valueA0 = enumA->values().at(0); + QCOMPARE(valueA0.name(), QLatin1String("ValueA0")); + QCOMPARE(valueA0.stringValue(), QLatin1String("3u")); + QCOMPARE(valueA0.value().unsignedValue(), 3u); + + AbstractMetaEnumValue valueA1 = enumA->values().at(1); + QCOMPARE(valueA1.name(), QLatin1String("ValueA1")); + QCOMPARE(valueA1.stringValue(), QLatin1String("~3u")); + QCOMPARE(valueA1.value().unsignedValue(), ~3u); + + AbstractMetaEnumValue valueA2 = enumA->values().at(2); + QCOMPARE(valueA2.name(), QLatin1String("ValueA2")); + QCOMPARE(valueA2.stringValue(), QLatin1String("0xffffffff")); + QCOMPARE(valueA2.value().unsignedValue(), 0xffffffffu); + + AbstractMetaEnumValue valueA3 = enumA->values().at(3); + QCOMPARE(valueA3.name(), QLatin1String("ValueA3")); + QCOMPARE(valueA3.stringValue(), QLatin1String("0xf0")); + QCOMPARE(valueA3.value().unsignedValue(), 0xf0u); + + AbstractMetaEnumValue valueA4 = enumA->values().at(4); + QCOMPARE(valueA4.name(), QLatin1String("ValueA4")); + QCOMPARE(valueA4.stringValue(), QLatin1String("8 |ValueA3")); + QCOMPARE(valueA4.value().unsignedValue(), 8|0xf0u); + + AbstractMetaEnumValue valueA5 = enumA->values().at(5); + QCOMPARE(valueA5.name(), QLatin1String("ValueA5")); + QCOMPARE(valueA5.stringValue(), QLatin1String("ValueA3|32")); + QCOMPARE(valueA5.value().unsignedValue(), 0xf0u|32); + + AbstractMetaEnumValue valueA6 = enumA->values().at(6); + QCOMPARE(valueA6.name(), QLatin1String("ValueA6")); + QCOMPARE(valueA6.stringValue(), QLatin1String("ValueA3 >> 1")); + QCOMPARE(valueA6.value().unsignedValue(), 0xf0u >> 1); + + AbstractMetaEnumValue valueA7 = enumA->values().at(7); + QCOMPARE(valueA7.name(), QLatin1String("ValueA7")); + QCOMPARE(valueA7.stringValue(), QLatin1String("ValueA3 << 1")); + QCOMPARE(valueA7.value().unsignedValue(), 0xf0u << 1); + + const auto enumB = classA->findEnum(QLatin1String("EnumB")); + QVERIFY(enumB.has_value()); QVERIFY(enumB->isSigned()); QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumB")); QCOMPARE(enumB->values().size(), 1); - const AbstractMetaEnumValue *valueB0 = enumB->values().at(0); - QCOMPARE(valueB0->name(), QLatin1String("ValueB0")); - QCOMPARE(valueB0->stringValue(), QLatin1String("~3")); - QCOMPARE(valueB0->value().value(), ~3); + const AbstractMetaEnumValue valueB0 = enumB->values().at(0); + QCOMPARE(valueB0.name(), QLatin1String("ValueB0")); + QCOMPARE(valueB0.stringValue(), QLatin1String("~3")); + QCOMPARE(valueB0.value().value(), ~3); } void TestEnum::testPrivateEnum() @@ -384,24 +386,24 @@ void TestEnum::testPrivateEnum() QVERIFY(classA); QCOMPARE(classA->enums().count(), 2); - AbstractMetaEnum* privateEnum = classA->findEnum(QLatin1String("PrivateEnum")); - QVERIFY(privateEnum); + auto privateEnum = classA->findEnum(QLatin1String("PrivateEnum")); + QVERIFY(privateEnum.has_value()); QVERIFY(privateEnum->isPrivate()); QCOMPARE(privateEnum->typeEntry()->qualifiedCppName(), QLatin1String("A::PrivateEnum")); - AbstractMetaEnum* publicEnum = classA->findEnum(QLatin1String("PublicEnum")); - QVERIFY(publicEnum); + auto publicEnum = classA->findEnum(QLatin1String("PublicEnum")); + QVERIFY(publicEnum.has_value()); QCOMPARE(publicEnum->typeEntry()->qualifiedCppName(), QLatin1String("A::PublicEnum")); - AbstractMetaEnumValue *pub0 = publicEnum->values().constFirst(); - QCOMPARE(pub0->name(), QLatin1String("Pub0")); - QCOMPARE(pub0->value().value(), 0x0f); - QCOMPARE(pub0->stringValue(), QLatin1String("Priv0")); + AbstractMetaEnumValue pub0 = publicEnum->values().constFirst(); + QCOMPARE(pub0.name(), QLatin1String("Pub0")); + QCOMPARE(pub0.value().value(), 0x0f); + QCOMPARE(pub0.stringValue(), QLatin1String("Priv0")); - AbstractMetaEnumValue *pub1 = publicEnum->values().constLast(); - QCOMPARE(pub1->name(), QLatin1String("Pub1")); - QCOMPARE(pub1->value().value(), 0xf0); - QCOMPARE(pub1->stringValue(), QLatin1String("A::Priv1")); + AbstractMetaEnumValue pub1 = publicEnum->values().constLast(); + QCOMPARE(pub1.name(), QLatin1String("Pub1")); + QCOMPARE(pub1.value().value(), 0xf0); + QCOMPARE(pub1.stringValue(), QLatin1String("A::Priv1")); } void TestEnum::testTypedefEnum() @@ -422,18 +424,18 @@ void TestEnum::testTypedefEnum() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - AbstractMetaEnum *enumA = globalEnums.constFirst(); - QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); + AbstractMetaEnum enumA = globalEnums.constFirst(); + QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); - AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst(); - QCOMPARE(enumValueA0->name(), QLatin1String("A0")); - QCOMPARE(enumValueA0->value().value(), 0); - QCOMPARE(enumValueA0->stringValue(), QLatin1String("")); + AbstractMetaEnumValue enumValueA0 = enumA.values().constFirst(); + QCOMPARE(enumValueA0.name(), QLatin1String("A0")); + QCOMPARE(enumValueA0.value().value(), 0); + QCOMPARE(enumValueA0.stringValue(), QLatin1String("")); - AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast(); - QCOMPARE(enumValueA1->name(), QLatin1String("A1")); - QCOMPARE(enumValueA1->value().value(), 1); - QCOMPARE(enumValueA1->stringValue(), QString()); + AbstractMetaEnumValue enumValueA1 = enumA.values().constLast(); + QCOMPARE(enumValueA1.name(), QLatin1String("A1")); + QCOMPARE(enumValueA1.value().value(), 1); + QCOMPARE(enumValueA1.stringValue(), QString()); } QTEST_APPLESS_MAIN(TestEnum) diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp index e3aad6b50..8bd830d14 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp @@ -54,8 +54,8 @@ void NamespaceTest::testNamespaceMembers() AbstractMetaClassList classes = builder->classes(); AbstractMetaClass *ns = AbstractMetaClass::findClass(classes, QLatin1String("Namespace")); QVERIFY(ns); - const AbstractMetaEnum* metaEnum = ns->findEnum(QLatin1String("Option")); - QVERIFY(metaEnum); + auto metaEnum = ns->findEnum(QLatin1String("Option")); + QVERIFY(metaEnum.has_value()); const AbstractMetaFunction* func = ns->findFunction(QLatin1String("foo")); QVERIFY(func); } diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp index 0f257b472..d8170f5e8 100644 --- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp @@ -59,11 +59,13 @@ void TestTypeRevision::testRevisionAttr() AbstractMetaClass *rev2 = AbstractMetaClass::findClass(classes, QLatin1String("Rev_2")); QCOMPARE(rev2->typeEntry()->revision(), 2); - AbstractMetaEnum* rev3 = rev2->findEnum(QLatin1String("Rev_3")); + auto rev3 = rev2->findEnum(QLatin1String("Rev_3")); + QVERIFY(rev3.has_value()); QCOMPARE(rev3->typeEntry()->revision(), 3); FlagsTypeEntry* rev4 = rev3->typeEntry()->flags(); QCOMPARE(rev4->revision(), 4); - AbstractMetaEnum* rev5 = rev2->findEnum(QLatin1String("Rev_5")); + auto rev5 = rev2->findEnum(QLatin1String("Rev_5")); + QVERIFY(rev5.has_value()); const EnumTypeEntry *revEnumTypeEntry = rev5->typeEntry(); QCOMPARE(revEnumTypeEntry->revision(), 5); QCOMPARE(revEnumTypeEntry->flags()->revision(), 5); |