qdbusutil.cpp File Reference

#include "qdbusutil_p.h"
#include "qdbus_symbols_p.h"
#include <QtCore/qstringlist.h>
#include "qdbusargument.h"
#include "qdbusunixfiledescriptor.h"

Go to the source code of this file.

Namespaces
	QDBusUtil
	The QDBusUtil namespace contains a few functions that are of general use when dealing with D-Bus strings.

Functions
static bool	argToString (const QDBusArgument &arg, QString &out)
QString	QDBusUtil::argumentToString (const QVariant &arg)
	Dumps the contents of a QtDBus argument from arg into a string. More...
static bool	isBasicType (int c)
static bool	isFixedType (int c)
bool	QDBusUtil::isValidBasicType (int c)
	Returns true if c is a valid, basic D-Bus type. More...
bool	QDBusUtil::isValidBusName (const QString &busName)
	Returns true if busName is a valid bus name. More...
static bool	isValidCharacter (const QChar &c)
static bool	isValidCharacterNoDash (const QChar &c)
bool	QDBusUtil::isValidErrorName (const QString &errorName)
	Returns true if errorName is a valid error name. More...
bool	QDBusUtil::isValidFixedType (int c)
	Returns true if c is a valid, fixed D-Bus type. More...
bool	QDBusUtil::isValidInterfaceName (const QString &ifaceName)
	Returns true if this is ifaceName is a valid interface name. More...
bool	QDBusUtil::isValidMemberName (const QString &memberName)
	Returns true if memberName is a valid member name. More...
static bool	isValidNumber (const QChar &c)
bool	QDBusUtil::isValidObjectPath (const QString &path)
	Returns true if path is valid object path. More...
bool	QDBusUtil::isValidPartOfObjectPath (const QString &part)
bool	QDBusUtil::isValidSignature (const QString &signature)
	Returns true if signature is a valid D-Bus type signature for one or more types. More...
bool	QDBusUtil::isValidSingleSignature (const QString &signature)
	Returns true if signature is a valid D-Bus type signature for exactly one full type. More...
bool	QDBusUtil::isValidUniqueConnectionName (const QString &connName)
	Returns true if connName is a valid unique connection name. More...
static const char *	validateSingleType (const char *signature)
static bool	variantToString (const QVariant &arg, QString &out)

Variables
static const char	basicTypes [] = "sogybnqiuxtdh"
static const char	fixedTypes [] = "ybnqiuxtdh"
static const char	oneLetterTypes [] = "vsogybnqiuxtdh"

Function Documentation

argToString()

bool argToString ( const QDBusArgument &  arg, QString &  out  )

static

Definition at line 162 of file qdbusutil.cpp.

Referenced by isValidNumber(), and variantToString().

{
    QString busSig = busArg.currentSignature();
    bool doIterate = false;
    QDBusArgument::ElementType elementType = busArg.currentType();

    if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType
            && elementType != QDBusArgument::MapEntryType)
        out += QLatin1String("[Argument: ") + busSig + QLatin1Char(' ');

    switch (elementType) {
        case QDBusArgument::BasicType:
        case QDBusArgument::VariantType:
            if (!variantToString(busArg.asVariant(), out))
                return false;
            break;
        case QDBusArgument::StructureType:
            busArg.beginStructure();
            doIterate = true;
            break;
        case QDBusArgument::ArrayType:
            busArg.beginArray();
            out += QLatin1Char('{');
            doIterate = true;
            break;
        case QDBusArgument::MapType:
            busArg.beginMap();
            out += QLatin1Char('{');
            doIterate = true;
            break;
        case QDBusArgument::MapEntryType:
            busArg.beginMapEntry();
            if (!variantToString(busArg.asVariant(), out))
                return false;
            out += QLatin1String(" = ");
            if (!argToString(busArg, out))
                return false;
            busArg.endMapEntry();
            break;
        case QDBusArgument::UnknownType:
        default:
            out += QLatin1String("<ERROR - Unknown Type>");
            return false;
    }
    if (doIterate && !busArg.atEnd()) {
        while (!busArg.atEnd()) {
            if (!argToString(busArg, out))
                return false;
            out += QLatin1String(", ");
        }
        out.chop(2);
    }
    switch (elementType) {
        case QDBusArgument::BasicType:
        case QDBusArgument::VariantType:
        case QDBusArgument::UnknownType:
        case QDBusArgument::MapEntryType:
            // nothing to do
            break;
        case QDBusArgument::StructureType:
            busArg.endStructure();
            break;
        case QDBusArgument::ArrayType:
            out += QLatin1Char('}');
            busArg.endArray();
            break;
        case QDBusArgument::MapType:
            out += QLatin1Char('}');
            busArg.endMap();
            break;
    }

    if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType
            && elementType != QDBusArgument::MapEntryType)
        out += QLatin1Char(']');

    return true;
}

