diff options
author | Friedemann Kleint <Friedemann.Kleint@qt.io> | 2020-11-10 14:38:50 +0100 |
---|---|---|
committer | Friedemann Kleint <Friedemann.Kleint@qt.io> | 2020-11-11 17:14:02 +0000 |
commit | c527b0bac89679aa01fbc409077dd5640fc59c9b (patch) | |
tree | 5c81a3d2d17e119d428f7a0d0e9f449110d922db /sources/shiboken6/ApiExtractor | |
parent | e720169ff6cb840dbd5a89f22f4d5e2e2b36bf17 (diff) |
shiboken6: AbstractMetaClass: Introduce a private class
Move the data members of AbstractMetaClass to a private class. Similar
to what was done for TypeEntry, the main motivation here is header
hygiene and decoupling.
Change-Id: I8e2ea551b5df29649ed6f93a8a4cb938ac1978f6
Reviewed-by: Christian Tismer <tismer@stackless.com>
Diffstat (limited to 'sources/shiboken6/ApiExtractor')
5 files changed, 537 insertions, 246 deletions
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp index d7393d82a..a742910ec 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp @@ -28,6 +28,7 @@ #include "abstractmetalang.h" #include "abstractmetalang_helpers.h" +#include "abstractmetaenum.h" #include "abstractmetafunction.h" #include "abstractmetafield.h" #include "modifications.h" @@ -43,30 +44,79 @@ bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b) return a->signature() < b->signature(); } -AbstractMetaClass::AbstractMetaClass() - : m_hasVirtuals(false), - m_isPolymorphic(false), - m_hasNonpublic(false), - m_hasNonPrivateConstructor(false), - m_hasPrivateConstructor(false), - m_functionsFixed(false), - m_hasPrivateDestructor(false), - m_hasProtectedDestructor(false), - m_hasVirtualDestructor(false), - m_hasHashFunction(false), - m_hasEqualsOperator(false), - m_hasCloneOperator(false), - m_isTypeDef(false), - m_hasToStringCapability(false) -{ -} +class AbstractMetaClassPrivate +{ +public: + AbstractMetaClassPrivate() + : m_hasVirtuals(false), + m_isPolymorphic(false), + m_hasNonpublic(false), + m_hasNonPrivateConstructor(false), + m_hasPrivateConstructor(false), + m_functionsFixed(false), + m_hasPrivateDestructor(false), + m_hasProtectedDestructor(false), + m_hasVirtualDestructor(false), + m_hasHashFunction(false), + m_hasEqualsOperator(false), + m_hasCloneOperator(false), + m_isTypeDef(false), + m_hasToStringCapability(false) + { + } + + ~AbstractMetaClassPrivate() + { + qDeleteAll(m_functions); + qDeleteAll(m_propertySpecs); + } + + uint m_hasVirtuals : 1; + uint m_isPolymorphic : 1; + uint m_hasNonpublic : 1; + uint m_hasNonPrivateConstructor : 1; + uint m_hasPrivateConstructor : 1; + uint m_functionsFixed : 1; + uint m_hasPrivateDestructor : 1; + uint m_hasProtectedDestructor : 1; + uint m_hasVirtualDestructor : 1; + uint m_hasHashFunction : 1; + uint m_hasEqualsOperator : 1; + uint m_hasCloneOperator : 1; + uint m_isTypeDef : 1; + uint m_hasToStringCapability : 1; + + Documentation m_doc; -AbstractMetaClass::~AbstractMetaClass() + const AbstractMetaClass *m_enclosingClass = nullptr; + AbstractMetaClassList m_baseClasses; // Real base classes after setting up inheritance + AbstractMetaTypeList m_baseTemplateInstantiations; + AbstractMetaClass *m_extendedNamespace = nullptr; + + const AbstractMetaClass *m_templateBaseClass = nullptr; + AbstractMetaFunctionList m_functions; + AbstractMetaFieldList m_fields; + AbstractMetaEnumList m_enums; + QVector<QPropertySpec *> m_propertySpecs; + AbstractMetaClassList m_innerClasses; + + AbstractMetaFunctionList m_externalConversionOperators; + + QStringList m_baseClassNames; // Base class names from C++, including rejected + QVector<TypeEntry *> m_templateArgs; + ComplexTypeEntry *m_typeEntry = nullptr; + SourceLocation m_sourceLocation; + + bool m_stream = false; + uint m_toStringCapabilityIndirections = 0; +}; + +AbstractMetaClass::AbstractMetaClass() : d(new AbstractMetaClassPrivate) { - qDeleteAll(m_functions); - qDeleteAll(m_propertySpecs); } +AbstractMetaClass::~AbstractMetaClass() = default; + /******************************************************************************* * Returns true if this class is a subclass of the given class */ @@ -85,13 +135,18 @@ bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const return false; } +bool AbstractMetaClass::isPolymorphic() const +{ + return d->m_isPolymorphic; +} + /******************************************************************************* * Returns a list of all the functions with a given name */ AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const { AbstractMetaFunctionList returned; - for (AbstractMetaFunction *function : m_functions) { + for (AbstractMetaFunction *function : d->m_functions) { if (function->name() == name) returned.append(function); } @@ -176,7 +231,7 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio bool AbstractMetaClass::hasArithmeticOperatorOverload() const { - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate()) return true; } @@ -185,7 +240,7 @@ bool AbstractMetaClass::hasArithmeticOperatorOverload() const bool AbstractMetaClass::hasBitwiseOperatorOverload() const { - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate()) return true; } @@ -194,7 +249,7 @@ bool AbstractMetaClass::hasBitwiseOperatorOverload() const bool AbstractMetaClass::hasComparisonOperatorOverload() const { - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate()) return true; } @@ -203,29 +258,64 @@ bool AbstractMetaClass::hasComparisonOperatorOverload() const bool AbstractMetaClass::hasLogicalOperatorOverload() const { - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate()) return true; } return false; } +const AbstractMetaFieldList &AbstractMetaClass::fields() const +{ + return d->m_fields; +} + +AbstractMetaFieldList &AbstractMetaClass::fields() +{ + return d->m_fields; +} + +void AbstractMetaClass::setFields(const AbstractMetaFieldList &fields) +{ + d->m_fields = fields; +} + +void AbstractMetaClass::addField(const AbstractMetaField &field) +{ + d->m_fields << field; +} + void AbstractMetaClass::sortFunctions() { - std::sort(m_functions.begin(), m_functions.end(), function_sorter); + std::sort(d->m_functions.begin(), d->m_functions.end(), function_sorter); +} + +const AbstractMetaClass *AbstractMetaClass::templateBaseClass() const +{ + return d->m_templateBaseClass; +} + +void AbstractMetaClass::setTemplateBaseClass(const AbstractMetaClass *cls) +{ + d->m_templateBaseClass = cls; +} + +const AbstractMetaFunctionList &AbstractMetaClass::functions() const +{ + return d->m_functions; } void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions) { - m_functions = functions; + d->m_functions = functions; // Functions must be sorted by name before next loop sortFunctions(); - for (AbstractMetaFunction *f : qAsConst(m_functions)) { + for (AbstractMetaFunction *f : qAsConst(d->m_functions)) { f->setOwnerClass(this); if (!f->isPublic()) - m_hasNonpublic = true; + d->m_hasNonpublic = true; } } @@ -239,19 +329,49 @@ bool AbstractMetaClass::hasDefaultToStringFunction() const return false; } +bool AbstractMetaClass::hasEqualsOperator() const +{ + return d->m_hasEqualsOperator; +} + +void AbstractMetaClass::setHasEqualsOperator(bool on) +{ + d->m_hasEqualsOperator = on; +} + +bool AbstractMetaClass::hasCloneOperator() const +{ + return d->m_hasCloneOperator; +} + +void AbstractMetaClass::setHasCloneOperator(bool on) +{ + d->m_hasCloneOperator = on; +} + +const QVector<QPropertySpec *> &AbstractMetaClass::propertySpecs() const +{ + return d->m_propertySpecs; +} + +void AbstractMetaClass::addPropertySpec(QPropertySpec *spec) +{ + d->m_propertySpecs << spec; +} + void AbstractMetaClass::addFunction(AbstractMetaFunction *function) { Q_ASSERT(!function->signature().startsWith(QLatin1Char('('))); function->setOwnerClass(this); if (!function->isDestructor()) - m_functions << function; + d->m_functions << function; else Q_ASSERT(false); //memory leak - m_hasVirtuals |= function->isVirtual(); - m_isPolymorphic |= m_hasVirtuals; - m_hasNonpublic |= !function->isPublic(); + d->m_hasVirtuals |= function->isVirtual(); + d->m_isPolymorphic |= d->m_hasVirtuals; + d->m_hasNonpublic |= !function->isPublic(); } bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const @@ -259,7 +379,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const if (!other->isSignal()) return false; - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName) return other->modifiedName() == f->modifiedName(); } @@ -270,40 +390,90 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const QString AbstractMetaClass::name() const { - return m_typeEntry->targetLangEntryName(); + return d->m_typeEntry->targetLangEntryName(); +} + +const Documentation &AbstractMetaClass::documentation() const +{ + return d->m_doc; +} + +void AbstractMetaClass::setDocumentation(const Documentation &doc) +{ + d->m_doc = doc; +} + +QString AbstractMetaClass::baseClassName() const +{ + return d->m_baseClasses.isEmpty() ? QString() : d->m_baseClasses.constFirst()->name(); +} + +AbstractMetaClass *AbstractMetaClass::baseClass() const +{ + return d->m_baseClasses.value(0, nullptr); +} + +const AbstractMetaClassList &AbstractMetaClass::baseClasses() const +{ + return d->m_baseClasses; } void AbstractMetaClass::addBaseClass(AbstractMetaClass *baseClass) { Q_ASSERT(baseClass); - m_baseClasses.append(baseClass); - m_isPolymorphic |= baseClass->isPolymorphic(); + d->m_baseClasses.append(baseClass); + d->m_isPolymorphic |= baseClass->isPolymorphic(); } void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass) { if (baseClass) { - m_baseClasses.prepend(baseClass); - m_isPolymorphic |= baseClass->isPolymorphic(); + d->m_baseClasses.prepend(baseClass); + d->m_isPolymorphic |= baseClass->isPolymorphic(); } } +AbstractMetaClass *AbstractMetaClass::extendedNamespace() const +{ + return d->m_extendedNamespace; +} + +void AbstractMetaClass::setExtendedNamespace(AbstractMetaClass *e) +{ + d->m_extendedNamespace = e; +} + +const AbstractMetaClassList &AbstractMetaClass::innerClasses() const +{ + return d->m_innerClasses; +} + +void AbstractMetaClass::addInnerClass(AbstractMetaClass *cl) +{ + d->m_innerClasses << cl; +} + +void AbstractMetaClass::setInnerClasses(const AbstractMetaClassList &innerClasses) +{ + d->m_innerClasses = innerClasses; +} + QString AbstractMetaClass::package() const { - return m_typeEntry->targetLangPackage(); + return d->m_typeEntry->targetLangPackage(); } bool AbstractMetaClass::isNamespace() const { - return m_typeEntry->isNamespace(); + return d->m_typeEntry->isNamespace(); } // Is an invisible namespaces whose functions/enums // should be mapped to the global space. bool AbstractMetaClass::isInvisibleNamespace() const { - return m_typeEntry->isNamespace() && m_typeEntry->generateCode() - && !NamespaceTypeEntry::isVisibleScope(m_typeEntry); + return d->m_typeEntry->isNamespace() && d->m_typeEntry->generateCode() + && !NamespaceTypeEntry::isVisibleScope(d->m_typeEntry); } static bool qObjectPredicate(const AbstractMetaClass *c) @@ -316,9 +486,14 @@ bool AbstractMetaClass::isQObject() const return qObjectPredicate(this) || recurseClassHierarchy(this, qObjectPredicate) != nullptr; } +bool AbstractMetaClass::isQtNamespace() const +{ + return isNamespace() && name() == QLatin1String("Qt"); +} + QString AbstractMetaClass::qualifiedCppName() const { - return m_typeEntry->qualifiedCppName(); + return d->m_typeEntry->qualifiedCppName(); } bool AbstractMetaClass::hasFunction(const QString &str) const @@ -328,12 +503,12 @@ bool AbstractMetaClass::hasFunction(const QString &str) const const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const { - return AbstractMetaFunction::find(m_functions, functionName); + return AbstractMetaFunction::find(d->m_functions, functionName); } bool AbstractMetaClass::hasProtectedFunctions() const { - for (AbstractMetaFunction *func : m_functions) { + for (AbstractMetaFunction *func : d->m_functions) { if (func->isProtected()) return true; } @@ -342,7 +517,7 @@ bool AbstractMetaClass::hasProtectedFunctions() const bool AbstractMetaClass::hasProtectedFields() const { - for (const AbstractMetaField &field : m_fields) { + for (const AbstractMetaField &field : d->m_fields) { if (field.isProtected()) return true; } @@ -354,9 +529,54 @@ bool AbstractMetaClass::hasProtectedMembers() const return hasProtectedFields() || hasProtectedFunctions(); } +const QVector<TypeEntry *> &AbstractMetaClass::templateArguments() const +{ + return d->m_templateArgs; +} + +void AbstractMetaClass::setTemplateArguments(const QVector<TypeEntry *> &args) +{ + d->m_templateArgs = args; +} + +const QStringList &AbstractMetaClass::baseClassNames() const +{ + return d->m_baseClassNames; +} + +void AbstractMetaClass::setBaseClassNames(const QStringList &names) +{ + d->m_baseClassNames = names; +} + +const ComplexTypeEntry *AbstractMetaClass::typeEntry() const +{ + return d->m_typeEntry; +} + +ComplexTypeEntry *AbstractMetaClass::typeEntry() +{ + return d->m_typeEntry; +} + +void AbstractMetaClass::setTypeEntry(ComplexTypeEntry *type) +{ + d->m_typeEntry = type; +} + +void AbstractMetaClass::setHasHashFunction(bool on) +{ + d->m_hasHashFunction = on; +} + +bool AbstractMetaClass::hasHashFunction() const +{ + return d->m_hasHashFunction; +} + QPropertySpec *AbstractMetaClass::propertySpecByName(const QString &name) const { - for (auto propertySpec : m_propertySpecs) { + for (auto propertySpec : d->m_propertySpecs) { if (name == propertySpec->name()) return propertySpec; } @@ -365,7 +585,7 @@ QPropertySpec *AbstractMetaClass::propertySpecByName(const QString &name) const QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const { - for (const auto &propertySpec : m_propertySpecs) { + for (const auto &propertySpec : d->m_propertySpecs) { if (name == propertySpec->read()) return propertySpec; } @@ -374,7 +594,7 @@ QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) const { - for (const auto &propertySpec : m_propertySpecs) { + for (const auto &propertySpec : d->m_propertySpecs) { if (name == propertySpec->write()) return propertySpec; } @@ -383,34 +603,86 @@ QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) cons QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) const { - for (const auto &propertySpec : m_propertySpecs) { + for (const auto &propertySpec : d->m_propertySpecs) { if (name == propertySpec->reset()) return propertySpec; } return nullptr; } +AbstractMetaFunctionList AbstractMetaClass::externalConversionOperators() const +{ + return d->m_externalConversionOperators; +} + +void AbstractMetaClass::addExternalConversionOperator(AbstractMetaFunction *conversionOp) +{ + if (!d->m_externalConversionOperators.contains(conversionOp)) + d->m_externalConversionOperators.append(conversionOp); +} + +bool AbstractMetaClass::hasExternalConversionOperators() const +{ + return !d->m_externalConversionOperators.isEmpty(); +} + bool AbstractMetaClass::hasTemplateBaseClassInstantiations() const { - return m_templateBaseClass != nullptr && !m_baseTemplateInstantiations.isEmpty(); + return d->m_templateBaseClass != nullptr && !d->m_baseTemplateInstantiations.isEmpty(); } const AbstractMetaTypeList &AbstractMetaClass::templateBaseClassInstantiations() const { - return m_baseTemplateInstantiations; + return d->m_baseTemplateInstantiations; } void AbstractMetaClass::setTemplateBaseClassInstantiations(const AbstractMetaTypeList &instantiations) { - Q_ASSERT(m_templateBaseClass != nullptr); - m_baseTemplateInstantiations = instantiations; + Q_ASSERT(d->m_templateBaseClass != nullptr); + d->m_baseTemplateInstantiations = instantiations; +} + +void AbstractMetaClass::setTypeDef(bool typeDef) +{ + d->m_isTypeDef = typeDef; +} + +bool AbstractMetaClass::isTypeDef() const +{ + return d->m_isTypeDef; +} + +bool AbstractMetaClass::isStream() const +{ + return d->m_stream; +} + +void AbstractMetaClass::setStream(bool stream) +{ + d->m_stream = stream; +} + +bool AbstractMetaClass::hasToStringCapability() const +{ + return d->m_hasToStringCapability; +} + +void AbstractMetaClass::setToStringCapability(bool value, uint indirections) +{ + d->m_hasToStringCapability = value; + d->m_toStringCapabilityIndirections = indirections; +} + +uint AbstractMetaClass::toStringCapabilityIndirections() const +{ + return d->m_toStringCapabilityIndirections; } // Does any of the base classes require deletion in the main thread? bool AbstractMetaClass::deleteInMainThread() const { return typeEntry()->deleteInMainThread() - || (!m_baseClasses.isEmpty() && m_baseClasses.constFirst()->deleteInMainThread()); + || (!d->m_baseClasses.isEmpty() && d->m_baseClasses.constFirst()->deleteInMainThread()); } static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func) @@ -424,18 +696,23 @@ static bool functions_contains(const AbstractMetaFunctionList &l, const Abstract bool AbstractMetaClass::hasConstructors() const { - return AbstractMetaClass::queryFirstFunction(m_functions, Constructors) != nullptr; + return AbstractMetaClass::queryFirstFunction(d->m_functions, Constructors) != nullptr; } const AbstractMetaFunction *AbstractMetaClass::copyConstructor() const { - for (const AbstractMetaFunction *f : m_functions) { + for (const AbstractMetaFunction *f : d->m_functions) { if (f->functionType() == AbstractMetaFunction::CopyConstructorFunction) return f; } return nullptr; } +bool AbstractMetaClass::hasCopyConstructor() const +{ + return copyConstructor() != nullptr; +} + bool AbstractMetaClass::hasPrivateCopyConstructor() const { const AbstractMetaFunction *copyCt = copyConstructor(); @@ -493,21 +770,71 @@ void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate) addFunction(f); } +bool AbstractMetaClass::hasNonPrivateConstructor() const +{ + return d->m_hasNonPrivateConstructor; +} + +void AbstractMetaClass::setHasNonPrivateConstructor(bool value) +{ + d->m_hasNonPrivateConstructor = value; +} + +bool AbstractMetaClass::hasPrivateConstructor() const +{ + return d->m_hasPrivateConstructor; +} + +void AbstractMetaClass::setHasPrivateConstructor(bool value) +{ + d->m_hasPrivateConstructor = value; +} + +bool AbstractMetaClass::hasPrivateDestructor() const +{ + return d->m_hasPrivateDestructor; +} + +void AbstractMetaClass::setHasPrivateDestructor(bool value) +{ + d->m_hasPrivateDestructor = value; +} + +bool AbstractMetaClass::hasProtectedDestructor() const +{ + return d->m_hasProtectedDestructor; +} + +void AbstractMetaClass::setHasProtectedDestructor(bool value) +{ + d->m_hasProtectedDestructor = value; +} + +bool AbstractMetaClass::hasVirtualDestructor() const +{ + return d->m_hasVirtualDestructor; +} + void AbstractMetaClass::setHasVirtualDestructor(bool value) { - m_hasVirtualDestructor = value; + d->m_hasVirtualDestructor = value; if (value) - m_hasVirtuals = m_isPolymorphic = 1; + d->m_hasVirtuals = d->m_isPolymorphic = 1; +} + +bool AbstractMetaClass::isConstructible() const +{ + return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor(); } bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const { - return functions_contains(m_functions, f); + return functions_contains(d->m_functions, f); } bool AbstractMetaClass::generateExceptionHandling() const { - return queryFirstFunction(m_functions, AbstractMetaClass::Visible + return queryFirstFunction(d->m_functions, AbstractMetaClass::Visible | AbstractMetaClass::GenerateExceptionHandling) != nullptr; } /* Goes through the list of functions and returns a list of all @@ -619,12 +946,12 @@ const AbstractMetaFunction *AbstractMetaClass::queryFirstFunction(const Abstract AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions query) const { - return AbstractMetaClass::queryFunctionList(m_functions, query); + return AbstractMetaClass::queryFunctionList(d->m_functions, query); } bool AbstractMetaClass::hasSignals() const { - return queryFirstFunction(m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr; + return queryFirstFunction(d->m_functions, Signals | Visible | NotRemovedFromTargetLang) != nullptr; } AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const @@ -635,13 +962,33 @@ AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const std::optional<AbstractMetaField> AbstractMetaClass::findField(const QString &name) const { - return AbstractMetaField::find(m_fields, name); + return AbstractMetaField::find(d->m_fields, name); +} + +const AbstractMetaEnumList &AbstractMetaClass::enums() const +{ + return d->m_enums; +} + +AbstractMetaEnumList &AbstractMetaClass::enums() +{ + return d->m_enums; +} + +void AbstractMetaClass::setEnums(const AbstractMetaEnumList &enums) +{ + d->m_enums = enums; +} + +void AbstractMetaClass::addEnum(const AbstractMetaEnum &e) +{ + d->m_enums << e; } std::optional<AbstractMetaEnum> AbstractMetaClass::findEnum(const QString &enumName) const { - for (const auto &e : m_enums) { + for (const auto &e : d->m_enums) { if (e.name() == enumName) return e; } @@ -654,7 +1001,7 @@ std::optional<AbstractMetaEnum> std::optional<AbstractMetaEnumValue> AbstractMetaClass::findEnumValue(const QString &enumValueName) const { - for (const AbstractMetaEnum &e : qAsConst(m_enums)) { + for (const AbstractMetaEnum &e : qAsConst(d->m_enums)) { auto v = e.findEnumValue(enumValueName); if (v.has_value()) return v; @@ -667,7 +1014,7 @@ std::optional<AbstractMetaEnumValue> void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const { - for (const AbstractMetaEnum &metaEnum : m_enums) { + for (const AbstractMetaEnum &metaEnum : d->m_enums) { if (!metaEnum.isPrivate() && metaEnum.typeEntry()->generateCode()) enumList->append(metaEnum); } @@ -691,6 +1038,11 @@ void AbstractMetaClass::getFunctionsFromInvisibleNamespacesToBeGenerated(Abstrac } } +QString AbstractMetaClass::fullName() const +{ + return package() + QLatin1Char('.') + name(); +} + static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType &type) { @@ -722,14 +1074,14 @@ static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const Abst void AbstractMetaClass::fixFunctions() { - if (m_functionsFixed) + if (d->m_functionsFixed) return; - m_functionsFixed = true; + d->m_functionsFixed = true; AbstractMetaFunctionList funcs = functions(); - for (auto superClass : m_baseClasses) { + for (auto superClass : d->m_baseClasses) { superClass->fixFunctions(); // Since we always traverse the complete hierarchy we are only // interrested in what each super class implements, not what @@ -1014,79 +1366,79 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla #ifndef QT_NO_DEBUG_STREAM -void AbstractMetaClass::format(QDebug &d) const +void AbstractMetaClass::format(QDebug &debug) const { - if (d.verbosity() > 2) - d << static_cast<const void *>(this) << ", "; - d << '"' << qualifiedCppName(); - if (const int count = m_templateArgs.size()) { + if (debug.verbosity() > 2) + debug << static_cast<const void *>(this) << ", "; + debug << '"' << qualifiedCppName(); + if (const int count = d->m_templateArgs.size()) { for (int i = 0; i < count; ++i) - d << (i ? ',' : '<') << m_templateArgs.at(i)->qualifiedCppName(); - d << '>'; + debug << (i ? ',' : '<') << d->m_templateArgs.at(i)->qualifiedCppName(); + debug << '>'; } - d << '"'; + debug << '"'; if (isNamespace()) - d << " [namespace]"; + debug << " [namespace]"; if (attributes() & AbstractMetaAttributes::FinalCppClass) - d << " [final]"; + debug << " [final]"; if (attributes().testFlag(AbstractMetaAttributes::Deprecated)) - d << " [deprecated]"; - if (!m_baseClasses.isEmpty()) { - d << ", inherits "; - for (auto b : m_baseClasses) - d << " \"" << b->name() << '"'; + debug << " [deprecated]"; + if (!d->m_baseClasses.isEmpty()) { + debug << ", inherits "; + for (auto b : d->m_baseClasses) + debug << " \"" << b->name() << '"'; } if (auto templateBase = templateBaseClass()) { const auto &instantiatedTypes = templateBaseClassInstantiations(); - d << ", instantiates \"" << templateBase->name(); + debug << ", instantiates \"" << templateBase->name(); for (int i = 0, count = instantiatedTypes.size(); i < count; ++i) - d << (i ? ',' : '<') << instantiatedTypes.at(i).name(); - d << ">\""; + debug << (i ? ',' : '<') << instantiatedTypes.at(i).name(); + debug << ">\""; } - if (const int count = m_propertySpecs.size()) { - d << ", properties (" << count << "): ["; + if (const int count = d->m_propertySpecs.size()) { + debug << ", properties (" << count << "): ["; for (int i = 0; i < count; ++i) { if (i) - d << ", "; - m_propertySpecs.at(i)->formatDebug(d); + debug << ", "; + d->m_propertySpecs.at(i)->formatDebug(debug); } - d << ']'; + debug << ']'; } } -void AbstractMetaClass::formatMembers(QDebug &d) const +void AbstractMetaClass::formatMembers(QDebug &debug) const { - if (!m_enums.isEmpty()) - d << ", enums[" << m_enums.size() << "]=" << m_enums; - if (!m_functions.isEmpty()) { - const int count = m_functions.size(); - d << ", functions=[" << count << "]("; + if (!d->m_enums.isEmpty()) + debug << ", enums[" << d->m_enums.size() << "]=" << d->m_enums; + if (!d->m_functions.isEmpty()) { + const int count = d->m_functions.size(); + debug << ", functions=[" << count << "]("; for (int i = 0; i < count; ++i) { if (i) - d << ", "; - m_functions.at(i)->formatDebugBrief(d); + debug << ", "; + d->m_functions.at(i)->formatDebugBrief(debug); } - d << ')'; + debug << ')'; } - if (const int count = m_fields.size()) { - d << ", fields=[" << count << "]("; + if (const int count = d->m_fields.size()) { + debug << ", fields=[" << count << "]("; for (int i = 0; i < count; ++i) { if (i) - d << ", "; - m_fields.at(i).formatDebug(d); + debug << ", "; + d->m_fields.at(i).formatDebug(debug); } - d << ')'; + debug << ')'; } } SourceLocation AbstractMetaClass::sourceLocation() const { - return m_sourceLocation; + return d->m_sourceLocation; } void AbstractMetaClass::setSourceLocation(const SourceLocation &sourceLocation) { - m_sourceLocation = sourceLocation; + d->m_sourceLocation = sourceLocation; } QDebug operator<<(QDebug d, const AbstractMetaClass *ac) diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h index 8de86ed2a..2087180cd 100644 --- a/sources/shiboken6/ApiExtractor/abstractmetalang.h +++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h @@ -31,27 +31,29 @@ #include "abstractmetalang_typedefs.h" #include "abstractmetaattributes.h" -#include "abstractmetaenum.h" -#include "abstractmetafield.h" #include "enclosingclassmixin.h" -#include "documentation.h" -#include "sourcelocation.h" #include "typesystem_enums.h" #include "typesystem_typedefs.h" #include <QtCore/qobjectdefs.h> +#include <QtCore/QScopedPointer> #include <QtCore/QStringList> QT_FORWARD_DECLARE_CLASS(QDebug) -class QPropertySpec; +class AbstractMetaClassPrivate; class ComplexTypeEntry; +class Documentation; class EnumTypeEntry; +class QPropertySpec; +class SourceLocation; class AbstractMetaClass : public AbstractMetaAttributes, public EnclosingClassMixin { Q_GADGET public: + Q_DISABLE_COPY_MOVE(AbstractMetaClass) + enum FunctionQueryOption { Constructors = 0x0000001, // Only constructors //Destructors = 0x0000002, // Only destructors. Not included in class. @@ -97,8 +99,7 @@ public: void fixFunctions(); - const AbstractMetaFunctionList &functions() const { return m_functions; } - + const AbstractMetaFunctionList &functions() const; void setFunctions(const AbstractMetaFunctionList &functions); void addFunction(AbstractMetaFunction *function); bool hasFunction(const AbstractMetaFunction *f) const; @@ -108,31 +109,28 @@ public: bool hasConstructors() const; const AbstractMetaFunction *copyConstructor() const; - bool hasCopyConstructor() const { return copyConstructor() != nullptr; } + bool hasCopyConstructor() const; bool hasPrivateCopyConstructor() const; void addDefaultConstructor(); void addDefaultCopyConstructor(bool isPrivate = false); - bool hasNonPrivateConstructor() const { return m_hasNonPrivateConstructor; } - void setHasNonPrivateConstructor(bool value) { m_hasNonPrivateConstructor = value; } + bool hasNonPrivateConstructor() const; + void setHasNonPrivateConstructor(bool value); - bool hasPrivateConstructor() const { return m_hasPrivateConstructor; } - void setHasPrivateConstructor(bool value) { m_hasPrivateConstructor = value; } + bool hasPrivateConstructor() const; + void setHasPrivateConstructor(bool value); - bool hasPrivateDestructor() const { return m_hasPrivateDestructor; } - void setHasPrivateDestructor(bool value) { m_hasPrivateDestructor = value; } + bool hasPrivateDestructor() const; + void setHasPrivateDestructor(bool value); - bool hasProtectedDestructor() const { return m_hasProtectedDestructor; } - void setHasProtectedDestructor(bool value) { m_hasProtectedDestructor = value; } + bool hasProtectedDestructor() const; + void setHasProtectedDestructor(bool value); - bool hasVirtualDestructor() const { return m_hasVirtualDestructor; } + bool hasVirtualDestructor() const; void setHasVirtualDestructor(bool value); - bool isConstructible() const - { - return (hasNonPrivateConstructor() || !hasPrivateConstructor()) && !hasPrivateDestructor(); - } + bool isConstructible() const; bool generateExceptionHandling() const; @@ -163,17 +161,17 @@ public: bool hasComparisonOperatorOverload() const; bool hasLogicalOperatorOverload() const; - const AbstractMetaFieldList &fields() const { return m_fields; } - AbstractMetaFieldList &fields() { return m_fields; } - void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; } - void addField(const AbstractMetaField &field) { m_fields << field; } + const AbstractMetaFieldList &fields() const; + AbstractMetaFieldList &fields(); + void setFields(const AbstractMetaFieldList &fields); + void addField(const AbstractMetaField &field); 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(const AbstractMetaEnum &e) { m_enums << e; } + const AbstractMetaEnumList &enums() const; + AbstractMetaEnumList &enums(); + void setEnums(const AbstractMetaEnumList &enums); + void addEnum(const AbstractMetaEnum &e); std::optional<AbstractMetaEnum> findEnum(const QString &enumName) const; std::optional<AbstractMetaEnumValue> findEnumValue(const QString &enumName) const; @@ -182,10 +180,7 @@ public: void getFunctionsFromInvisibleNamespacesToBeGenerated(AbstractMetaFunctionList *funcList) const; - QString fullName() const - { - return package() + QLatin1Char('.') + name(); - } + QString fullName() const; /** * Retrieves the class name without any namespace/scope information. @@ -193,19 +188,13 @@ public: */ QString name() 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 baseClassName() const - { - return m_baseClasses.isEmpty() ? QString() : m_baseClasses.constFirst()->name(); - } + QString baseClassName() const; - AbstractMetaClass *baseClass() const - { - return m_baseClasses.value(0, nullptr); - } - const AbstractMetaClassList &baseClasses() const { return m_baseClasses; } + AbstractMetaClass *baseClass() const; + const AbstractMetaClassList &baseClasses() const; void addBaseClass(AbstractMetaClass *base_class); void setBaseClass(AbstractMetaClass *base_class); @@ -213,12 +202,12 @@ public: /** * \return the namespace from another package which this namespace extends. */ - AbstractMetaClass *extendedNamespace() const { return m_extendedNamespace; } - void setExtendedNamespace(AbstractMetaClass *e) { m_extendedNamespace = e; } + AbstractMetaClass *extendedNamespace() const; + void setExtendedNamespace(AbstractMetaClass *e); - const AbstractMetaClassList& innerClasses() const { return m_innerClasses; } - void addInnerClass(AbstractMetaClass* cl) { m_innerClasses << cl; } - void setInnerClasses(const AbstractMetaClassList &innerClasses) { m_innerClasses = innerClasses; } + const AbstractMetaClassList &innerClasses() const; + void addInnerClass(AbstractMetaClass* cl); + void setInnerClasses(const AbstractMetaClassList &innerClasses); QString package() const; @@ -227,10 +216,7 @@ public: bool isQObject() const; - bool isQtNamespace() const - { - return isNamespace() && name() == QLatin1String("Qt"); - } + bool isQtNamespace() const; QString qualifiedCppName() const; @@ -241,7 +227,7 @@ public: * Says if the class that declares or inherits a virtual function. * \return true if the class implements or inherits any virtual methods */ - bool isPolymorphic() const { return m_isPolymorphic; } + bool isPolymorphic() const; /** * Tells if this class has one or more functions that are protected. @@ -262,77 +248,64 @@ public: bool hasProtectedMembers() const; - const QVector<TypeEntry *> &templateArguments() const { return m_templateArgs; } - void setTemplateArguments(const QVector<TypeEntry *> &args) { m_templateArgs = args; } + const QVector<TypeEntry *> &templateArguments() const; + void setTemplateArguments(const QVector<TypeEntry *> &args); // only valid during metabuilder's run - const QStringList &baseClassNames() const { return m_baseClassNames; } - void setBaseClassNames(const QStringList &names) { m_baseClassNames = names; } + const QStringList &baseClassNames() const; + void setBaseClassNames(const QStringList &names); - const ComplexTypeEntry *typeEntry() const { return m_typeEntry; } - ComplexTypeEntry *typeEntry() { return m_typeEntry; } - void setTypeEntry(ComplexTypeEntry *type) { m_typeEntry = type; } + const ComplexTypeEntry *typeEntry() const; + ComplexTypeEntry *typeEntry(); + void setTypeEntry(ComplexTypeEntry *type); - void setHasHashFunction(bool on) { m_hasHashFunction = on; } + void setHasHashFunction(bool on); - bool hasHashFunction() const { return m_hasHashFunction; } + bool hasHashFunction() const; bool hasDefaultToStringFunction() const; - bool hasEqualsOperator() const { return m_hasEqualsOperator; } - void setHasEqualsOperator(bool on) { m_hasEqualsOperator = on; } + bool hasEqualsOperator() const; + void setHasEqualsOperator(bool on); - bool hasCloneOperator() const { return m_hasCloneOperator; } - void setHasCloneOperator(bool on) { m_hasCloneOperator = on; } + bool hasCloneOperator() const; + void setHasCloneOperator(bool on); - const QVector<QPropertySpec *> &propertySpecs() const { return m_propertySpecs; } - void addPropertySpec(QPropertySpec *spec) { m_propertySpecs << spec; } + const QVector<QPropertySpec *> &propertySpecs() const; + void addPropertySpec(QPropertySpec *spec); QPropertySpec *propertySpecByName(const QString &name) const; QPropertySpec *propertySpecForRead(const QString &name) const; QPropertySpec *propertySpecForWrite(const QString &name) const; QPropertySpec *propertySpecForReset(const QString &name) const; - /// Returns a list of conversion operators for this class. The conversion operators are defined in other classes of the same module. - AbstractMetaFunctionList externalConversionOperators() const - { - return m_externalConversionOperators; - } + /// Returns a list of conversion operators for this class. The conversion + /// operators are defined in other classes of the same module. + AbstractMetaFunctionList externalConversionOperators() const; /// Adds a converter operator for this class. - void addExternalConversionOperator(AbstractMetaFunction* conversionOp) - { - if (!m_externalConversionOperators.contains(conversionOp)) - m_externalConversionOperators.append(conversionOp); - } + void addExternalConversionOperator(AbstractMetaFunction* conversionOp); /// Returns true if this class has any converter operators defined elsewhere. - bool hasExternalConversionOperators() const - { - return !m_externalConversionOperators.isEmpty(); - } + bool hasExternalConversionOperators() const; void sortFunctions(); - const AbstractMetaClass *templateBaseClass() const { return m_templateBaseClass; } - void setTemplateBaseClass(const AbstractMetaClass *cls) { m_templateBaseClass = cls; } + const AbstractMetaClass *templateBaseClass() const; + void setTemplateBaseClass(const AbstractMetaClass *cls); bool hasTemplateBaseClassInstantiations() const; const AbstractMetaTypeList &templateBaseClassInstantiations() const; void setTemplateBaseClassInstantiations(const AbstractMetaTypeList& instantiations); - void setTypeDef(bool typeDef) { m_isTypeDef = typeDef; } - bool isTypeDef() const { return m_isTypeDef; } + void setTypeDef(bool typeDef); + bool isTypeDef() const; - bool isStream() const { return m_stream; } - void setStream(bool stream) { m_stream = stream; } + bool isStream() const; + void setStream(bool stream); - bool hasToStringCapability() const { return m_hasToStringCapability; } - void setToStringCapability(bool value, uint indirections = 0) - { - m_hasToStringCapability = value; - m_toStringCapabilityIndirections = indirections; - } + bool hasToStringCapability() const; + void setToStringCapability(bool value, uint indirections = 0); - uint toStringCapabilityIndirections() const { return m_toStringCapabilityIndirections; } + uint toStringCapabilityIndirections() const; bool deleteInMainThread() const; @@ -357,45 +330,8 @@ private: void formatMembers(QDebug &d) const; friend QDebug operator<<(QDebug d, const AbstractMetaClass *ac); #endif - uint m_hasVirtuals : 1; - uint m_isPolymorphic : 1; - uint m_hasNonpublic : 1; - uint m_hasNonPrivateConstructor : 1; - uint m_hasPrivateConstructor : 1; - uint m_functionsFixed : 1; - uint m_hasPrivateDestructor : 1; - uint m_hasProtectedDestructor : 1; - uint m_hasVirtualDestructor : 1; - uint m_hasHashFunction : 1; - uint m_hasEqualsOperator : 1; - uint m_hasCloneOperator : 1; - uint m_isTypeDef : 1; - uint m_hasToStringCapability : 1; - - Documentation m_doc; - - const AbstractMetaClass *m_enclosingClass = nullptr; - AbstractMetaClassList m_baseClasses; // Real base classes after setting up inheritance - AbstractMetaTypeList m_baseTemplateInstantiations; - AbstractMetaClass *m_extendedNamespace = nullptr; - - const AbstractMetaClass *m_templateBaseClass = nullptr; - AbstractMetaFunctionList m_functions; - AbstractMetaFieldList m_fields; - AbstractMetaEnumList m_enums; - QVector<QPropertySpec *> m_propertySpecs; - AbstractMetaClassList m_innerClasses; - - AbstractMetaFunctionList m_externalConversionOperators; - - QStringList m_baseClassNames; // Base class names from C++, including rejected - QVector<TypeEntry *> m_templateArgs; - ComplexTypeEntry *m_typeEntry = nullptr; - SourceLocation m_sourceLocation; -// FunctionModelItem m_qDebugStreamFunction; - - bool m_stream = false; - uint m_toStringCapabilityIndirections = 0; + + QScopedPointer<AbstractMetaClassPrivate> d; }; Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::FunctionQueryOptions) @@ -404,7 +340,7 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::OperatorQueryOptions) template <class Function> void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const { - for (auto ic : m_innerClasses) { + for (auto ic : innerClasses()) { if (ic->isInvisibleNamespace()) { f(ic); ic->invisibleNamespaceRecursion(f); diff --git a/sources/shiboken6/ApiExtractor/apiextractor.cpp b/sources/shiboken6/ApiExtractor/apiextractor.cpp index a6bdd3edb..dba0d23da 100644 --- a/sources/shiboken6/ApiExtractor/apiextractor.cpp +++ b/sources/shiboken6/ApiExtractor/apiextractor.cpp @@ -40,6 +40,7 @@ #include "typesystem.h" #include "fileout.h" #include "abstractmetabuilder.h" +#include "abstractmetaenum.h" #include "typedatabase.h" #include "typesystem.h" diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp index 59c062f8c..a88c8554a 100644 --- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp @@ -33,6 +33,7 @@ #include <QtTest/QTest> #include "testutil.h" #include <abstractmetalang.h> +#include <documentation.h> #include <modifications.h> #include <typesystem.h> #include <qtdocparser.h> diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp index 8bd830d14..7f0addd6b 100644 --- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp +++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp @@ -30,6 +30,7 @@ #include <QtTest/QTest> #include "testutil.h" #include <abstractmetalang.h> +#include <abstractmetaenum.h> #include <typesystem.h> void NamespaceTest::testNamespaceMembers() |