QDBusMetaType Class Reference

Meta-type registration system for the QtDBus module. More...

#include <qdbusmetatype.h>

Public Types
typedef void(*	DemarshallFunction) (const QDBusArgument &, void *)
typedef void(*	MarshallFunction) (QDBusArgument &, const void *)

Static Public Functions
static bool	demarshall (const QDBusArgument &, int id, void *data)
	Executes the demarshalling of type id (whose data will be placed in data) from the D-Bus marshalling argument arg. More...
static bool	marshall (QDBusArgument &, int id, const void *data)
	Executes the marshalling of type id (whose data is contained in data) to the D-Bus marshalling argument arg. More...
static void	registerMarshallOperators (int typeId, MarshallFunction, DemarshallFunction)
	Registers the marshalling and demarshalling functions for meta type id. More...
static int	signatureToType (const char *signature)
static const char *	typeToSignature (int type)
	Returns the D-Bus signature equivalent to the supplied meta type id type. More...

Detailed Description

Meta-type registration system for the QtDBus module.

Warning

This function is not part of the public interface.

The QDBusMetaType class allows you to register class types for marshalling and demarshalling over D-Bus. D-Bus supports a very limited set of primitive types, but allows one to extend the type system by creating compound types, such as arrays (lists) and structs. In order to use them with QtDBus, those types must be registered.

See QtDBus type system for more information on the type system and how to register additional types.

See also

QtDBus type system, qDBusRegisterMetaType(), QMetaType, QVariant, QDBusArgument

Definition at line 56 of file qdbusmetatype.h.

Typedefs

DemarshallFunction

QDBusMetaType::DemarshallFunction

Warning

This function is not part of the public interface.

Definition at line 60 of file qdbusmetatype.h.

MarshallFunction

QDBusMetaType::MarshallFunction

Warning

This function is not part of the public interface.

Definition at line 59 of file qdbusmetatype.h.

Functions

demarshall()

bool QDBusMetaType::demarshall ( const QDBusArgument &  arg, int  id, void *  data  )

static

Executes the demarshalling of type id (whose data will be placed in data) from the D-Bus marshalling argument arg.

Warning

This function is not part of the public interface. Returns true if the demarshalling succeeded, or false if an error occurred.

Definition at line 287 of file qdbusmetatype.cpp.

Referenced by copyArgument(), QDBusConnectionPrivate::deliverCall(), QDBusAbstractInterfacePrivate::property(), qDBusReplyFill(), and writeProperty().

{
    QDBusMetaTypeId::init();

    DemarshallFunction df;
    {
        QReadLocker locker(customTypesLock());
        QVector<QDBusCustomTypeInfo> *ct = customTypes();
        if (id >= ct->size())
            return false;       // non-existent

        const QDBusCustomTypeInfo &info = (*ct).at(id);
        if (!info.demarshall) {
            df = 0;             // make gcc happy
            return false;
        } else
            df = info.demarshall;
    }

    QDBusArgument copy = arg;
    df(copy, data);
    return true;
}

marshall()

bool QDBusMetaType::marshall ( QDBusArgument &  arg, int  id, const void *  data  )

static

Executes the marshalling of type id (whose data is contained in data) to the D-Bus marshalling argument arg.

Warning

This function is not part of the public interface. Returns true if the marshalling succeeded, or false if an error occurred.

Definition at line 255 of file qdbusmetatype.cpp.

Referenced by QDBusMarshaller::appendRegisteredType(), and QDBusArgumentPrivate::createSignature().

{
    QDBusMetaTypeId::init();

    MarshallFunction mf;
    {
        QReadLocker locker(customTypesLock());
        QVector<QDBusCustomTypeInfo> *ct = customTypes();
        if (id >= ct->size())
            return false;       // non-existent

        const QDBusCustomTypeInfo &info = (*ct).at(id);
        if (!info.marshall) {
            mf = 0;             // make gcc happy
            return false;
        } else
            mf = info.marshall;
    }

    mf(arg, data);
    return true;
}

registerMarshallOperators()

void QDBusMetaType::registerMarshallOperators ( int  id, MarshallFunction  mf, DemarshallFunction  df  )

static

Registers the marshalling and demarshalling functions for meta type id.

Warning

This function is not part of the public interface.

Definition at line 230 of file qdbusmetatype.cpp.

{
    QByteArray var;
    QVector<QDBusCustomTypeInfo> *ct = customTypes();
    if (id < 0 || !mf || !df || !ct)
        return;                 // error!

    QWriteLocker locker(customTypesLock());
    if (id >= ct->size())
        ct->resize(id + 1);
    QDBusCustomTypeInfo &info = (*ct)[id];
    info.marshall = mf;
    info.demarshall = df;
}

signatureToType()

int QDBusMetaType::signatureToType ( const char *  signature )

static

Warning

This function is not part of the public interface.

Returns the Qt meta type id for the given D-Bus signature for exactly one full type, given by signature.

Note: this function only handles the basic D-Bus types.

See also

QDBusUtil::isValidSingleSignature(), typeToSignature(), QVariant::type(), QVariant::userType()

Definition at line 323 of file qdbusmetatype.cpp.

Referenced by QDBusArgumentPrivate::createSignature(), QDBusMetaObjectGenerator::findType(), and generateInterfaceXml().

