Ejemplo n.º 1
0
QDBusDataList::QDBusDataList(const QDBusData &containerItemType) : d(new Private())
{
    d->type = containerItemType.type();

    switch(d->type)
    {
        case QDBusData::List:   // fall through
        case QDBusData::Struct: // fall through
        case QDBusData::Map:
            d->containerItem = containerItemType;
            break;

        default: // not a container
            break;
    }
}
Ejemplo n.º 2
0
static void qDBusDataToIterator(DBusMessageIter* it, const QDBusData& var)
{
    switch (var.type())
    {
        case QDBusData::Bool:
        {
            dbus_bool_t value = var.toBool();
            dbus_message_iter_append_basic(it, DBUS_TYPE_BOOLEAN, &value);
            break;
        }
        case QDBusData::Byte:
        {
            Q_UINT8 value = var.toByte();
            dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &value);
            break;
        }
        case QDBusData::Int16: {
            Q_INT16 value = var.toInt16();
            dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &value);
            break;
        }
        case QDBusData::UInt16: {
            Q_UINT16 value = var.toUInt16();
            dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &value);
            break;
        }
        case QDBusData::Int32: {
            Q_INT32 value = var.toInt32();
            dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &value);
            break;
        }
        case QDBusData::UInt32: {
            Q_UINT32 value = var.toUInt32();
            dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &value);
            break;
        }
        case QDBusData::Int64: {
            Q_INT64 value = var.toInt64();
            dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &value);
            break;
        }
        case QDBusData::UInt64: {
            Q_UINT64 value = var.toUInt64();
            dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &value);
            break;
        }
        case QDBusData::Double: {
            double value = var.toDouble();
            dbus_message_iter_append_basic(it, DBUS_TYPE_DOUBLE, &value);
            break;
        }
        case QDBusData::String:
            qAppendToMessage(it, var.toString());
            break;
        case QDBusData::ObjectPath:
            qAppendToMessage(it, var.toObjectPath());
            break;
        case QDBusData::List: {
            QDBusDataList list = var.toList();

            QCString signature = 0;
            if (list.hasContainerItemType())
                signature = list.containerItemType().buildDBusSignature();
            else
                signature = qDBusTypeForQDBusType(list.type());

            DBusMessageIter sub;
            dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
                                             signature.data(), &sub);

            const QValueList<QDBusData> valueList = var.toQValueList();
            QValueList<QDBusData>::ConstIterator listIt    = valueList.begin();
            QValueList<QDBusData>::ConstIterator listEndIt = valueList.end();
            for (; listIt != listEndIt; ++listIt)
            {
                qDBusDataToIterator(&sub, *listIt);
            }
            dbus_message_iter_close_container(it, &sub);
            break;
        }
        case QDBusData::Map: {
            switch (var.keyType()) {
                case QDBusData::Byte:
                    qDBusByteKeyMapToIterator(it, var);
                    break;
                case QDBusData::Int16:
                    qDBusInt16KeyMapToIterator(it, var);
                    break;
                case QDBusData::UInt16:
                    qDBusUInt16KeyMapToIterator(it, var);
                    break;
                case QDBusData::Int32:
                    qDBusInt32KeyMapToIterator(it, var);
                    break;
                case QDBusData::UInt32:
                    qDBusUInt32KeyMapToIterator(it, var);
                    break;
                case QDBusData::Int64:
                    qDBusInt64KeyMapToIterator(it, var);
                    break;
                case QDBusData::UInt64:
                    qDBusUInt64KeyMapToIterator(it, var);
                    break;
                case QDBusData::String:
                    qDBusStringKeyMapToIterator(it, var);
                    break;
                case QDBusData::ObjectPath:
                    qDBusObjectPathKeyMapToIterator(it, var);
                    break;
                default:
                    qWarning("QDBusMarshall: unhandled map key type %s "
                             "at marshalling",
                             QDBusData::typeName(var.keyType()));
                    break;
            }
            break;
        }
        case QDBusData::Variant: {
            QDBusVariant variant = var.toVariant();
            if (variant.signature.isEmpty() || !variant.value.isValid()) break;

            DBusMessageIter sub;
            dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT,
                                             variant.signature.utf8(), &sub);

            qDBusDataToIterator(&sub, variant.value);

            dbus_message_iter_close_container(it, &sub);
            break;
        }
        case QDBusData::Struct: {
            QValueList<QDBusData> memberList = var.toStruct();
            if (memberList.isEmpty()) break;

            DBusMessageIter sub;
            dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub);

            QValueList<QDBusData>::ConstIterator memberIt    = memberList.begin();
            QValueList<QDBusData>::ConstIterator memberEndIt = memberList.end();
            for (; memberIt != memberEndIt; ++memberIt)
            {
                qDBusDataToIterator(&sub, *memberIt);
            }

            dbus_message_iter_close_container(it, &sub);
        }
#if 0
        case QVariant::ByteArray: {
            const QByteArray array = var.toByteArray();
            const char* cdata = array.data();
                DBusMessageIter sub;
                dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub);
            dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.size());
                dbus_message_iter_close_container(it, &sub);
        break;
        }
#endif
        default:
            //qWarning("Don't know how to handle type %s", var.typeName());
            break;
    }
}