Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-15 10:24:21 

0001 // Copyright (C) 2016 The Qt Company Ltd.
0002 // Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com>
0003 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0004 
0005 #ifndef QMETAOBJECT_H
0006 #define QMETAOBJECT_H
0007 
0008 #include <QtCore/qobjectdefs.h>
0009 #include <QtCore/qcompare.h>
0010 #include <QtCore/qvariant.h>
0011 
0012 QT_BEGIN_NAMESPACE
0013 
0014 class QUntypedBindable;
0015 
0016 #define Q_METAMETHOD_INVOKE_MAX_ARGS 10
0017 
0018 class Q_CORE_EXPORT QMetaMethod
0019 {
0020 public:
0021     constexpr inline QMetaMethod() : mobj(nullptr), data({ nullptr }) {}
0022 
0023     QByteArray methodSignature() const;
0024     QByteArray name() const;
0025     QByteArrayView nameView() const;
0026     const char *typeName() const;
0027     int returnType() const;
0028     QMetaType returnMetaType() const;
0029     int parameterCount() const;
0030     int parameterType(int index) const;
0031     QMetaType parameterMetaType(int index) const;
0032     void getParameterTypes(int *types) const;
0033     QList<QByteArray> parameterTypes() const;
0034     QByteArray parameterTypeName(int index) const;
0035     QList<QByteArray> parameterNames() const;
0036     const char *tag() const;
0037     enum Access { Private, Protected, Public };
0038     Access access() const;
0039     enum MethodType { Method, Signal, Slot, Constructor };
0040     MethodType methodType() const;
0041     enum Attributes { Compatibility = 0x1, Cloned = 0x2, Scriptable = 0x4 };
0042     int attributes() const;
0043     int methodIndex() const;
0044     int relativeMethodIndex() const;
0045     int revision() const;
0046     bool isConst() const;
0047 
0048     inline const QMetaObject *enclosingMetaObject() const { return mobj; }
0049 
0050 #if QT_VERSION <= QT_VERSION_CHECK(7, 0, 0)
0051     bool invoke(QObject *object,
0052                 Qt::ConnectionType connectionType,
0053                 QGenericReturnArgument returnValue,
0054                 QGenericArgument val0 = QGenericArgument(nullptr),
0055                 QGenericArgument val1 = QGenericArgument(),
0056                 QGenericArgument val2 = QGenericArgument(),
0057                 QGenericArgument val3 = QGenericArgument(),
0058                 QGenericArgument val4 = QGenericArgument(),
0059                 QGenericArgument val5 = QGenericArgument(),
0060                 QGenericArgument val6 = QGenericArgument(),
0061                 QGenericArgument val7 = QGenericArgument(),
0062                 QGenericArgument val8 = QGenericArgument(),
0063                 QGenericArgument val9 = QGenericArgument()) const;
0064     inline bool invoke(QObject *object,
0065                        QGenericReturnArgument returnValue,
0066                        QGenericArgument val0 = QGenericArgument(nullptr),
0067                        QGenericArgument val1 = QGenericArgument(),
0068                        QGenericArgument val2 = QGenericArgument(),
0069                        QGenericArgument val3 = QGenericArgument(),
0070                        QGenericArgument val4 = QGenericArgument(),
0071                        QGenericArgument val5 = QGenericArgument(),
0072                        QGenericArgument val6 = QGenericArgument(),
0073                        QGenericArgument val7 = QGenericArgument(),
0074                        QGenericArgument val8 = QGenericArgument(),
0075                        QGenericArgument val9 = QGenericArgument()) const
0076     {
0077         return invoke(object, Qt::AutoConnection, returnValue,
0078                       val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
0079     }
0080     inline bool invoke(QObject *object,
0081                        Qt::ConnectionType connectionType,
0082                        QGenericArgument val0,
0083                        QGenericArgument val1 = QGenericArgument(),
0084                        QGenericArgument val2 = QGenericArgument(),
0085                        QGenericArgument val3 = QGenericArgument(),
0086                        QGenericArgument val4 = QGenericArgument(),
0087                        QGenericArgument val5 = QGenericArgument(),
0088                        QGenericArgument val6 = QGenericArgument(),
0089                        QGenericArgument val7 = QGenericArgument(),
0090                        QGenericArgument val8 = QGenericArgument(),
0091                        QGenericArgument val9 = QGenericArgument()) const
0092     {
0093         return invoke(object, connectionType, QGenericReturnArgument(),
0094                       val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
0095     }
0096     inline bool invoke(QObject *object,
0097                        QGenericArgument val0,
0098                        QGenericArgument val1 = QGenericArgument(),
0099                        QGenericArgument val2 = QGenericArgument(),
0100                        QGenericArgument val3 = QGenericArgument(),
0101                        QGenericArgument val4 = QGenericArgument(),
0102                        QGenericArgument val5 = QGenericArgument(),
0103                        QGenericArgument val6 = QGenericArgument(),
0104                        QGenericArgument val7 = QGenericArgument(),
0105                        QGenericArgument val8 = QGenericArgument(),
0106                        QGenericArgument val9 = QGenericArgument()) const
0107     {
0108         return invoke(object, Qt::AutoConnection, QGenericReturnArgument(),
0109                       val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
0110     }
0111     bool invokeOnGadget(void *gadget,
0112                         QGenericReturnArgument returnValue,
0113                         QGenericArgument val0 = QGenericArgument(nullptr),
0114                         QGenericArgument val1 = QGenericArgument(),
0115                         QGenericArgument val2 = QGenericArgument(),
0116                         QGenericArgument val3 = QGenericArgument(),
0117                         QGenericArgument val4 = QGenericArgument(),
0118                         QGenericArgument val5 = QGenericArgument(),
0119                         QGenericArgument val6 = QGenericArgument(),
0120                         QGenericArgument val7 = QGenericArgument(),
0121                         QGenericArgument val8 = QGenericArgument(),
0122                         QGenericArgument val9 = QGenericArgument()) const;
0123     inline bool invokeOnGadget(void *gadget,
0124                                QGenericArgument val0,
0125                                QGenericArgument val1 = QGenericArgument(),
0126                                QGenericArgument val2 = QGenericArgument(),
0127                                QGenericArgument val3 = QGenericArgument(),
0128                                QGenericArgument val4 = QGenericArgument(),
0129                                QGenericArgument val5 = QGenericArgument(),
0130                                QGenericArgument val6 = QGenericArgument(),
0131                                QGenericArgument val7 = QGenericArgument(),
0132                                QGenericArgument val8 = QGenericArgument(),
0133                                QGenericArgument val9 = QGenericArgument()) const
0134     {
0135         return invokeOnGadget(gadget, QGenericReturnArgument(),
0136                               val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
0137     }
0138 #endif
0139 
0140     template <typename ReturnArg, typename... Args>
0141 #ifdef Q_QDOC
0142     bool
0143 #else
0144     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0145 #endif
0146     invoke(QObject *obj, Qt::ConnectionType c, QTemplatedMetaMethodReturnArgument<ReturnArg> r,
0147            Args &&... arguments) const
0148     {
0149         auto h = QtPrivate::invokeMethodHelper(r, std::forward<Args>(arguments)...);
0150         return invokeImpl(*this, obj, c, h.parameterCount(), h.parameters.data(),
0151                           h.typeNames.data(), h.metaTypes.data());
0152     }
0153 
0154     template <typename... Args>
0155 #ifdef Q_QDOC
0156     bool
0157 #else
0158     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0159 #endif
0160     invoke(QObject *obj, Qt::ConnectionType c, Args &&... arguments) const
0161     {
0162         return invoke(obj, c, QTemplatedMetaMethodReturnArgument<void>{}, std::forward<Args>(arguments)...);
0163     }
0164 
0165     template <typename ReturnArg, typename... Args>
0166 #ifdef Q_QDOC
0167     bool
0168 #else
0169     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0170 #endif
0171     invoke(QObject *obj, QTemplatedMetaMethodReturnArgument<ReturnArg> r, Args &&... arguments) const
0172     {
0173         return invoke(obj, Qt::AutoConnection, r, std::forward<Args>(arguments)...);
0174     }
0175 
0176     template <typename... Args>
0177 #ifdef Q_QDOC
0178     bool
0179 #else
0180     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0181 #endif
0182     invoke(QObject *obj, Args &&... arguments) const
0183     {
0184         return invoke(obj, Qt::AutoConnection, std::forward<Args>(arguments)...);
0185     }
0186 
0187     template <typename ReturnArg, typename... Args>
0188 #ifdef Q_QDOC
0189     bool
0190 #else
0191     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0192 #endif
0193     invokeOnGadget(void *gadget, QTemplatedMetaMethodReturnArgument<ReturnArg> r, Args &&... arguments) const
0194     {
0195         auto h = QtPrivate::invokeMethodHelper(r, std::forward<Args>(arguments)...);
0196         return invokeImpl(*this, gadget, Qt::ConnectionType(-1), h.parameterCount(),
0197                           h.parameters.data(), h.typeNames.data(), h.metaTypes.data());
0198     }
0199 
0200     template <typename... Args>
0201 #ifdef Q_QDOC
0202     bool
0203 #else
0204     QtPrivate::Invoke::IfNotOldStyleArgs<bool, Args...>
0205 #endif
0206     invokeOnGadget(void *gadget, Args &&... arguments) const
0207     {
0208         return invokeOnGadget(gadget, QTemplatedMetaMethodReturnArgument<void>{}, std::forward<Args>(arguments)...);
0209     }
0210 
0211     inline bool isValid() const { return mobj != nullptr; }
0212 
0213     template <typename PointerToMemberFunction>
0214     static inline QMetaMethod fromSignal(PointerToMemberFunction signal)
0215     {
0216         typedef QtPrivate::FunctionPointer<PointerToMemberFunction> SignalType;
0217         static_assert(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value,
0218                       "No Q_OBJECT in the class with the signal");
0219         return fromSignalImpl(&SignalType::Object::staticMetaObject,
0220                               reinterpret_cast<void **>(&signal));
0221     }
0222 
0223 private:
0224     static bool invokeImpl(QMetaMethod self, void *target, Qt::ConnectionType, qsizetype paramCount,
0225                            const void *const *parameters, const char *const *typeNames,
0226                            const QtPrivate::QMetaTypeInterface *const *metaTypes);
0227     static QMetaMethod fromSignalImpl(const QMetaObject *, void **);
0228     static QMetaMethod fromRelativeMethodIndex(const QMetaObject *mobj, int index);
0229     static QMetaMethod fromRelativeConstructorIndex(const QMetaObject *mobj, int index);
0230 
0231 protected:
0232     struct Data {
0233         enum { Size = 6 };
0234 
0235         uint name() const { return d[0]; }
0236         uint argc() const { return d[1]; }
0237         uint parameters() const { return d[2]; }
0238         uint tag() const { return d[3]; }
0239         uint flags() const { return d[4]; }
0240         uint metaTypeOffset() const { return d[5]; }
0241         bool operator==(const Data &other) const { return d == other.d; }
0242 
0243         const uint *d;
0244     };
0245 private:
0246     constexpr QMetaMethod(const QMetaObject *metaObject, const Data &data_)
0247         : mobj(metaObject), data(data_)
0248     {}
0249 protected:
0250 
0251     const QMetaObject *mobj;
0252     Data data;
0253     friend struct QMetaObject;
0254     friend struct QMetaObjectPrivate;
0255     friend class QObject;
0256 
0257 private:
0258     friend bool comparesEqual(const QMetaMethod &lhs, const QMetaMethod &rhs) noexcept
0259     { return lhs.data == rhs.data; }
0260     Q_DECLARE_EQUALITY_COMPARABLE(QMetaMethod)
0261 };
0262 Q_DECLARE_TYPEINFO(QMetaMethod, Q_RELOCATABLE_TYPE);
0263 
0264 class Q_CORE_EXPORT QMetaEnum
0265 {
0266 public:
0267     constexpr inline QMetaEnum() : mobj(nullptr), data({ nullptr }) {}
0268 
0269     const char *name() const;
0270     const char *enumName() const;
0271     QMetaType metaType() const;
0272 
0273     bool isFlag() const;
0274     bool isScoped() const;
0275     bool is64Bit() const;
0276 
0277     int keyCount() const;
0278     const char *key(int index) const;
0279     int value(int index) const;
0280     std::optional<quint64> value64(int index) const;
0281 
0282     const char *scope() const;
0283 
0284     int keyToValue(const char *key, bool *ok = nullptr) const;
0285     int keysToValue(const char *keys, bool *ok = nullptr) const;
0286     std::optional<quint64> keyToValue64(const char *key) const;
0287     std::optional<quint64> keysToValue64(const char *keys) const;
0288 #if QT_CORE_REMOVED_SINCE(6, 9)
0289     const char *valueToKey(int value) const;
0290     QByteArray valueToKeys(int value) const;
0291 #endif
0292     const char *valueToKey(quint64 value) const;
0293     QByteArray valueToKeys(quint64 value) const;
0294 
0295     inline const QMetaObject *enclosingMetaObject() const { return mobj; }
0296 
0297     inline bool isValid() const { return name() != nullptr; }
0298 
0299     template<typename T>
0300     static QMetaEnum fromType()
0301     {
0302         static_assert(QtPrivate::IsQEnumHelper<T>::Value,
0303                       "QMetaEnum::fromType only works with enums declared as "
0304                       "Q_ENUM, Q_ENUM_NS, Q_FLAG or Q_FLAG_NS");
0305         const QMetaObject *metaObject = qt_getEnumMetaObject(T());
0306         const char *name = qt_getEnumName(T());
0307         return metaObject->enumerator(metaObject->indexOfEnumerator(name));
0308     }
0309 
0310 private:
0311     struct Data {
0312         enum { Size = 5 };
0313         quint32 name() const { return d[0]; }
0314         quint32 alias() const { return d[1]; }
0315         quint32 flags() const { return d[2]; }
0316         qint32 keyCount() const { return static_cast<qint32>(d[3]); }
0317         quint32 data() const { return d[4]; }
0318         int index(const QMetaObject *mobj) const;
0319 
0320         const uint *d;
0321     };
0322 
0323     QMetaEnum(const QMetaObject *mobj, int index);
0324     template <typename... Args> quint64 value_helper(uint index, Args...) const noexcept;
0325 
0326     const QMetaObject *mobj;
0327     Data data;
0328     friend struct QMetaObject;
0329     friend struct QMetaObjectPrivate;
0330 };
0331 Q_DECLARE_TYPEINFO(QMetaEnum, Q_RELOCATABLE_TYPE);
0332 
0333 class Q_CORE_EXPORT QMetaProperty
0334 {
0335 public:
0336     constexpr QMetaProperty() : mobj(nullptr), data({ nullptr }) {}
0337 
0338     const char *name() const;
0339     const char *typeName() const;
0340 #if QT_DEPRECATED_SINCE(6, 0)
0341     QT_WARNING_PUSH
0342     QT_WARNING_DISABLE_DEPRECATED
0343     QT_DEPRECATED_VERSION_6_0
0344     QVariant::Type type() const
0345     { int t = userType(); return t >= QMetaType::User ? QVariant::UserType : QVariant::Type(t); }
0346     QT_WARNING_POP
0347 #endif
0348     int userType() const { return typeId(); }
0349     int typeId() const { return metaType().id(); }
0350     QMetaType metaType() const;
0351     int propertyIndex() const;
0352     int relativePropertyIndex() const;
0353 
0354     bool isReadable() const;
0355     bool isWritable() const;
0356     bool isResettable() const;
0357     bool isDesignable() const;
0358     bool isScriptable() const;
0359     bool isStored() const;
0360     bool isUser() const;
0361     bool isConstant() const;
0362     bool isFinal() const;
0363     bool isRequired() const;
0364     bool isBindable() const;
0365 
0366     bool isFlagType() const;
0367     bool isEnumType() const;
0368     QMetaEnum enumerator() const;
0369 
0370     bool hasNotifySignal() const;
0371     QMetaMethod notifySignal() const;
0372     int notifySignalIndex() const;
0373 
0374     int revision() const;
0375 
0376     QVariant read(const QObject *obj) const;
0377     bool write(QObject *obj, const QVariant &value) const;
0378     bool write(QObject *obj, QVariant &&value) const;
0379     bool reset(QObject *obj) const;
0380 
0381     QUntypedBindable bindable(QObject *object) const;
0382 
0383     QVariant readOnGadget(const void *gadget) const;
0384     bool writeOnGadget(void *gadget, const QVariant &value) const;
0385     bool writeOnGadget(void *gadget, QVariant &&value) const;
0386     bool resetOnGadget(void *gadget) const;
0387 
0388     bool hasStdCppSet() const;
0389     bool isAlias() const;
0390     inline bool isValid() const { return isReadable(); }
0391     inline const QMetaObject *enclosingMetaObject() const { return mobj; }
0392 
0393 private:
0394 #if QT_DEPRECATED_SINCE(6, 4)
0395     QT_DEPRECATED_VERSION_X_6_4("obsolete, simply returns typeId()")
0396     int registerPropertyType() const;
0397 #endif
0398 
0399     struct Data {
0400         enum { Size = 5 };
0401 
0402         uint name() const { return d[0]; }
0403         uint type() const { return d[1]; }
0404         uint flags() const { return d[2]; }
0405         uint notifyIndex() const { return d[3]; }
0406         uint revision() const { return d[4]; }
0407 
0408         int index(const QMetaObject *mobj) const;
0409 
0410         const uint *d;
0411     };
0412 
0413     QMetaProperty(const QMetaObject *mobj, int index);
0414     static Data getMetaPropertyData(const QMetaObject *mobj, int index);
0415 
0416     const QMetaObject *mobj;
0417     Data data;
0418     QMetaEnum menum;
0419     friend struct QMetaObject;
0420     friend struct QMetaObjectPrivate;
0421 };
0422 
0423 class Q_CORE_EXPORT QMetaClassInfo
0424 {
0425 public:
0426     constexpr inline QMetaClassInfo() : mobj(nullptr), data({ nullptr }) {}
0427     const char *name() const;
0428     const char *value() const;
0429     inline const QMetaObject *enclosingMetaObject() const { return mobj; }
0430 
0431 private:
0432     struct Data {
0433         enum { Size = 2 };
0434 
0435         uint name() const { return d[0]; }
0436         uint value() const { return d[1]; }
0437 
0438         const uint *d;
0439     };
0440 
0441     const QMetaObject *mobj;
0442     Data data;
0443     friend struct QMetaObject;
0444 };
0445 Q_DECLARE_TYPEINFO(QMetaClassInfo, Q_RELOCATABLE_TYPE);
0446 
0447 QT_END_NAMESPACE
0448 
0449 #endif // QMETAOBJECT_H
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!