{
    if (!signature)
        return QVariant::Invalid;

    QDBusMetaTypeId::init();
    switch (signature[0])
    {
    case DBUS_TYPE_BOOLEAN:
        return QVariant::Bool;

    case DBUS_TYPE_BYTE:
        return QMetaType::UChar;

    case DBUS_TYPE_INT16:
        return QMetaType::Short;

    case DBUS_TYPE_UINT16:
        return QMetaType::UShort;

    case DBUS_TYPE_INT32:
        return QVariant::Int;

    case DBUS_TYPE_UINT32:
        return QVariant::UInt;

    case DBUS_TYPE_INT64:
        return QVariant::LongLong;

    case DBUS_TYPE_UINT64:
        return QVariant::ULongLong;

    case DBUS_TYPE_DOUBLE:
        return QVariant::Double;

    case DBUS_TYPE_STRING:
        return QVariant::String;

    case DBUS_TYPE_OBJECT_PATH:
        return QDBusMetaTypeId::objectpath;

    case DBUS_TYPE_SIGNATURE:
        return QDBusMetaTypeId::signature;

    case DBUS_TYPE_UNIX_FD:
        return QDBusMetaTypeId::unixfd;

    case DBUS_TYPE_VARIANT:
        return QDBusMetaTypeId::variant;

    case DBUS_TYPE_ARRAY:       // special case
        switch (signature[1]) {
        case DBUS_TYPE_BYTE:
            return QVariant::ByteArray;

        case DBUS_TYPE_STRING:
            return QVariant::StringList;

        case DBUS_TYPE_VARIANT:
            return QVariant::List;

        case DBUS_TYPE_OBJECT_PATH:
            return qMetaTypeId<QList<QDBusObjectPath> >();

        case DBUS_TYPE_SIGNATURE:
            return qMetaTypeId<QList<QDBusSignature> >();

        }
        // fall through
    default:
        return QVariant::Invalid;
    }
}

typeToSignature()

const char * QDBusMetaType::typeToSignature ( int  type )

static

Returns the D-Bus signature equivalent to the supplied meta type id type.

Warning

This function is not part of the public interface.

More types can be registered with the qDBusRegisterMetaType() function.

See also

QDBusUtil::isValidSingleSignature(), signatureToType(), QVariant::type(), QVariant::userType()

Definition at line 411 of file qdbusmetatype.cpp.

Referenced by QDBusMarshaller::append(), QDBusMarshaller::appendVariantInternal(), QDBusMarshaller::beginArray(), QDBusMarshaller::beginMap(), copyArgument(), findSlot(), QDBusMetaObjectGenerator::findType(), generateInterfaceXml(), QDBusMessagePrivate::makeLocal(), QDBusConnectionPrivate::prepareHook(), QDBusAbstractInterfacePrivate::property(), qDBusParametersForMethod(), qDBusReplyFill(), readAllProperties(), and QDBusPendingCallPrivate::setMetaTypes().

{
    // check if it's a static type
    switch (type)
    {
    case QMetaType::UChar:
        return DBUS_TYPE_BYTE_AS_STRING;

    case QVariant::Bool:
        return DBUS_TYPE_BOOLEAN_AS_STRING;

    case QMetaType::Short:
        return DBUS_TYPE_INT16_AS_STRING;

    case QMetaType::UShort:
        return DBUS_TYPE_UINT16_AS_STRING;

    case QVariant::Int:
        return DBUS_TYPE_INT32_AS_STRING;

    case QVariant::UInt:
        return DBUS_TYPE_UINT32_AS_STRING;

    case QVariant::LongLong:
        return DBUS_TYPE_INT64_AS_STRING;

    case QVariant::ULongLong:
        return DBUS_TYPE_UINT64_AS_STRING;

    case QVariant::Double:
        return DBUS_TYPE_DOUBLE_AS_STRING;

    case QVariant::String:
        return DBUS_TYPE_STRING_AS_STRING;

    case QVariant::StringList:
        return DBUS_TYPE_ARRAY_AS_STRING
            DBUS_TYPE_STRING_AS_STRING; // as

    case QVariant::ByteArray:
        return DBUS_TYPE_ARRAY_AS_STRING
            DBUS_TYPE_BYTE_AS_STRING; // ay
    }

    QDBusMetaTypeId::init();
    if (type == QDBusMetaTypeId::variant)
        return DBUS_TYPE_VARIANT_AS_STRING;
    else if (type == QDBusMetaTypeId::objectpath)
        return DBUS_TYPE_OBJECT_PATH_AS_STRING;
    else if (type == QDBusMetaTypeId::signature)
        return DBUS_TYPE_SIGNATURE_AS_STRING;
    else if (type == QDBusMetaTypeId::unixfd)
        return DBUS_TYPE_UNIX_FD_AS_STRING;

    // try the database
    QVector<QDBusCustomTypeInfo> *ct = customTypes();
    {
        QReadLocker locker(customTypesLock());
        if (type >= ct->size())
            return 0;           // type not registered with us

        const QDBusCustomTypeInfo &info = (*ct).at(type);

        if (!info.signature.isNull())
            return info.signature;

        if (!info.marshall)
            return 0;           // type not registered with us
    }

    // call to user code to construct the signature type
    QDBusCustomTypeInfo *info;
    {
        // createSignature will never return a null QByteArray
        // if there was an error, it'll return ""
        QByteArray signature = QDBusArgumentPrivate::createSignature(type);

        // re-acquire lock
        QWriteLocker locker(customTypesLock());
        info = &(*ct)[type];
        info->signature = signature;
    }
    return info->signature;
}

---

The documentation for this class was generated from the following files:

• /src/dbus/qdbusmetatype.h
• /src/dbus/qdbusmetatype.cpp