isBasicType()

static bool isBasicType ( int  c )

static

Definition at line 246 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidBasicType(), and validateSingleType().

{
    return c != DBUS_TYPE_INVALID && strchr(basicTypes, c) != NULL;
}

isFixedType()

static bool isFixedType ( int  c )

static

Definition at line 251 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidFixedType().

{
    return c != DBUS_TYPE_INVALID && strchr(fixedTypes, c) != NULL;
}

isValidCharacter()

static bool isValidCharacter ( const QChar &  c )

inlinestatic

Definition at line 64 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidBusName(), and QDBusUtil::isValidUniqueConnectionName().

{
    register ushort u = c.unicode();
    return (u >= 'a' && u <= 'z')
            || (u >= 'A' && u <= 'Z')
            || (u >= '0' && u <= '9')
            || (u == '_') || (u == '-');
}

isValidCharacterNoDash()

static bool isValidCharacterNoDash ( const QChar &  c )

inlinestatic

Definition at line 55 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidMemberName(), and QDBusUtil::isValidPartOfObjectPath().

{
    register ushort u = c.unicode();
    return (u >= 'a' && u <= 'z')
            || (u >= 'A' && u <= 'Z')
            || (u >= '0' && u <= '9')
            || (u == '_');
}

isValidNumber()

static bool isValidNumber ( const QChar &  c )

inlinestatic

Definition at line 73 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidBusName(), and QDBusUtil::isValidMemberName().

{
    register ushort u = c.unicode();
    return (u >= '0' && u <= '9');
}

validateSingleType()

static const char* validateSingleType ( const char *  signature )

static

Definition at line 258 of file qdbusutil.cpp.

Referenced by QDBusUtil::isValidSignature(), and QDBusUtil::isValidSingleSignature().

{
    register char c = *signature;
    if (c == DBUS_TYPE_INVALID)
        return 0;

    // is it one of the one-letter types?
    if (strchr(oneLetterTypes, c) != NULL)
        return signature + 1;

    // is it an array?
    if (c == DBUS_TYPE_ARRAY) {
        // then it's valid if the next type is valid
        // or if it's a dict-entry
        c = *++signature;
        if (c == DBUS_DICT_ENTRY_BEGIN_CHAR) {
            // beginning of a dictionary entry
            // a dictionary entry has a key which is of basic types
            // and a free value
            c = *++signature;
            if (!isBasicType(c))
                return 0;
            signature = validateSingleType(signature + 1);
            return signature && *signature == DBUS_DICT_ENTRY_END_CHAR ? signature + 1 : 0;
        }

        return validateSingleType(signature);
    }

    if (c == DBUS_STRUCT_BEGIN_CHAR) {
        // beginning of a struct
        ++signature;
        while (true) {
            signature = validateSingleType(signature);
            if (!signature)
                return 0;
            if (*signature == DBUS_STRUCT_END_CHAR)
                return signature + 1;
        }
    }

    // invalid/unknown type
    return 0;
}

variantToString()

static bool variantToString ( const QVariant &  arg, QString &  out  )

static

Definition at line 81 of file qdbusutil.cpp.

Referenced by argToString(), and QDBusUtil::argumentToString().

