Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #ifndef QMETAOBJECTBUILDER_P_H
++ #define QMETAOBJECTBUILDER_P_H
++
++ //
++ // W A R N I N G
++ // -------------
++ //
++ // This file is not part of the Qt API. It exists for the convenience
++ // of moc. This header file may change from version to version without notice,
++ // or even be removed.
++ //
++ // We mean it.
++ //
++
++ #include <QtCore/private/qglobal_p.h>
++ #include <QtCore/qobject.h>
++ #include <QtCore/qmetaobject.h>
++ #include <QtCore/qdatastream.h>
++ #include <QtCore/qhash.h>
++ #include <QtCore/qmap.h>
++
++ #include <private/qmetaobject_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ class QMetaObjectBuilderPrivate;
++ class QMetaMethodBuilder;
++ class QMetaMethodBuilderPrivate;
++ class QMetaPropertyBuilder;
++ class QMetaPropertyBuilderPrivate;
++ class QMetaEnumBuilder;
++ class QMetaEnumBuilderPrivate;
++
++ class Q_CORE_EXPORT QMetaObjectBuilder
++ {
++ public:
++ enum AddMember
++ {
++ ClassName = 0x00000001,
++ SuperClass = 0x00000002,
++ Methods = 0x00000004,
++ Signals = 0x00000008,
++ Slots = 0x00000010,
++ Constructors = 0x00000020,
++ Properties = 0x00000040,
++ Enumerators = 0x00000080,
++ ClassInfos = 0x00000100,
++ RelatedMetaObjects = 0x00000200,
++ StaticMetacall = 0x00000400,
++ PublicMethods = 0x00000800,
++ ProtectedMethods = 0x00001000,
++ PrivateMethods = 0x00002000,
++ AllMembers = 0x7FFFFFFF,
++ AllPrimaryMembers = 0x7FFFFBFC
++ };
++ Q_DECLARE_FLAGS(AddMembers, AddMember)
++
++ QMetaObjectBuilder();
++ explicit QMetaObjectBuilder(const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members = AllMembers);
++ virtual ~QMetaObjectBuilder();
++
++ QByteArray className() const;
++ void setClassName(const QByteArray& name);
++
++ const QMetaObject *superClass() const;
++ void setSuperClass(const QMetaObject *meta);
++
++ MetaObjectFlags flags() const;
++ void setFlags(MetaObjectFlags);
++
++ int methodCount() const;
++ int constructorCount() const;
++ int propertyCount() const;
++ int enumeratorCount() const;
++ int classInfoCount() const;
++ int relatedMetaObjectCount() const;
++
++ QMetaMethodBuilder addMethod(const QByteArray& signature);
++ QMetaMethodBuilder addMethod(const QByteArray& signature, const QByteArray& returnType);
++ QMetaMethodBuilder addMethod(const QMetaMethod& prototype);
++
++ QMetaMethodBuilder addSlot(const QByteArray& signature);
++ QMetaMethodBuilder addSignal(const QByteArray& signature);
++
++ QMetaMethodBuilder addConstructor(const QByteArray& signature);
++ QMetaMethodBuilder addConstructor(const QMetaMethod& prototype);
++
++ QMetaPropertyBuilder addProperty(const QByteArray& name, const QByteArray& type, int notifierId=-1);
++ QMetaPropertyBuilder addProperty(const QByteArray& name, const QByteArray& type, QMetaType metaType, int notifierId=-1);
++ QMetaPropertyBuilder addProperty(const QMetaProperty& prototype);
++
++ QMetaEnumBuilder addEnumerator(const QByteArray& name);
++ QMetaEnumBuilder addEnumerator(const QMetaEnum& prototype);
++
++ int addClassInfo(const QByteArray& name, const QByteArray& value);
++
++ int addRelatedMetaObject(const QMetaObject *meta);
++
++ void addMetaObject(const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members = AllMembers);
++
++ QMetaMethodBuilder method(int index) const;
++ QMetaMethodBuilder signal(int index) const;
++ QMetaMethodBuilder constructor(int index) const;
++ QMetaPropertyBuilder property(int index) const;
++ QMetaEnumBuilder enumerator(int index) const;
++ const QMetaObject *relatedMetaObject(int index) const;
++
++ QByteArray classInfoName(int index) const;
++ QByteArray classInfoValue(int index) const;
++
++ void removeMethod(int index);
++ void removeSignal(int index);
++ void removeConstructor(int index);
++ void removeProperty(int index);
++ void removeEnumerator(int index);
++ void removeClassInfo(int index);
++ void removeRelatedMetaObject(int index);
++
++ int indexOfMethod(const QByteArray& signature);
++ int indexOfSignal(const QByteArray& signature);
++ int indexOfSlot(const QByteArray& signature);
++ int indexOfConstructor(const QByteArray& signature);
++ int indexOfProperty(const QByteArray& name);
++ int indexOfEnumerator(const QByteArray& name);
++ int indexOfClassInfo(const QByteArray& name);
++
++ typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
++
++ QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction() const;
++ void setStaticMetacallFunction(QMetaObjectBuilder::StaticMetacallFunction value);
++
++ QMetaObject *toMetaObject() const;
++
++ private:
++ Q_DISABLE_COPY_MOVE(QMetaObjectBuilder)
++
++ QMetaObjectBuilderPrivate *d;
++
++ friend class QMetaMethodBuilder;
++ friend class QMetaPropertyBuilder;
++ friend class QMetaEnumBuilder;
++ };
++
++ class Q_CORE_EXPORT QMetaMethodBuilder
++ {
++ public:
++ QMetaMethodBuilder() = default;
++
++ int index() const;
++
++ QMetaMethod::MethodType methodType() const;
++ QByteArray signature() const;
++
++ QByteArray returnType() const;
++ void setReturnType(const QByteArray& value);
++
++ QList<QByteArrayView> parameterTypes() const;
++ QList<QByteArray> parameterNames() const;
++ void setParameterNames(const QList<QByteArray>& value);
++
++ QByteArray tag() const;
++ void setTag(const QByteArray& value);
++
++ QMetaMethod::Access access() const;
++ void setAccess(QMetaMethod::Access value);
++
++ int attributes() const;
++ void setAttributes(int value);
++
++ bool isConst() const;
++ void setConst(bool methodIsConst=true);
++
++ int revision() const;
++ void setRevision(int revision);
++
++ private:
++ const QMetaObjectBuilder *_mobj = nullptr;
++ int _index = 0;
++ QMetaMethod::MethodType _type = QMetaMethod::MethodType::Method;
++
++ friend class QMetaObjectBuilder;
++ friend class QMetaPropertyBuilder;
++
++ QMetaMethodBuilder(const QMetaObjectBuilder *mobj, int index, QMetaMethod::MethodType type)
++ : _mobj(mobj), _index(index), _type(type) {}
++
++ QMetaMethodBuilderPrivate *d_func() const;
++ };
++
++ class Q_CORE_EXPORT QMetaPropertyBuilder
++ {
++ public:
++ QMetaPropertyBuilder() : _mobj(nullptr), _index(0) {}
++
++ int index() const { return _index; }
++
++ QByteArray name() const;
++ QByteArray type() const;
++
++ bool hasNotifySignal() const;
++ QMetaMethodBuilder notifySignal() const;
++ void setNotifySignal(const QMetaMethodBuilder& value);
++ void removeNotifySignal();
++
++ bool isReadable() const;
++ bool isWritable() const;
++ bool isResettable() const;
++ bool isDesignable() const;
++ bool isScriptable() const;
++ bool isStored() const;
++ bool isEditable() const;
++ bool isUser() const;
++ bool hasStdCppSet() const;
++ bool isEnumOrFlag() const;
++ bool isConstant() const;
++ bool isFinal() const;
++ bool isVirtual() const;
++ bool isOverride() const;
++ bool isAlias() const;
++ bool isBindable() const;
++ bool isRequired() const;
++
++ void setReadable(bool value);
++ void setWritable(bool value);
++ void setResettable(bool value);
++ void setDesignable(bool value);
++ void setScriptable(bool value);
++ void setStored(bool value);
++ void setUser(bool value);
++ void setStdCppSet(bool value);
++ void setEnumOrFlag(bool value);
++ void setConstant(bool value);
++ void setFinal(bool value);
++ void setVirtual(bool value);
++ void setOverride(bool value);
++ void setAlias(bool value);
++ void setBindable(bool value);
++ void setRequired(bool value);
++
++ int revision() const;
++ void setRevision(int revision);
++
++ private:
++ const QMetaObjectBuilder *_mobj;
++ int _index;
++
++ friend class QMetaObjectBuilder;
++
++ QMetaPropertyBuilder(const QMetaObjectBuilder *mobj, int index)
++ : _mobj(mobj), _index(index) {}
++
++ QMetaPropertyBuilderPrivate *d_func() const;
++ };
++
++ class Q_CORE_EXPORT QMetaEnumBuilder
++ {
++ public:
++ QMetaEnumBuilder() : _mobj(nullptr), _index(0) {}
++
++ int index() const { return _index; }
++
++ QByteArray name() const;
++
++ QByteArray enumName() const;
++ void setEnumName(const QByteArray &alias);
++
++ QMetaType metaType() const;
++ void setMetaType(QMetaType metaType);
++
++ bool isFlag() const;
++ void setIsFlag(bool value);
++
++ bool isScoped() const;
++ void setIsScoped(bool value);
++
++ bool is64Bit() const;
++ void setIs64Bit(bool value);
++
++ int keyCount() const;
++ QByteArray key(int index) const;
++ int value(int index) const;
++ std::optional<quint64> value64(int index) const;
++
++ int addKey(const QByteArray &name, int value);
++ int addKey(const QByteArray &name, quint64 value);
++ void removeKey(int index);
++
++ private:
++ const QMetaObjectBuilder *_mobj;
++ int _index;
++
++ friend class QMetaObjectBuilder;
++
++ QMetaEnumBuilder(const QMetaObjectBuilder *mobj, int index)
++ : _mobj(mobj), _index(index) {}
++
++ QMetaEnumBuilderPrivate *d_func() const;
++ };
++
++ class Q_CORE_EXPORT QMetaStringTable
++ {
++ Q_DISABLE_COPY_MOVE(QMetaStringTable)
++ public:
++ explicit QMetaStringTable(const QByteArray &className);
++
++ int enter(const QByteArray &value);
++
++ static int preferredAlignment();
++ int blobSize() const;
++ void writeBlob(char *out) const;
++
++ private:
++ typedef QHash<QByteArray, int> Entries; // string --> index mapping
++ Entries m_entries;
++ int m_index;
++ QByteArray m_className;
++ };
++
++ Q_DECLARE_OPERATORS_FOR_FLAGS(QMetaObjectBuilder::AddMembers)
++
++ QT_END_NAMESPACE
++
++ #endif