qt 6.5.1 original

src/dbus/qdbusmetaobject.cpp

@@ -0,0 +1,698 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// Copyright (C) 2016 Intel Corporation.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qdbusmetaobject_p.h"
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qvarlengtharray.h>
+
+#include "qdbusutil_p.h"
+#include "qdbuserror.h"
+#include "qdbusmetatype.h"
+#include "qdbusargument.h"
+#include "qdbusintrospection_p.h"
+#include "qdbusabstractinterface_p.h"
+
+#include <private/qmetaobject_p.h>
+#include <private/qmetaobjectbuilder_p.h>
+
+#ifndef QT_NO_DBUS
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt::StringLiterals;
+
+class QDBusMetaObjectGenerator
+{
+public:
+    QDBusMetaObjectGenerator(const QString &interface,
+                             const QDBusIntrospection::Interface *parsedData);
+    void write(QDBusMetaObject *obj);
+    void writeWithoutXml(QDBusMetaObject *obj);
+
+private:
+    struct Method {
+        QList<QByteArray> parameterNames;
+        QByteArray tag;
+        QByteArray name;
+        QVarLengthArray<int, 4> inputTypes;
+        QVarLengthArray<int, 4> outputTypes;
+        QByteArray rawReturnType;
+        quint32 flags;
+    };
+
+    struct Property {
+        QByteArray typeName;
+        QByteArray signature;
+        int type;
+        quint32 flags;
+    };
+    struct Type {
+        int id;
+        QByteArray name;
+    };
+
+    QMap<QByteArray, Method> signals_;
+    QMap<QByteArray, Method> methods;
+    QMap<QByteArray, Property> properties;
+
+    const QDBusIntrospection::Interface *data;
+    QString interface;
+
+    Type findType(const QByteArray &signature,
+                  const QDBusIntrospection::Annotations &annotations,
+                  const char *direction = "Out", int id = -1);
+
+    void parseMethods();
+    void parseSignals();
+    void parseProperties();
+
+    static qsizetype aggregateParameterCount(const QMap<QByteArray, Method> &map);
+};
+
+static const qsizetype intsPerProperty = 2;
+static const qsizetype intsPerMethod = 2;
+
+struct QDBusMetaObjectPrivate : public QMetaObjectPrivate
+{
+    int propertyDBusData;
+    int methodDBusData;
+};
+
+QDBusMetaObjectGenerator::QDBusMetaObjectGenerator(const QString &interfaceName,
+                                                   const QDBusIntrospection::Interface *parsedData)
+    : data(parsedData), interface(interfaceName)
+{
+    if (data) {
+        parseProperties();
+        parseSignals();             // call parseSignals first so that slots override signals
+        parseMethods();
+    }
+}
+
+static int registerComplexDBusType(const QByteArray &typeName)
+{
+    struct QDBusRawTypeHandler : QtPrivate::QMetaTypeInterface
+    {
+        const QByteArray name;
+        QDBusRawTypeHandler(const QByteArray &name)
+            : QtPrivate::QMetaTypeInterface {
+                0, sizeof(void *), sizeof(void *), QMetaType::RelocatableType, 0, nullptr,
+                name.constData(),
+                nullptr, nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr,
+                nullptr, nullptr, nullptr
+            },
+            name(name)
+        {}
+    };
+
+    Q_CONSTINIT static QBasicMutex mutex;
+    Q_CONSTINIT static struct Hash : QHash<QByteArray, QMetaType>
+    {
+        ~Hash()
+        {
+            for (QMetaType entry : *this)
+                QMetaType::unregisterMetaType(std::move(entry));
+        }
+    } hash;
+    QMutexLocker lock(&mutex);
+    QMetaType &metatype = hash[typeName];
+    if (!metatype.isValid())
+        metatype = QMetaType(new QDBusRawTypeHandler(typeName));
+    return metatype.id();
+}
+
+Q_DBUS_EXPORT bool qt_dbus_metaobject_skip_annotations = false;
+
+QDBusMetaObjectGenerator::Type
+QDBusMetaObjectGenerator::findType(const QByteArray &signature,
+                                   const QDBusIntrospection::Annotations &annotations,
+                                   const char *direction, int id)
+{
+    Type result;
+    result.id = QMetaType::UnknownType;
+
+    int type = QDBusMetaType::signatureToMetaType(signature).id();
+    if (type == QMetaType::UnknownType && !qt_dbus_metaobject_skip_annotations) {
+        // it's not a type normally handled by our meta type system
+        // it must contain an annotation
+        QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName");
+        if (id >= 0)
+            annotationName += QString::fromLatin1(".%1%2")
+                              .arg(QLatin1StringView(direction))
+                              .arg(id);
+
+        // extract from annotations:
+        QByteArray typeName = annotations.value(annotationName).toLatin1();
+
+        // verify that it's a valid one
+        if (typeName.isEmpty()) {
+            // try the old annotation from Qt 4
+            annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");
+            if (id >= 0)
+                annotationName += QString::fromLatin1(".%1%2")
+                                  .arg(QLatin1StringView(direction))
+                                  .arg(id);
+            typeName = annotations.value(annotationName).toLatin1();
+        }
+
+        if (!typeName.isEmpty()) {
+            // type name found
+            type = QMetaType::fromName(typeName).id();
+        }
+
+        if (type == QMetaType::UnknownType || signature != QDBusMetaType::typeToSignature(QMetaType(type))) {
+            // type is still unknown or doesn't match back to the signature that it
+            // was expected to, so synthesize a fake type
+            typeName = "QDBusRawType<0x" + signature.toHex() + ">*";
+            type = registerComplexDBusType(typeName);
+        }
+
+        result.name = typeName;
+    } else if (type == QMetaType::UnknownType) {
+        // this case is used only by the qdbus command-line tool
+        // invalid, let's create an impossible type that contains the signature
+
+        if (signature == "av") {
+            result.name = "QVariantList";
+            type = QMetaType::QVariantList;
+        } else if (signature == "a{sv}") {
+            result.name = "QVariantMap";
+            type = QMetaType::QVariantMap;
+        } else if (signature == "a{ss}") {
+            result.name = "QMap<QString,QString>";
+            type = qMetaTypeId<QMap<QString, QString> >();
+        } else if (signature == "aay") {
+            result.name = "QByteArrayList";
+            type = qMetaTypeId<QByteArrayList>();
+        } else {
+            result.name = "{D-Bus type \"" + signature + "\"}";
+            type = registerComplexDBusType(result.name);
+        }
+    } else {
+        result.name = QMetaType(type).name();
+    }
+
+    result.id = type;
+    return result;              // success
+}
+
+void QDBusMetaObjectGenerator::parseMethods()
+{
+    //
+    // TODO:
+    //  Add cloned methods when the remote object has return types
+    //
+
+    QDBusIntrospection::Methods::ConstIterator method_it = data->methods.constBegin();
+    QDBusIntrospection::Methods::ConstIterator method_end = data->methods.constEnd();
+    for ( ; method_it != method_end; ++method_it) {
+        const QDBusIntrospection::Method &m = *method_it;
+        Method mm;
+
+        mm.name = m.name.toLatin1();
+        QByteArray prototype = mm.name;
+        prototype += '(';
+
+        bool ok = true;
+
+        // build the input argument list
+        for (qsizetype i = 0; i < m.inputArgs.size(); ++i) {
+            const QDBusIntrospection::Argument &arg = m.inputArgs.at(i);
+
+            Type type = findType(arg.type.toLatin1(), m.annotations, "In", i);
+            if (type.id == QMetaType::UnknownType) {
+                ok = false;
+                break;
+            }
+
+            mm.inputTypes.append(type.id);
+
+            mm.parameterNames.append(arg.name.toLatin1());
+
+            prototype.append(type.name);
+            prototype.append(',');
+        }
+        if (!ok) continue;
+
+        // build the output argument list:
+        for (qsizetype i = 0; i < m.outputArgs.size(); ++i) {
+            const QDBusIntrospection::Argument &arg = m.outputArgs.at(i);
+
+            Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i);
+            if (type.id == QMetaType::UnknownType) {
+                ok = false;
+                break;
+            }
+
+            mm.outputTypes.append(type.id);
+
+            if (i == 0 && type.id == -1) {
+                mm.rawReturnType = type.name;
+            }
+            if (i != 0) {
+                // non-const ref parameter
+                mm.parameterNames.append(arg.name.toLatin1());
+
+                prototype.append(type.name);
+                prototype.append("&,");
+            }
+        }
+        if (!ok) continue;
+
+        // convert the last commas:
+        if (!mm.parameterNames.isEmpty())
+            prototype[prototype.size() - 1] = ')';
+        else
+            prototype.append(')');
+
+        // check the async tag
+        if (m.annotations.value(ANNOTATION_NO_WAIT ""_L1) == "true"_L1)
+            mm.tag = "Q_NOREPLY";
+
+        // meta method flags
+        mm.flags = AccessPublic | MethodSlot | MethodScriptable;
+
+        // add
+        methods.insert(QMetaObject::normalizedSignature(prototype), mm);
+    }
+}
+
+void QDBusMetaObjectGenerator::parseSignals()
+{
+    QDBusIntrospection::Signals::ConstIterator signal_it = data->signals_.constBegin();
+    QDBusIntrospection::Signals::ConstIterator signal_end = data->signals_.constEnd();
+    for ( ; signal_it != signal_end; ++signal_it) {
+        const QDBusIntrospection::Signal &s = *signal_it;
+        Method mm;
+
+        mm.name = s.name.toLatin1();
+        QByteArray prototype = mm.name;
+        prototype += '(';
+
+        bool ok = true;
+
+        // build the output argument list
+        for (qsizetype i = 0; i < s.outputArgs.size(); ++i) {
+            const QDBusIntrospection::Argument &arg = s.outputArgs.at(i);
+
+            Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i);
+            if (type.id == QMetaType::UnknownType) {
+                ok = false;
+                break;
+            }
+
+            mm.inputTypes.append(type.id);
+
+            mm.parameterNames.append(arg.name.toLatin1());
+
+            prototype.append(type.name);
+            prototype.append(',');
+        }
+        if (!ok) continue;
+
+        // convert the last commas:
+        if (!mm.parameterNames.isEmpty())
+            prototype[prototype.size() - 1] = ')';
+        else
+            prototype.append(')');
+
+        // meta method flags
+        mm.flags = AccessPublic | MethodSignal | MethodScriptable;
+
+        // add
+        signals_.insert(QMetaObject::normalizedSignature(prototype), mm);
+    }
+}
+
+void QDBusMetaObjectGenerator::parseProperties()
+{
+    QDBusIntrospection::Properties::ConstIterator prop_it = data->properties.constBegin();
+    QDBusIntrospection::Properties::ConstIterator prop_end = data->properties.constEnd();
+    for ( ; prop_it != prop_end; ++prop_it) {
+        const QDBusIntrospection::Property &p = *prop_it;
+        Property mp;
+        Type type = findType(p.type.toLatin1(), p.annotations);
+        if (type.id == QMetaType::UnknownType)
+            continue;
+
+        QByteArray name = p.name.toLatin1();
+        mp.signature = p.type.toLatin1();
+        mp.type = type.id;
+        mp.typeName = type.name;
+
+        // build the flags:
+        mp.flags = StdCppSet | Scriptable | Stored | Designable;
+        if (p.access != QDBusIntrospection::Property::Write)
+            mp.flags |= Readable;
+        if (p.access != QDBusIntrospection::Property::Read)
+            mp.flags |= Writable;
+
+        // add the property:
+        properties.insert(name, mp);
+    }
+}
+
+// Returns the sum of all parameters (including return type) for the given
+// \a map of methods. This is needed for calculating the size of the methods'
+// parameter type/name meta-data.
+qsizetype QDBusMetaObjectGenerator::aggregateParameterCount(const QMap<QByteArray, Method> &map)
+{
+    qsizetype sum = 0;
+    QMap<QByteArray, Method>::const_iterator it;
+    for (it = map.constBegin(); it != map.constEnd(); ++it) {
+        const Method &m = it.value();
+        sum += m.inputTypes.size() + qMax(qsizetype(1), m.outputTypes.size());
+    }
+    return sum;
+}
+
+void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj)
+{
+    // this code here is mostly copied from qaxbase.cpp
+    // with a few modifications to make it cleaner
+
+    QString className = interface;
+    className.replace(u'.', "::"_L1);
+    if (className.isEmpty())
+        className = "QDBusInterface"_L1;
+
+    QVarLengthArray<uint> idata;
+    idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(uint));
+
+    qsizetype methodParametersDataSize =
+            ((aggregateParameterCount(signals_)
+             + aggregateParameterCount(methods)) * 2) // types and parameter names
+            - signals_.size() // return "parameters" don't have names
+            - methods.size(); // ditto
+
+    QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());
+    static_assert(QMetaObjectPrivate::OutputRevision == 11, "QtDBus meta-object generator should generate the same version as moc");
+    header->revision = QMetaObjectPrivate::OutputRevision;
+    header->className = 0;
+    header->classInfoCount = 0;
+    header->classInfoData = 0;
+    header->methodCount = int(signals_.size() + methods.size());
+    header->methodData = int(idata.size());
+    header->propertyCount = int(properties.size());
+    header->propertyData = int(header->methodData + header->methodCount *
+                               QMetaObjectPrivate::IntsPerMethod + methodParametersDataSize);
+    header->enumeratorCount = 0;
+    header->enumeratorData = 0;
+    header->constructorCount = 0;
+    header->constructorData = 0;
+    header->flags = RequiresVariantMetaObject;
+    header->signalCount = signals_.size();
+    // These are specific to QDBusMetaObject:
+    header->propertyDBusData = int(header->propertyData + header->propertyCount
+                                   * QMetaObjectPrivate::IntsPerProperty);
+    header->methodDBusData = int(header->propertyDBusData + header->propertyCount * intsPerProperty);
+
+    qsizetype data_size = idata.size() +
+                    (header->methodCount * (QMetaObjectPrivate::IntsPerMethod+intsPerMethod)) + methodParametersDataSize +
+                    (header->propertyCount * (QMetaObjectPrivate::IntsPerProperty+intsPerProperty));
+    for (const Method &mm : std::as_const(signals_))
+        data_size += 2 + mm.inputTypes.size() + mm.outputTypes.size();
+    for (const Method &mm : std::as_const(methods))
+        data_size += 2 + mm.inputTypes.size() + mm.outputTypes.size();
+    idata.resize(data_size + 1);
+
+    QMetaStringTable strings(className.toLatin1());
+
+    qsizetype offset = header->methodData;
+    qsizetype parametersOffset = offset + header->methodCount * QMetaObjectPrivate::IntsPerMethod;
+    qsizetype signatureOffset = header->methodDBusData;
+    qsizetype typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;
+    idata[typeidOffset++] = 0;                           // eod
+
+    qsizetype totalMetaTypeCount = properties.size();
+    ++totalMetaTypeCount; // + 1 for metatype of dynamic metaobject
+    for (const auto& methodContainer: {signals_, methods}) {
+        for (const auto& method: methodContainer) {
+            qsizetype argc = method.inputTypes.size() + qMax(qsizetype(0), method.outputTypes.size() - 1);
+            totalMetaTypeCount += argc + 1;
+        }
+    }
+    QMetaType *metaTypes = new QMetaType[totalMetaTypeCount];
+    int propertyId = 0;
+
+    // add each method:
+    qsizetype currentMethodMetaTypeOffset = properties.size() + 1;
+    for (int x = 0; x < 2; ++x) {
+        // Signals must be added before other methods, to match moc.
+        QMap<QByteArray, Method> &map = (x == 0) ? signals_ : methods;
+        for (QMap<QByteArray, Method>::ConstIterator it = map.constBegin();
+             it != map.constEnd(); ++it) {
+            const Method &mm = it.value();
+
+            qsizetype argc = mm.inputTypes.size() + qMax(qsizetype(0), mm.outputTypes.size() - 1);
+
+            idata[offset++] = strings.enter(mm.name);
+            idata[offset++] = argc;
+            idata[offset++] = parametersOffset;
+            idata[offset++] = strings.enter(mm.tag);
+            idata[offset++] = mm.flags;
+            idata[offset++] = currentMethodMetaTypeOffset;
+
+            // Parameter types
+            for (qsizetype i = -1; i < argc; ++i) {
+                int type;
+                QByteArray typeName;
+                if (i < 0) { // Return type
+                    if (!mm.outputTypes.isEmpty()) {
+                        type = mm.outputTypes.first();
+                        if (type == -1) {
+                            type = IsUnresolvedType | strings.enter(mm.rawReturnType);
+                        }
+                    } else {
+                        type = QMetaType::Void;
+                    }
+                } else if (i < mm.inputTypes.size()) {
+                    type = mm.inputTypes.at(i);
+                } else {
+                    Q_ASSERT(mm.outputTypes.size() > 1);
+                    type = mm.outputTypes.at(i - mm.inputTypes.size() + 1);
+                    // Output parameters are references; type id not available
+                    typeName = QMetaType(type).name();
+                    typeName.append('&');
+                    type = QMetaType::UnknownType;
+                }
+                int typeInfo;
+                if (!typeName.isEmpty())
+                    typeInfo = IsUnresolvedType | strings.enter(typeName);
+                else
+                    typeInfo = type;
+                metaTypes[currentMethodMetaTypeOffset++] = QMetaType(type);
+                idata[parametersOffset++] = typeInfo;
+            }
+            // Parameter names
+            for (qsizetype i = 0; i < argc; ++i)
+                idata[parametersOffset++] = strings.enter(mm.parameterNames.at(i));
+
+            idata[signatureOffset++] = typeidOffset;
+            idata[typeidOffset++] = mm.inputTypes.size();
+            memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.size() * sizeof(uint));
+            typeidOffset += mm.inputTypes.size();
+
+            idata[signatureOffset++] = typeidOffset;
+            idata[typeidOffset++] = mm.outputTypes.size();
+            memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.size() * sizeof(uint));
+            typeidOffset += mm.outputTypes.size();
+        }
+    }
+
+    Q_ASSERT(offset == header->methodData + header->methodCount * QMetaObjectPrivate::IntsPerMethod);
+    Q_ASSERT(parametersOffset == header->propertyData);
+    Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);
+    Q_ASSERT(typeidOffset == idata.size());
+    offset += methodParametersDataSize;
+    Q_ASSERT(offset == header->propertyData);
+
+    // add each property
+    signatureOffset = header->propertyDBusData;
+    for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin();
+         it != properties.constEnd(); ++it) {
+        const Property &mp = it.value();
+
+        // form is name, typeinfo, flags
+        idata[offset++] = strings.enter(it.key()); // name
+        Q_ASSERT(mp.type != QMetaType::UnknownType);
+        idata[offset++] = mp.type;
+        idata[offset++] = mp.flags;
+        idata[offset++] = -1; // notify index
+        idata[offset++] = 0; // revision
+
+        idata[signatureOffset++] = strings.enter(mp.signature);
+        idata[signatureOffset++] = mp.type;
+
+        metaTypes[propertyId++] = QMetaType(mp.type);
+    }
+    metaTypes[propertyId] = QMetaType(); // we can't know our own metatype
+
+    Q_ASSERT(offset == header->propertyDBusData);
+    Q_ASSERT(signatureOffset == header->methodDBusData);
+
+    char *string_data = new char[strings.blobSize()];
+    strings.writeBlob(string_data);
+
+    uint *uint_data = new uint[idata.size()];
+    memcpy(uint_data, idata.data(), idata.size() * sizeof(uint));
+
+    // put the metaobject together
+    obj->d.data = uint_data;
+    obj->d.relatedMetaObjects = nullptr;
+    obj->d.static_metacall = nullptr;
+    obj->d.extradata = nullptr;
+    obj->d.stringdata = reinterpret_cast<const uint *>(string_data);
+    obj->d.superdata = &QDBusAbstractInterface::staticMetaObject;
+    obj->d.metaTypes = reinterpret_cast<QtPrivate::QMetaTypeInterface *const *>(metaTypes);
+}
+
+#if 0
+void QDBusMetaObjectGenerator::writeWithoutXml(const QString &interface)
+{
+    // no XML definition
+    QString tmp(interface);
+    tmp.replace(u'.', "::"_L1);
+    QByteArray name(tmp.toLatin1());
+
+    QDBusMetaObjectPrivate *header = new QDBusMetaObjectPrivate;
+    memset(header, 0, sizeof *header);
+    header->revision = 1;
+    // leave the rest with 0
+
+    char *stringdata = new char[name.length() + 1];
+    stringdata[name.length()] = '\0';
+
+    d.data = reinterpret_cast<uint*>(header);
+    d.relatedMetaObjects = 0;
+    d.static_metacall = 0;
+    d.extradata = 0;
+    d.stringdata = stringdata;
+    d.superdata = &QDBusAbstractInterface::staticMetaObject;
+    cached = false;
+}
+#endif
+
+/////////
+// class QDBusMetaObject
+
+QDBusMetaObject *QDBusMetaObject::createMetaObject(const QString &interface, const QString &xml,
+                                                   QHash<QString, QDBusMetaObject *> &cache,
+                                                   QDBusError &error)
+{
+    error = QDBusError();
+    QDBusIntrospection::Interfaces parsed = QDBusIntrospection::parseInterfaces(xml);
+
+    QDBusMetaObject *we = nullptr;
+    QDBusIntrospection::Interfaces::ConstIterator it = parsed.constBegin();
+    QDBusIntrospection::Interfaces::ConstIterator end = parsed.constEnd();
+    for ( ; it != end; ++it) {
+        // check if it's in the cache
+        bool us = it.key() == interface;
+
+        QDBusMetaObject *obj = cache.value(it.key(), 0);
+        if (!obj && (us || !interface.startsWith("local."_L1 ))) {
+            // not in cache; create
+            obj = new QDBusMetaObject;
+            QDBusMetaObjectGenerator generator(it.key(), it.value().constData());
+            generator.write(obj);
+
+            if ((obj->cached = !it.key().startsWith("local."_L1)))
+                // cache it
+                cache.insert(it.key(), obj);
+            else if (!us)
+                delete obj;
+
+        }
+
+        if (us)
+            // it's us
+            we = obj;
+    }
+
+    if (we)
+        return we;
+    // still nothing?
+
+    if (parsed.isEmpty()) {
+        // object didn't return introspection
+        we = new QDBusMetaObject;
+        QDBusMetaObjectGenerator generator(interface, nullptr);
+        generator.write(we);
+        we->cached = false;
+        return we;
+    } else if (interface.isEmpty()) {
+        // merge all interfaces
+        it = parsed.constBegin();
+        QDBusIntrospection::Interface merged = *it.value().constData();
+
+        for (++it; it != end; ++it) {
+            merged.annotations.insert(it.value()->annotations);
+            merged.methods.unite(it.value()->methods);
+            merged.signals_.unite(it.value()->signals_);
+            merged.properties.insert(it.value()->properties);
+        }
+
+        merged.name = "local.Merged"_L1;
+        merged.introspection.clear();
+
+        we = new QDBusMetaObject;
+        QDBusMetaObjectGenerator generator(merged.name, &merged);
+        generator.write(we);
+        we->cached = false;
+        return we;
+    }
+
+    // mark as an error
+    error = QDBusError(QDBusError::UnknownInterface,
+                       "Interface '%1' was not found"_L1.arg(interface));
+    return nullptr;
+}
+
+QDBusMetaObject::QDBusMetaObject()
+{
+}
+
+static inline const QDBusMetaObjectPrivate *priv(const uint* data)
+{
+    return reinterpret_cast<const QDBusMetaObjectPrivate *>(data);
+}
+
+const int *QDBusMetaObject::inputTypesForMethod(int id) const
+{
+    //id -= methodOffset();
+    if (id >= 0 && id < priv(d.data)->methodCount) {
+        int handle = priv(d.data)->methodDBusData + id*intsPerMethod;
+        return reinterpret_cast<const int*>(d.data + d.data[handle]);
+    }
+    return nullptr;
+}
+
+const int *QDBusMetaObject::outputTypesForMethod(int id) const
+{
+    //id -= methodOffset();
+    if (id >= 0 && id < priv(d.data)->methodCount) {
+        int handle = priv(d.data)->methodDBusData + id*intsPerMethod;
+        return reinterpret_cast<const int*>(d.data + d.data[handle + 1]);
+    }
+    return nullptr;
+}
+
+int QDBusMetaObject::propertyMetaType(int id) const
+{
+    //id -= propertyOffset();
+    if (id >= 0 && id < priv(d.data)->propertyCount) {
+        int handle = priv(d.data)->propertyDBusData + id*intsPerProperty;
+        return d.data[handle + 1];
+    }
+    return 0;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DBUS