{
    int argType = arg.userType();

    if (argType == QVariant::StringList) {
        out += QLatin1Char('{');
        QStringList list = arg.toStringList();
        foreach (QString item, list)
            out += QLatin1Char('\"') + item + QLatin1String("\", ");
        if (!list.isEmpty())
            out.chop(2);
        out += QLatin1Char('}');
    } else if (argType == QVariant::ByteArray) {
        out += QLatin1Char('{');
        QByteArray list = arg.toByteArray();
        for (int i = 0; i < list.count(); ++i) {
            out += QString::number(list.at(i));
            out += QLatin1String(", ");
        }
        if (!list.isEmpty())
            out.chop(2);
        out += QLatin1Char('}');
    } else if (argType == QVariant::List) {
        out += QLatin1Char('{');
        QList<QVariant> list = arg.toList();
        foreach (QVariant item, list) {
            if (!variantToString(item, out))
                return false;
            out += QLatin1String(", ");
        }
        if (!list.isEmpty())
            out.chop(2);
        out += QLatin1Char('}');
    } else if (argType == QMetaType::Char || argType == QMetaType::Short || argType == QMetaType::Int
               || argType == QMetaType::Long || argType == QMetaType::LongLong) {
        out += QString::number(arg.toLongLong());
    } else if (argType == QMetaType::UChar || argType == QMetaType::UShort || argType == QMetaType::UInt
               || argType == QMetaType::ULong || argType == QMetaType::ULongLong) {
        out += QString::number(arg.toULongLong());
    } else if (argType == QMetaType::Double) {
        out += QString::number(arg.toDouble());
    } else if (argType == QMetaType::Bool) {
        out += QLatin1String(arg.toBool() ? "true" : "false");
    } else if (argType == qMetaTypeId<QDBusArgument>()) {
        argToString(qvariant_cast<QDBusArgument>(arg), out);
    } else if (argType == qMetaTypeId<QDBusObjectPath>()) {
        const QString path = qvariant_cast<QDBusObjectPath>(arg).path();
        out += QLatin1String("[ObjectPath: ");
        out += path;
        out += QLatin1Char(']');
    } else if (argType == qMetaTypeId<QDBusSignature>()) {
        out += QLatin1String("[Signature: ") + qvariant_cast<QDBusSignature>(arg).signature();
        out += QLatin1Char(']');
    } else if (argType == qMetaTypeId<QDBusUnixFileDescriptor>()) {
        out += QLatin1String("[Unix FD: ");
        out += QLatin1String(qvariant_cast<QDBusUnixFileDescriptor>(arg).isValid() ? "valid" : "not valid");
        out += QLatin1Char(']');
    } else if (argType == qMetaTypeId<QDBusVariant>()) {
        const QVariant v = qvariant_cast<QDBusVariant>(arg).variant();
        out += QLatin1String("[Variant");
        int vUserType = v.userType();
        if (vUserType != qMetaTypeId<QDBusVariant>()
                && vUserType != qMetaTypeId<QDBusSignature>()
                && vUserType != qMetaTypeId<QDBusObjectPath>()
                && vUserType != qMetaTypeId<QDBusArgument>())
            out += QLatin1Char('(') + QLatin1String(v.typeName()) + QLatin1Char(')');
        out += QLatin1String(": ");
        if (!variantToString(v, out))
            return false;
        out += QLatin1Char(']');
    } else if (arg.canConvert(QVariant::String)) {
        out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"');
    } else {
        out += QLatin1Char('[');
        out += QLatin1String(arg.typeName());
        out += QLatin1Char(']');
    }

    return true;
}

Variable Documentation

basicTypes

const char basicTypes[] = "sogybnqiuxtdh"

static

Definition at line 243 of file qdbusutil.cpp.

Referenced by isBasicType().

fixedTypes

const char fixedTypes[] = "ybnqiuxtdh"

static

Definition at line 244 of file qdbusutil.cpp.

Referenced by isFixedType().

oneLetterTypes

const char oneLetterTypes[] = "vsogybnqiuxtdh"

static

Definition at line 242 of file qdbusutil.cpp.

Referenced by validateSingleType().