Esempio n. 1
0
static void qDBusUInt16KeyMapToIterator(DBusMessageIter* it, const QDBusData& var)
{
    DBusMessageIter sub;
    QCString sig;

    QDBusDataMap<Q_UINT16> map = var.toUInt16KeyMap();

    sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
    sig += qDBusTypeForQDBusType(map.keyType());

    if (map.hasContainerValueType())
        sig += map.containerValueType().buildDBusSignature();
    else
        sig += qDBusTypeForQDBusType(map.valueType());
    sig += DBUS_DICT_ENTRY_END_CHAR;

    dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);

    QDBusDataMap<Q_UINT16>::ConstIterator mit = map.begin();
    for (; mit != map.end(); ++mit)
    {
        DBusMessageIter itemIterator;
        dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
                                         0, &itemIterator);

        dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &(mit.key()));
        qDBusDataToIterator(&itemIterator, mit.data());

        dbus_message_iter_close_container(&sub, &itemIterator);
    }

    dbus_message_iter_close_container(it, &sub);
}
Esempio n. 2
0
static QDBusData qFetchMap(DBusMessageIter *it, const QDBusData& prototype)
{
    if (dbus_message_iter_get_arg_type(it) == DBUS_TYPE_INVALID)
        return prototype;

    DBusMessageIter itemIter;
    dbus_message_iter_recurse(it, &itemIter);
    if (dbus_message_iter_get_arg_type(&itemIter) == DBUS_TYPE_INVALID)
        return prototype;

    switch (dbus_message_iter_get_arg_type(&itemIter)) {
        case DBUS_TYPE_BYTE: {
            QDBusDataMap<Q_UINT8> map = prototype.toByteKeyMap();
            do {
                qFetchByteKeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromByteKeyMap(map);
        }

        case DBUS_TYPE_INT16: {
            QDBusDataMap<Q_INT16> map = prototype.toInt16KeyMap();
            do {
                qFetchInt16KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromInt16KeyMap(map);
        }

        case DBUS_TYPE_UINT16: {
            QDBusDataMap<Q_UINT16> map = prototype.toUInt16KeyMap();
            do {
                qFetchUInt16KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromUInt16KeyMap(map);
        }

        case DBUS_TYPE_INT32: {
            QDBusDataMap<Q_INT32> map = prototype.toInt32KeyMap();
            do {
                qFetchInt32KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromInt32KeyMap(map);
        }

        case DBUS_TYPE_UINT32: {
            QDBusDataMap<Q_UINT32> map = prototype.toUInt32KeyMap();
            do {
                qFetchUInt32KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromUInt32KeyMap(map);
        }

        case DBUS_TYPE_INT64: {
            QDBusDataMap<Q_INT64> map = prototype.toInt64KeyMap();
            do {
                qFetchInt64KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromInt64KeyMap(map);
        }

        case DBUS_TYPE_UINT64: {
            QDBusDataMap<Q_UINT64> map = prototype.toUInt64KeyMap();
            do {
                qFetchUInt64KeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromUInt64KeyMap(map);
        }

        case DBUS_TYPE_STRING:      // fall through
        case DBUS_TYPE_OBJECT_PATH: // fall through
        case DBUS_TYPE_SIGNATURE: {
            QDBusDataMap<QString> map = prototype.toStringKeyMap();
            do {
                qFetchStringKeyMapEntry(map, it);
            } while (dbus_message_iter_next(it));

            return QDBusData::fromStringKeyMap(map);
        }

        default:
            break;
    }

    return prototype;
}
Esempio n. 3
0
bool QDBusData::operator==(const QDBusData& other) const
{
    if (&other == this) return true;

    if (d == other.d) return true;

    if (d->type == other.d->type)
    {
        switch (d->type)
        {
            case QDBusData::Invalid:
                return true;

            case QDBusData::Bool:
                return d->value.boolValue == other.d->value.boolValue;

            case QDBusData::Byte:
                return d->value.byteValue == other.d->value.byteValue;

            case QDBusData::Int16:
                return d->value.int16Value == other.d->value.int16Value;

            case QDBusData::UInt16:
                return d->value.uint16Value == other.d->value.uint16Value;

            case QDBusData::Int32:
                return d->value.int32Value == other.d->value.int32Value;

            case QDBusData::UInt32:
                return d->value.uint32Value == other.d->value.uint32Value;

            case QDBusData::Int64:
                return d->value.int64Value == other.d->value.int64Value;

            case QDBusData::UInt64:
                return d->value.uint64Value == other.d->value.uint64Value;

            case QDBusData::Double:
                // FIXME: should not compare doubles for equality like this
                return d->value.doubleValue == other.d->value.doubleValue;

            case QDBusData::String:
                return toString() == other.toString();

            case QDBusData::ObjectPath:
                return toObjectPath() == other.toObjectPath();

            case QDBusData::List:
                return toList() == other.toList();

            case QDBusData::Struct:
                return toStruct() == other.toStruct();

            case QDBusData::Variant:
                return toVariant() == other.toVariant();

            case QDBusData::Map:
                if (d->keyType != other.d->keyType) return false;

                switch (d->keyType)
                {
                    case QDBusData::Byte:
                        toByteKeyMap() == other.toByteKeyMap();
                        break;

                    case QDBusData::Int16:
                        toInt16KeyMap() == other.toInt16KeyMap();
                        break;

                    case QDBusData::UInt16:
                        toUInt16KeyMap() == other.toUInt16KeyMap();
                        break;

                    case QDBusData::Int32:
                        toInt32KeyMap() == other.toInt32KeyMap();
                        break;

                    case QDBusData::UInt32:
                        toUInt32KeyMap() == other.toUInt32KeyMap();
                        break;
                    case QDBusData::Int64:
                        toInt64KeyMap() == other.toInt64KeyMap();
                        break;

                    case QDBusData::UInt64:
                        toUInt64KeyMap() == other.toUInt64KeyMap();
                        break;

                    case QDBusData::String:
                        toStringKeyMap() == other.toStringKeyMap();
                        break;

                    case QDBusData::ObjectPath:
                        toObjectPathKeyMap() == other.toObjectPathKeyMap();
                        break;

                    default:
                        qFatal("QDBusData operator== unhandled map key type %d(%s)",
                               d->keyType, QDBusData::typeName(d->keyType));
                        break;
                }

                break;
        }
    }

    return false;
}