##// END OF EJS Templates
fix PythonQt*Config.cmake _again_
fix PythonQt*Config.cmake _again_

File last commit:

r175:7bc6abba6c12
r214:10ef09a17283 master
Show More
abstractmetalang.h
946 lines | 36.2 KiB | text/x-c | CLexer
/****************************************************************************
**
** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Script Generator project on Qt Labs.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef ABSTRACTMETALANG_H
#define ABSTRACTMETALANG_H
#include "codemodel.h"
#include "typesystem.h"
#include <QSet>
#include <QStringList>
#include <QTextStream>
class AbstractMeta;
class AbstractMetaClass;
class AbstractMetaField;
class AbstractMetaFunction;
class AbstractMetaType;
class AbstractMetaVariable;
class AbstractMetaArgument;
class AbstractMetaEnumValue;
class AbstractMetaEnum;
class QPropertySpec;
typedef QList<AbstractMetaField *> AbstractMetaFieldList;
typedef QList<AbstractMetaArgument *> AbstractMetaArgumentList;
typedef QList<AbstractMetaFunction *> AbstractMetaFunctionList;
class AbstractMetaClassList : public QList<AbstractMetaClass *>
{
public:
AbstractMetaClass *findClass(const QString &name) const;
AbstractMetaEnumValue *findEnumValue(const QString &string) const;
AbstractMetaEnum *findEnum(const EnumTypeEntry *entry) const;
};
class AbstractMetaAttributes
{
public:
AbstractMetaAttributes() : m_attributes(0) { };
enum Attribute {
None = 0x00000000,
Private = 0x00000001,
Protected = 0x00000002,
Public = 0x00000004,
Friendly = 0x00000008,
Visibility = 0x0000000f,
Native = 0x00000010,
Abstract = 0x00000020,
Static = 0x00000040,
FinalInTargetLang = 0x00000080,
FinalInCpp = 0x00000100,
ForceShellImplementation = 0x00000200,
GetterFunction = 0x00000400,
SetterFunction = 0x00000800,
FinalOverload = 0x00001000,
InterfaceFunction = 0x00002000,
PropertyReader = 0x00004000,
PropertyWriter = 0x00008000,
PropertyResetter = 0x00010000,
Fake = 0x00020000,
Invokable = 0x00040000,
Final = FinalInTargetLang | FinalInCpp
};
uint attributes() const { return m_attributes; }
void setAttributes(uint attributes) { m_attributes = attributes; }
uint originalAttributes() const { return m_originalAttributes; }
void setOriginalAttributes(uint attributes) { m_originalAttributes = attributes; }
uint visibility() const { return m_attributes & Visibility; }
void setVisibility(uint visi) { m_attributes = (m_attributes & ~Visibility) | visi; }
void operator+=(Attribute attribute) { m_attributes |= attribute; }
void operator-=(Attribute attribute) { m_attributes &= ~attribute; }
bool isNative() const { return m_attributes & Native; }
bool isFinal() const { return (m_attributes & Final) == Final; }
bool isFinalInTargetLang() const { return m_attributes & FinalInTargetLang; }
bool isFinalInCpp() const { return m_attributes & FinalInCpp; }
bool isAbstract() const { return m_attributes & Abstract; }
bool isStatic() const { return m_attributes & Static; }
bool isForcedShellImplementation() const { return m_attributes & ForceShellImplementation; }
bool isInterfaceFunction() const { return m_attributes & InterfaceFunction; }
bool isFinalOverload() const { return m_attributes & FinalOverload; }
bool isInvokable() const { return m_attributes & Invokable; }
bool isPropertyReader() const { return m_attributes & PropertyReader; }
bool isPropertyWriter() const { return m_attributes & PropertyWriter; }
bool isPropertyResetter() const { return m_attributes & PropertyResetter; }
bool isPrivate() const { return m_attributes & Private; }
bool isProtected() const { return m_attributes & Protected; }
bool isPublic() const { return m_attributes & Public; }
bool isFriendly() const { return m_attributes & Friendly; }
bool wasPrivate() const { return m_originalAttributes & Private; }
bool wasProtected() const { return m_originalAttributes & Protected; }
bool wasPublic() const { return m_originalAttributes & Public; }
bool wasFriendly() const { return m_originalAttributes & Friendly; }
private:
uint m_attributes;
uint m_originalAttributes;
};
class AbstractMetaType
{
public:
enum TypeUsagePattern {
InvalidPattern,
PrimitivePattern,
FlagsPattern,
EnumPattern,
ValuePattern,
StringPattern,
CharPattern,
ObjectPattern,
QObjectPattern,
NativePointerPattern,
ContainerPattern,
VariantPattern,
JObjectWrapperPattern,
ArrayPattern,
ThreadPattern
};
AbstractMetaType() :
m_type_entry(0),
m_array_element_count(0),
m_array_element_type(0),
m_original_template_type(0),
m_pattern(InvalidPattern),
m_constant(false),
m_reference(false),
m_cpp_instantiation(true),
m_indirections(0),
m_reserved(0)
{
}
QString package() const { return m_type_entry->javaPackage(); }
QString name() const { return m_type_entry->targetLangName(); }
QString fullName() const { return m_type_entry->qualifiedTargetLangName(); }
void setTypeUsagePattern(TypeUsagePattern pattern) { m_pattern = pattern; }
TypeUsagePattern typeUsagePattern() const { return m_pattern; }
// true when use pattern is container
bool hasInstantiations() const { return !m_instantiations.isEmpty(); }
void addInstantiation(AbstractMetaType *inst) { m_instantiations << inst; }
void setInstantiations(const QList<AbstractMetaType *> &insts) { m_instantiations = insts; }
QList<AbstractMetaType *> instantiations() const { return m_instantiations; }
void setInstantiationInCpp(bool incpp) { m_cpp_instantiation = incpp; }
bool hasInstantiationInCpp() const { return hasInstantiations() && m_cpp_instantiation; }
QString minimalSignature() const;
// true when the type is a QtJambiObject subclass
bool hasNativeId() const;
// returns true if the typs is used as a non complex primitive, no & or *'s
bool isPrimitive() const { return m_pattern == PrimitivePattern; }
// returns true if the type is used as an enum
bool isEnum() const { return m_pattern == EnumPattern; }
// returns true if the type is used as a QObject *
bool isQObject() const { return m_pattern == QObjectPattern; }
// returns true if the type is used as an object, e.g. Xxx *
bool isObject() const { return m_pattern == ObjectPattern; }
// returns true if the type is used as an array, e.g. Xxx[42]
bool isArray() const { return m_pattern == ArrayPattern; }
// returns true if the type is used as a value type (X or const X &)
bool isValue() const { return m_pattern == ValuePattern; }
// returns true for more complex types...
bool isNativePointer() const { return m_pattern == NativePointerPattern; }
// returns true if the type was originally a QString or const QString & or equivalent for QLatin1String
bool isTargetLangString() const { return m_pattern == StringPattern; }
// returns true if the type was originally a QChar or const QChar &
bool isTargetLangChar() const { return m_pattern == CharPattern; }
// return true if the type was originally a QVariant or const QVariant &
bool isVariant() const { return m_pattern == VariantPattern; }
// return true if the type was originally a JObjectWrapper or const JObjectWrapper &
bool isJObjectWrapper() const { return m_pattern == JObjectWrapperPattern; }
// returns true if the type was used as a container
bool isContainer() const { return m_pattern == ContainerPattern; }
// returns true if the type was used as a flag
bool isFlags() const { return m_pattern == FlagsPattern; }
// returns true if the type was used as a thread
bool isThread() const { return m_pattern == ThreadPattern; }
bool isConstant() const { return m_constant; }
void setConstant(bool constant) { m_constant = constant; }
bool isReference() const { return m_reference; }
void setReference(bool ref) { m_reference = ref; }
// Returns true if the type is to be implemented using Java enums, e.g. not plain ints.
bool isTargetLangEnum() const { return isEnum() && !((EnumTypeEntry *) typeEntry())->forceInteger(); }
bool isIntegerEnum() const { return isEnum() && !isTargetLangEnum(); }
// Returns true if the type is to be implemented using Java QFlags, e.g. not plain ints.
bool isTargetLangFlags() const {
return isFlags() && !((FlagsTypeEntry *) typeEntry())->forceInteger(); }
bool isIntegerFlags() const { return isFlags() && !isTargetLangFlags(); }
int actualIndirections() const { return m_indirections + (isReference() ? 1 : 0); }
int indirections() const { return m_indirections; }
void setIndirections(int indirections) { m_indirections = indirections; }
void setArrayElementCount(int n) { m_array_element_count = n; }
int arrayElementCount() const { return m_array_element_count; }
AbstractMetaType *arrayElementType() const { return m_array_element_type; }
void setArrayElementType(AbstractMetaType *t) { m_array_element_type = t; }
QString cppSignature() const;
AbstractMetaType *copy() const;
const TypeEntry *typeEntry() const { return m_type_entry; }
void setTypeEntry(const TypeEntry *type) { m_type_entry = type; }
void setOriginalTypeDescription(const QString &otd) { m_original_type_description = otd; }
QString originalTypeDescription() const { return m_original_type_description; }
void setOriginalTemplateType(const AbstractMetaType *type) { m_original_template_type = type; }
const AbstractMetaType *originalTemplateType() const { return m_original_template_type; }
private:
const TypeEntry *m_type_entry;
QList <AbstractMetaType *> m_instantiations;
QString m_package;
QString m_original_type_description;
int m_array_element_count;
AbstractMetaType *m_array_element_type;
const AbstractMetaType *m_original_template_type;
TypeUsagePattern m_pattern;
uint m_constant : 1;
uint m_reference : 1;
uint m_cpp_instantiation : 1;
int m_indirections : 4;
uint m_reserved : 25; // unused
};
class AbstractMetaVariable
{
public:
AbstractMetaVariable() : m_type(0) { }
AbstractMetaType *type() const { return m_type; }
void setType(AbstractMetaType *type) { m_type = type; }
QString name() const { return m_name; }
void setName(const QString &name) { m_name = name; }
private:
QString m_name;
AbstractMetaType *m_type;
};
class AbstractMetaArgument : public AbstractMetaVariable
{
public:
AbstractMetaArgument() : m_argument_index(0) { };
QString defaultValueExpression() const { return m_expression; }
void setDefaultValueExpression(const QString &expr) { m_expression = expr; }
QString originalDefaultValueExpression() const { return m_original_expression; }
void setOriginalDefaultValueExpression(const QString &expr) { m_original_expression = expr; }
QString toString() const { return type()->name() + " " + AbstractMetaVariable::name() +
(m_expression.isEmpty() ? "" : " = " + m_expression); }
int argumentIndex() const { return m_argument_index; }
void setArgumentIndex(int argIndex) { m_argument_index = argIndex; }
QString argumentName() const;
QString indexedName() const;
AbstractMetaArgument *copy() const;
private:
// Just to force people to call argumentName() And indexedName();
QString name() const;
QString m_expression;
QString m_original_expression;
int m_argument_index;
};
class AbstractMetaField : public AbstractMetaVariable, public AbstractMetaAttributes
{
public:
AbstractMetaField();
~AbstractMetaField();
const AbstractMetaClass *enclosingClass() const { return m_class; }
void setEnclosingClass(const AbstractMetaClass *cls) { m_class = cls; }
const AbstractMetaFunction *getter() const;
const AbstractMetaFunction *setter() const;
FieldModificationList modifications() const;
AbstractMetaField *copy() const;
private:
mutable AbstractMetaFunction *m_getter;
mutable AbstractMetaFunction *m_setter;
const AbstractMetaClass *m_class;
};
class AbstractMetaFunction : public AbstractMetaAttributes
{
public:
enum FunctionType {
ConstructorFunction,
DestructorFunction,
NormalFunction,
SignalFunction,
EmptyFunction,
SlotFunction,
GlobalScopeFunction
};
enum CompareResult {
EqualName = 0x00000001,
EqualArguments = 0x00000002,
EqualAttributes = 0x00000004,
EqualImplementor = 0x00000008,
EqualReturnType = 0x00000010,
EqualDefaultValueOverload = 0x00000020,
EqualModifiedName = 0x00000040,
NameLessThan = 0x00001000,
PrettySimilar = EqualName | EqualArguments,
Equal = 0x0000001f,
NotEqual = 0x00001000
};
AbstractMetaFunction()
: m_function_type(NormalFunction),
m_type(0),
m_class(0),
m_implementing_class(0),
m_declaring_class(0),
m_interface_class(0),
m_property_spec(0),
m_constant(false),
m_invalid(false)
{
}
~AbstractMetaFunction();
QString name() const { return m_name; }
void setName(const QString &name) { m_name = name; }
QString originalName() const { return m_original_name.isEmpty() ? name() : m_original_name; }
void setOriginalName(const QString &name) { m_original_name = name; }
QString modifiedName() const;
QString minimalSignature() const;
QStringList possibleIntrospectionCompatibleSignatures() const;
QString marshalledName() const;
// true if one or more of the arguments are of QtJambiObject subclasses
bool argumentsHaveNativeId() const
{
foreach (const AbstractMetaArgument *arg, m_arguments) {
if (arg->type()->hasNativeId())
return true;
}
return false;
}
bool isModifiedRemoved(int types = TypeSystem::All) const;
AbstractMetaType *type() const { return m_type; }
void setType(AbstractMetaType *type) { m_type = type; }
// The class that has this function as a member.
const AbstractMetaClass *ownerClass() const { return m_class; }
void setOwnerClass(const AbstractMetaClass *cls) { m_class = cls; }
// The first class in a hierarchy that declares the function
const AbstractMetaClass *declaringClass() const { return m_declaring_class; }
void setDeclaringClass(const AbstractMetaClass *cls) { m_declaring_class = cls; }
// The class that actually implements this function
const AbstractMetaClass *implementingClass() const { return m_implementing_class; }
void setImplementingClass(const AbstractMetaClass *cls) { m_implementing_class = cls; }
bool needsCallThrough() const;
AbstractMetaArgumentList arguments() const { return m_arguments; }
void setArguments(const AbstractMetaArgumentList &arguments) { m_arguments = arguments; }
void addArgument(AbstractMetaArgument *argument) { m_arguments << argument; }
int actualMinimumArgumentCount() const;
void setInvalid(bool on) { m_invalid = on; }
bool isInvalid() const { return m_invalid; }
bool isDeprecated() const;
bool isDestructor() const { return functionType() == DestructorFunction; }
bool isConstructor() const { return functionType() == ConstructorFunction; }
bool isNormal() const { return functionType() == NormalFunction || isSlot() || isInGlobalScope(); }
bool isInGlobalScope() const { return functionType() == GlobalScopeFunction; }
bool isSignal() const { return functionType() == SignalFunction; }
bool isSlot() const { return functionType() == SlotFunction; }
bool isEmptyFunction() const { return functionType() == EmptyFunction; }
FunctionType functionType() const { return m_function_type; }
void setFunctionType(FunctionType type) { m_function_type = type; }
bool isVirtual() const { return !(isFinal() || isSignal() || isStatic()); }
QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
QString signature() const;
QString targetLangSignature(bool minimal = false) const;
bool shouldReturnThisObject() const { return QLatin1String("this") == argumentReplaced(0); }
bool shouldIgnoreReturnValue() const { return QLatin1String("void") == argumentReplaced(0); }
bool isConstant() const { return m_constant; }
void setConstant(bool constant) { m_constant = constant; }
QString toString() const { return m_name; }
uint compareTo(const AbstractMetaFunction *other) const;
bool operator <(const AbstractMetaFunction &a) const;
AbstractMetaFunction *copy() const;
QString replacedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
bool removedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
QString conversionRule(TypeSystem::Language language, int idx) const;
QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
bool nullPointersDisabled(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
QString nullPointerDefaultValue(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
bool resetObjectAfterUse(int argument_idx) const;
// Returns whether garbage collection is disabled for the argument in any context
bool disabledGarbageCollection(const AbstractMetaClass *cls, int key) const;
// Returns the ownership rules for the given argument in the given context
TypeSystem::Ownership ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int idx) const;
bool isVirtualSlot() const;
QString typeReplaced(int argument_index) const;
bool isRemovedFromAllLanguages(const AbstractMetaClass *) const;
bool isRemovedFrom(const AbstractMetaClass *, TypeSystem::Language language) const;
bool argumentRemoved(int) const;
QString argumentReplaced(int key) const;
bool needsSuppressUncheckedWarning() const;
bool hasModifications(const AbstractMetaClass *implementor) const;
FunctionModificationList modifications(const AbstractMetaClass *implementor) const;
// If this function stems from an interface, this returns the
// interface that declares it.
const AbstractMetaClass *interfaceClass() const { return m_interface_class; }
void setInterfaceClass(const AbstractMetaClass *cl) { m_interface_class = cl; }
void setPropertySpec(QPropertySpec *spec) { m_property_spec = spec; }
QPropertySpec *propertySpec() const { return m_property_spec; }
private:
QString m_name;
QString m_original_name;
mutable QString m_cached_minimal_signature;
mutable QString m_cached_modified_name;
FunctionType m_function_type;
AbstractMetaType *m_type;
const AbstractMetaClass *m_class;
const AbstractMetaClass *m_implementing_class;
const AbstractMetaClass *m_declaring_class;
const AbstractMetaClass *m_interface_class;
QPropertySpec *m_property_spec;
AbstractMetaArgumentList m_arguments;
uint m_constant : 1;
uint m_invalid : 1;
};
class AbstractMetaEnumValue
{
public:
AbstractMetaEnumValue()
: m_value_set(false), m_value(0)
{
}
int value() const { return m_value; }
void setValue(int value) { m_value_set = true; m_value = value; }
QString stringValue() const { return m_string_value; }
void setStringValue(const QString &v) { m_string_value = v; }
QString name() const { return m_name; }
void setName(const QString &name) { m_name = name; }
bool isValueSet() const { return m_value_set; }
private:
QString m_name;
QString m_string_value;
bool m_value_set;
int m_value;
};
class AbstractMetaEnumValueList : public QList<AbstractMetaEnumValue *>
{
public:
AbstractMetaEnumValue *find(const QString &name) const;
};
class AbstractMetaEnum : public AbstractMetaAttributes
{
public:
AbstractMetaEnum() : m_type_entry(0), m_class(0), m_has_qenums_declaration(false) {}
AbstractMetaEnumValueList values() const { return m_enum_values; }
void addEnumValue(AbstractMetaEnumValue *enumValue) { m_enum_values << enumValue; }
QString name() const { return m_type_entry->targetLangName(); }
QString qualifier() const { return m_type_entry->javaQualifier(); }
QString package() const { return m_type_entry->javaPackage(); }
QString fullName() const { return package() + "." + qualifier() + "." + name(); }
// Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
void setHasQEnumsDeclaration(bool on) { m_has_qenums_declaration = on; }
bool hasQEnumsDeclaration() const { return m_has_qenums_declaration; }
EnumTypeEntry *typeEntry() const { return m_type_entry; }
void setTypeEntry(EnumTypeEntry *entry) { m_type_entry = entry; }
AbstractMetaClass *enclosingClass() const { return m_class; }
void setEnclosingClass(AbstractMetaClass *c) { m_class = c; }
private:
AbstractMetaEnumValueList m_enum_values;
EnumTypeEntry *m_type_entry;
AbstractMetaClass *m_class;
uint m_has_qenums_declaration : 1;
uint m_reserved : 31;
};
typedef QList<AbstractMetaEnum *> AbstractMetaEnumList;
class AbstractMetaClass : public AbstractMetaAttributes
{
public:
enum FunctionQueryOption {
Constructors = 0x000001, // Only constructors
//Destructors = 0x000002, // Only destructors. Not included in class.
VirtualFunctions = 0x000004, // Only virtual functions (virtual in both TargetLang and C++)
FinalInTargetLangFunctions = 0x000008, // Only functions that are non-virtual in TargetLang
FinalInCppFunctions = 0x000010, // Only functions that are non-virtual in C++
ClassImplements = 0x000020, // Only functions implemented by the current class
Inconsistent = 0x000040, // Only inconsistent functions (inconsistent virtualness in TargetLang/C++)
StaticFunctions = 0x000080, // Only static functions
Signals = 0x000100, // Only signals
NormalFunctions = 0x000200, // Only functions that aren't signals
Visible = 0x000400, // Only public and protected functions
ForcedShellFunctions = 0x000800, // Only functions that are overridden to be implemented in the shell class
WasPublic = 0x001000, // Only functions that were originally public
WasProtected = 0x002000, // Only functions that were originally protected
NonStaticFunctions = 0x004000, // No static functions
Empty = 0x008000, // Empty overrides of abstract functions
Invisible = 0x010000, // Only private functions
VirtualInCppFunctions = 0x020000, // Only functions that are virtual in C++
NonEmptyFunctions = 0x040000, // Only functions with JNI implementations
VirtualInTargetLangFunctions = 0x080000, // Only functions which are virtual in TargetLang
AbstractFunctions = 0x100000, // Only abstract functions
WasVisible = 0x200000, // Only functions that were public or protected in the original code
NotRemovedFromTargetLang = 0x400000, // Only functions that have not been removed from TargetLang
NotRemovedFromShell = 0x800000, // Only functions that have not been removed from the shell class
VirtualSlots = 0x1000000 // Only functions that are set as virtual slots in the type system
};
AbstractMetaClass()
: m_namespace(false),
m_qobject(false),
m_has_virtuals(false),
m_has_nonpublic(false),
m_has_virtual_slots(false),
m_has_nonprivateconstructor(false),
m_functions_fixed(false),
m_has_public_destructor(true),
m_force_shell_class(false),
m_has_hash_function(false),
m_has_equals_operator(false),
m_has_clone_operator(false),
m_is_type_alias(false),
m_enclosing_class(0),
m_base_class(0),
m_template_base_class(0),
m_extracted_interface(0),
m_primary_interface_implementor(0),
m_type_entry(0),
m_qDebug_stream_function(0)
{
}
virtual ~AbstractMetaClass();
AbstractMetaClass *extractInterface();
void fixFunctions();
AbstractMetaFunctionList functions() const { return m_functions; }
void setFunctions(const AbstractMetaFunctionList &functions);
void addFunction(AbstractMetaFunction *function);
bool hasFunction(const AbstractMetaFunction *f) const;
bool hasFunction(const QString &str) const;
bool hasSignal(const AbstractMetaFunction *f) const;
bool hasConstructors() const;
void addDefaultConstructor();
bool hasNonPrivateConstructor() const { return m_has_nonprivateconstructor; }
void setHasNonPrivateConstructor(bool on) { m_has_nonprivateconstructor = on; }
bool hasPublicDestructor() const { return m_has_public_destructor; }
void setHasPublicDestructor(bool on) { m_has_public_destructor = on; }
AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
AbstractMetaFunctionList queryFunctions(uint query) const;
inline AbstractMetaFunctionList allVirtualFunctions() const;
inline AbstractMetaFunctionList allFinalFunctions() const;
AbstractMetaFunctionList functionsInTargetLang() const;
AbstractMetaFunctionList functionsInShellClass() const;
inline AbstractMetaFunctionList cppInconsistentFunctions() const;
inline AbstractMetaFunctionList cppSignalFunctions() const;
AbstractMetaFunctionList publicOverrideFunctions() const;
AbstractMetaFunctionList virtualOverrideFunctions() const;
AbstractMetaFunctionList virtualFunctions() const;
AbstractMetaFunctionList nonVirtualShellFunctions() const;
AbstractMetaFieldList fields() const { return m_fields; }
void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; }
void addField(AbstractMetaField *field) { m_fields << field; }
AbstractMetaEnumList enums() const { return m_enums; }
void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
void addEnum(AbstractMetaEnum *e) { m_enums << e; }
AbstractMetaEnum *findEnum(const QString &enumName);
AbstractMetaEnum *findEnumForValue(const QString &enumName);
AbstractMetaEnumValue *findEnumValue(const QString &enumName, AbstractMetaEnum *meta_enum);
AbstractMetaClassList interfaces() const { return m_interfaces; }
void addInterface(AbstractMetaClass *interface);
void setInterfaces(const AbstractMetaClassList &interface);
QString fullName() const { return package() + "." + name(); }
QString name() const;
QString baseClassName() const { return m_base_class ? m_base_class->name() : QString(); }
AbstractMetaClass *baseClass() const { return m_base_class; }
void setBaseClass(AbstractMetaClass *base_class) { m_base_class = base_class; }
const AbstractMetaClass *enclosingClass() const { return m_enclosing_class; }
void setEnclosingClass(AbstractMetaClass *cl) { m_enclosing_class = cl; }
QString package() const { return m_type_entry->javaPackage(); }
bool isInterface() const { return m_type_entry->isInterface(); }
bool isNamespace() const { return m_type_entry->isNamespace(); }
bool isQObject() const { return m_type_entry->isQObject(); }
bool isQtNamespace() const { return isNamespace() && name() == "Qt"; }
QString qualifiedCppName() const { return m_type_entry->qualifiedCppName(); }
bool hasInconsistentFunctions() const;
bool hasSignals() const;
bool inheritsFrom(const AbstractMetaClass *other) const;
void setForceShellClass(bool on) { m_force_shell_class = on; }
bool generateShellClass() const;
bool hasVirtualSlots() const { return m_has_virtual_slots; }
bool hasVirtualFunctions() const { return !isFinal() && m_has_virtuals; }
bool hasProtectedFunctions() const;
QList<TypeEntry *> templateArguments() const { return m_template_args; }
void setTemplateArguments(const QList<TypeEntry *> &args) { m_template_args = args; }
bool hasFieldAccessors() const;
// only valid during metajavabuilder's run
QStringList baseClassNames() const { return m_base_class_names; }
void setBaseClassNames(const QStringList &names) { m_base_class_names = names; }
AbstractMetaClass *primaryInterfaceImplementor() const { return m_primary_interface_implementor; }
void setPrimaryInterfaceImplementor(AbstractMetaClass *cl) { m_primary_interface_implementor = cl; }
const ComplexTypeEntry *typeEntry() const { return m_type_entry; }
ComplexTypeEntry *typeEntry() { return m_type_entry; }
void setTypeEntry(ComplexTypeEntry *type) { m_type_entry = type; }
void setHasHashFunction(bool on) { m_has_hash_function = on; }
bool hasHashFunction() const { return m_has_hash_function; }
void setToStringCapability(FunctionModelItem fun) { m_qDebug_stream_function= fun; }
FunctionModelItem hasToStringCapability() const { return m_qDebug_stream_function; }
virtual bool hasDefaultToStringFunction() const;
void setHasEqualsOperator(bool on) { m_has_equals_operator = on; }
bool hasEqualsOperator() const { return m_has_equals_operator; }
void setHasCloneOperator(bool on) { m_has_clone_operator = on; }
bool hasCloneOperator() const { return m_has_clone_operator; }
bool hasDefaultIsNull() const;
void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
QList<QPropertySpec *> propertySpecs() const { return m_property_specs; }
QPropertySpec *propertySpecForRead(const QString &name) const;
QPropertySpec *propertySpecForWrite(const QString &name) const;
QPropertySpec *propertySpecForReset(const QString &name) const;
QList<ReferenceCount> referenceCounts() const;
void setEqualsFunctions(const AbstractMetaFunctionList &lst) { m_equals_functions = lst; }
AbstractMetaFunctionList equalsFunctions() const { return m_equals_functions; }
void setNotEqualsFunctions(const AbstractMetaFunctionList &lst) { m_nequals_functions = lst; }
AbstractMetaFunctionList notEqualsFunctions() const { return m_nequals_functions; }
void setLessThanFunctions(const AbstractMetaFunctionList &lst) { m_less_than_functions = lst; }
AbstractMetaFunctionList lessThanFunctions() const { return m_less_than_functions; }
void setGreaterThanFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_functions = lst; }
AbstractMetaFunctionList greaterThanFunctions() const { return m_greater_than_functions; }
void setLessThanEqFunctions(const AbstractMetaFunctionList &lst) { m_less_than_eq_functions = lst; }
AbstractMetaFunctionList lessThanEqFunctions() const { return m_less_than_eq_functions; }
void setGreaterThanEqFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_eq_functions = lst; }
AbstractMetaFunctionList greaterThanEqFunctions() const { return m_greater_than_eq_functions; }
void sortFunctions();
const AbstractMetaClass *templateBaseClass() const { return m_template_base_class; }
void setTemplateBaseClass(const AbstractMetaClass *cls) { m_template_base_class = cls; }
void setTypeAlias(bool typeAlias) { m_is_type_alias = typeAlias; }
bool isTypeAlias() const { return m_is_type_alias; }
bool operator <(const AbstractMetaClass &a) const {
return qualifiedCppName() < a.qualifiedCppName();
}
private:
uint m_namespace : 1;
uint m_qobject : 1;
uint m_has_virtuals : 1;
uint m_has_nonpublic : 1;
uint m_has_virtual_slots : 1;
uint m_has_nonprivateconstructor : 1;
uint m_functions_fixed : 1;
uint m_has_public_destructor : 1;
uint m_force_shell_class : 1;
uint m_has_hash_function : 1;
uint m_has_equals_operator : 1;
uint m_has_clone_operator :1;
uint m_is_type_alias : 1;
uint m_reserved : 19;
const AbstractMetaClass *m_enclosing_class;
AbstractMetaClass *m_base_class;
const AbstractMetaClass *m_template_base_class;
AbstractMetaFunctionList m_functions;
AbstractMetaFieldList m_fields;
AbstractMetaEnumList m_enums;
AbstractMetaClassList m_interfaces;
AbstractMetaClass *m_extracted_interface;
AbstractMetaClass *m_primary_interface_implementor;
QList<QPropertySpec *> m_property_specs;
AbstractMetaFunctionList m_equals_functions;
AbstractMetaFunctionList m_nequals_functions;
AbstractMetaFunctionList m_less_than_functions;
AbstractMetaFunctionList m_greater_than_functions;
AbstractMetaFunctionList m_less_than_eq_functions;
AbstractMetaFunctionList m_greater_than_eq_functions;
QStringList m_base_class_names;
QList<TypeEntry *> m_template_args;
ComplexTypeEntry *m_type_entry;
FunctionModelItem m_qDebug_stream_function;
};
class QPropertySpec {
public:
QPropertySpec(const TypeEntry *type)
: m_type(type),
m_index(-1)
{
}
const TypeEntry *type() const { return m_type; }
QString name() const { return m_name; }
void setName(const QString &name) { m_name = name; }
QString read() const { return m_read; }
void setRead(const QString &read) { m_read = read; }
QString write() const { return m_write; }
void setWrite(const QString &write) { m_write = write; }
QString designable() const { return m_designable; }
void setDesignable(const QString &designable) { m_designable = designable; }
QString reset() const { return m_reset; }
void setReset(const QString &reset) { m_reset = reset; }
int index() const { return m_index; }
void setIndex(int index) { m_index = index; }
private:
QString m_name;
QString m_read;
QString m_write;
QString m_designable;
QString m_reset;
const TypeEntry *m_type;
int m_index;
};
inline AbstractMetaFunctionList AbstractMetaClass::allVirtualFunctions() const
{
return queryFunctions(VirtualFunctions
| NotRemovedFromTargetLang);
}
inline AbstractMetaFunctionList AbstractMetaClass::allFinalFunctions() const
{
return queryFunctions(FinalInTargetLangFunctions
| FinalInCppFunctions
| NotRemovedFromTargetLang);
}
inline AbstractMetaFunctionList AbstractMetaClass::cppInconsistentFunctions() const
{
return queryFunctions(Inconsistent
| NormalFunctions
| Visible
| NotRemovedFromTargetLang);
}
inline AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
{
return queryFunctions(Signals
| Visible
| NotRemovedFromTargetLang);
}
#endif // ABSTRACTMETALANG_H