diff options
Diffstat (limited to 'src/qmlcompiler/qqmljsmetatypes_p.h')
| -rw-r--r-- | src/qmlcompiler/qqmljsmetatypes_p.h | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/src/qmlcompiler/qqmljsmetatypes_p.h b/src/qmlcompiler/qqmljsmetatypes_p.h new file mode 100644 index 0000000000..fdd93ed71a --- /dev/null +++ b/src/qmlcompiler/qqmljsmetatypes_p.h @@ -0,0 +1,200 @@ +/**************************************************************************** +** +** Copyright (C) 2019 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the tools applications of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLJSMETATYPES_P_H +#define QQMLJSMETATYPES_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. + +#include <QtCore/qstring.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qsharedpointer.h> + +// MetaMethod and MetaProperty have both type names and actual QQmlJSScope types. +// When parsing the information from the relevant QML or qmltypes files, we only +// see the names and don't have a complete picture of the types, yet. In a second +// pass we typically fill in the types. The types may have multiple exported names +// and the the name property of MetaProperty and MetaMethod still carries some +// significance regarding which name was chosen to refer to the type. In a third +// pass we may further specify the type if the context provides additional information. +// The parent of an Item, for example, is typically not just a QtObject, but rather +// some other Item with custom properties. + +class QQmlJSScope; +class QQmlJSMetaEnum +{ + QStringList m_keys; + QString m_name; + QString m_alias; + bool m_isFlag = false; + +public: + QQmlJSMetaEnum() = default; + explicit QQmlJSMetaEnum(QString name) : m_name(std::move(name)) {} + + bool isValid() const { return !m_name.isEmpty(); } + + QString name() const { return m_name; } + void setName(const QString &name) { m_name = name; } + + QString alias() const { return m_alias; } + void setAlias(const QString &alias) { m_alias = alias; } + + bool isFlag() const { return m_isFlag; } + void setIsFlag(bool isFlag) { m_isFlag = isFlag; } + + void addKey(const QString &key) { m_keys.append(key); } + QStringList keys() const { return m_keys; } +}; + +class QQmlJSMetaMethod +{ +public: + enum Type { + Signal, + Slot, + Method + }; + + enum Access { + Private, + Protected, + Public + }; + + QQmlJSMetaMethod() = default; + explicit QQmlJSMetaMethod(QString name, QString returnType = QString()) + : m_name(std::move(name)) + , m_returnTypeName(std::move(returnType)) + , m_methodType(Method) + , m_methodAccess(Public) + {} + + QString methodName() const { return m_name; } + void setMethodName(const QString &name) { m_name = name; } + + QString returnTypeName() const { return m_returnTypeName; } + QSharedPointer<const QQmlJSScope> returnType() const { return m_returnType.toStrongRef(); } + void setReturnTypeName(const QString &type) { m_returnTypeName = type; } + void setReturnType(const QSharedPointer<const QQmlJSScope> &type) + { + m_returnType = type; + } + + QStringList parameterNames() const { return m_paramNames; } + QStringList parameterTypeNames() const { return m_paramTypeNames; } + QList<QSharedPointer<const QQmlJSScope>> parameterTypes() const + { + QList<QSharedPointer<const QQmlJSScope>> result; + for (const auto &type : m_paramTypes) + result.append(type.toStrongRef()); + return result; + } + void setParameterTypes(const QList<QSharedPointer<const QQmlJSScope>> &types) + { + Q_ASSERT(types.length() == m_paramNames.length()); + m_paramTypes.clear(); + for (const auto &type : types) + m_paramTypes.append(type); + } + void addParameter(const QString &name, const QString &typeName, + const QSharedPointer<const QQmlJSScope> &type = {}) + { + m_paramNames.append(name); + m_paramTypeNames.append(typeName); + m_paramTypes.append(type); + } + + int methodType() const { return m_methodType; } + void setMethodType(Type methodType) { m_methodType = methodType; } + + Access access() const { return m_methodAccess; } + + int revision() const { return m_revision; } + void setRevision(int r) { m_revision = r; } + +private: + QString m_name; + QString m_returnTypeName; + QWeakPointer<const QQmlJSScope> m_returnType; + + QStringList m_paramNames; + QStringList m_paramTypeNames; + QList<QWeakPointer<const QQmlJSScope>> m_paramTypes; + + Type m_methodType = Signal; + Access m_methodAccess = Private; + int m_revision = 0; +}; + +class QQmlJSMetaProperty +{ + QString m_propertyName; + QString m_typeName; + QWeakPointer<const QQmlJSScope> m_type; + bool m_isList; + bool m_isWritable; + bool m_isPointer; + bool m_isAlias; + int m_revision; + +public: + QQmlJSMetaProperty(QString propertyName, QString typeName, + bool isList, bool isWritable, bool isPointer, bool isAlias, + int revision) + : m_propertyName(std::move(propertyName)) + , m_typeName(std::move(typeName)) + , m_isList(isList) + , m_isWritable(isWritable) + , m_isPointer(isPointer) + , m_isAlias(isAlias) + , m_revision(revision) + {} + + QString propertyName() const { return m_propertyName; } + QString typeName() const { return m_typeName; } + + void setType(const QSharedPointer<const QQmlJSScope> &type) { m_type = type; } + QSharedPointer<const QQmlJSScope> type() const { return m_type.toStrongRef(); } + + bool isList() const { return m_isList; } + bool isWritable() const { return m_isWritable; } + bool isPointer() const { return m_isPointer; } + bool isAlias() const { return m_isAlias; } + int revision() const { return m_revision; } +}; + +#endif // QQMLJSMETATYPES_P_H |