You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1176 lines
40 KiB
1176 lines
40 KiB
/* qdbusmarshall.cpp
|
|
*
|
|
* Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org>
|
|
* Copyright (C) 2007 Kevin Krammer <kevin.krammer@gmx.at>
|
|
*
|
|
* Licensed under the Academic Free License version 2.1
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
* USA.
|
|
*
|
|
*/
|
|
|
|
#include "tqdbusmarshall.h"
|
|
#include "tqdbusdata.h"
|
|
#include "tqdbusdatalist.h"
|
|
#include "tqdbusdatamap.h"
|
|
#include "tqdbusobjectpath.h"
|
|
#include "tqdbusvariant.h"
|
|
|
|
#include <tqvariant.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqmap.h>
|
|
#include <tqstringlist.h>
|
|
#include <tqvaluevector.h>
|
|
|
|
#include <dbus/dbus.h>
|
|
|
|
template <typename T>
|
|
inline T qIterGet(DBusMessageIter *it)
|
|
{
|
|
T t;
|
|
dbus_message_iter_get_basic(it, &t);
|
|
return t;
|
|
}
|
|
|
|
static TQT_DBusData::Type qSingleTypeForDBusSignature(char signature)
|
|
{
|
|
switch (signature)
|
|
{
|
|
case 'b': return TQT_DBusData::Bool;
|
|
case 'y': return TQT_DBusData::Byte;
|
|
case 'n': return TQT_DBusData::Int16;
|
|
case 'q': return TQT_DBusData::UInt16;
|
|
case 'i': return TQT_DBusData::Int32;
|
|
case 'u': return TQT_DBusData::UInt32;
|
|
case 'x': return TQT_DBusData::Int64;
|
|
case 't': return TQT_DBusData::UInt64;
|
|
case 'd': return TQT_DBusData::Double;
|
|
case 's': return TQT_DBusData::String;
|
|
case 'o': return TQT_DBusData::ObjectPath;
|
|
case 'g': return TQT_DBusData::String;
|
|
case 'v': return TQT_DBusData::Variant;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TQT_DBusData::Invalid;
|
|
}
|
|
|
|
static TQValueList<TQT_DBusData> parseSignature(TQCString& signature)
|
|
{
|
|
// tqDebug("parseSignature(%s)", signature.data());
|
|
TQValueList<TQT_DBusData> result;
|
|
|
|
while (!signature.isEmpty())
|
|
{
|
|
switch (signature[0])
|
|
{
|
|
case '(': {
|
|
signature = signature.mid(1);
|
|
TQValueList<TQT_DBusData> memberList = parseSignature(signature);
|
|
result << TQT_DBusData::fromStruct(memberList);
|
|
Q_ASSERT(!signature.isEmpty() && signature[0] == ')');
|
|
signature = signature.mid(1);
|
|
break;
|
|
}
|
|
case ')': return result;
|
|
case '{': {
|
|
TQT_DBusData::Type keyType =
|
|
qSingleTypeForDBusSignature(signature[1]);
|
|
TQT_DBusData::Type valueType =
|
|
qSingleTypeForDBusSignature(signature[2]);
|
|
if (valueType != TQT_DBusData::Invalid)
|
|
{
|
|
switch (keyType)
|
|
{
|
|
case TQT_DBusData::Byte:
|
|
result << TQT_DBusData::fromByteKeyMap(
|
|
TQT_DBusDataMap<TQ_UINT8>(valueType));
|
|
break;
|
|
case TQT_DBusData::Int16:
|
|
result << TQT_DBusData::fromInt16KeyMap(
|
|
TQT_DBusDataMap<TQ_INT16>(valueType));
|
|
break;
|
|
case TQT_DBusData::UInt16:
|
|
result << TQT_DBusData::fromUInt16KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT16>(valueType));
|
|
break;
|
|
case TQT_DBusData::Int32:
|
|
result << TQT_DBusData::fromInt32KeyMap(
|
|
TQT_DBusDataMap<TQ_INT32>(valueType));
|
|
break;
|
|
case TQT_DBusData::UInt32:
|
|
result << TQT_DBusData::fromUInt32KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT32>(valueType));
|
|
break;
|
|
case TQT_DBusData::Int64:
|
|
result << TQT_DBusData::fromInt64KeyMap(
|
|
TQT_DBusDataMap<TQ_INT64>(valueType));
|
|
break;
|
|
case TQT_DBusData::UInt64:
|
|
result << TQT_DBusData::fromUInt64KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT64>(valueType));
|
|
break;
|
|
case TQT_DBusData::String:
|
|
result << TQT_DBusData::fromStringKeyMap(
|
|
TQT_DBusDataMap<TQString>(valueType));
|
|
break;
|
|
case TQT_DBusData::ObjectPath:
|
|
result << TQT_DBusData::fromObjectPathKeyMap(
|
|
TQT_DBusDataMap<TQT_DBusObjectPath>(valueType));
|
|
break;
|
|
default:
|
|
tqWarning("TQT_DBusMarshall: unsupported map key type %s "
|
|
"at de-marshalling",
|
|
TQT_DBusData::typeName(keyType));
|
|
break;
|
|
}
|
|
signature = signature.mid(3);
|
|
}
|
|
else
|
|
{
|
|
signature = signature.mid(2);
|
|
TQValueList<TQT_DBusData> valueContainer =
|
|
parseSignature(signature);
|
|
Q_ASSERT(valueContainer.count() == 1);
|
|
|
|
switch (keyType)
|
|
{
|
|
case TQT_DBusData::Byte:
|
|
result << TQT_DBusData::fromByteKeyMap(
|
|
TQT_DBusDataMap<TQ_UINT8>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::Int16:
|
|
result << TQT_DBusData::fromInt16KeyMap(
|
|
TQT_DBusDataMap<TQ_INT16>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::UInt16:
|
|
result << TQT_DBusData::fromUInt16KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT16>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::Int32:
|
|
result << TQT_DBusData::fromInt32KeyMap(
|
|
TQT_DBusDataMap<TQ_INT32>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::UInt32:
|
|
result << TQT_DBusData::fromUInt32KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT32>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::Int64:
|
|
result << TQT_DBusData::fromInt64KeyMap(
|
|
TQT_DBusDataMap<TQ_INT64>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::UInt64:
|
|
result << TQT_DBusData::fromUInt64KeyMap(
|
|
TQT_DBusDataMap<TQ_UINT64>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::String:
|
|
result << TQT_DBusData::fromStringKeyMap(
|
|
TQT_DBusDataMap<TQString>(valueContainer[0]));
|
|
break;
|
|
case TQT_DBusData::ObjectPath:
|
|
result << TQT_DBusData::fromObjectPathKeyMap(
|
|
TQT_DBusDataMap<TQT_DBusObjectPath>(valueContainer[0]));
|
|
break;
|
|
default:
|
|
tqWarning("TQT_DBusMarshall: unsupported map key type %s "
|
|
"at de-marshalling",
|
|
TQT_DBusData::typeName(keyType));
|
|
break;
|
|
}
|
|
}
|
|
Q_ASSERT(!signature.isEmpty() && signature[0] == '}');
|
|
signature = signature.mid(1);
|
|
break;
|
|
}
|
|
case '}': return result;
|
|
case 'a': {
|
|
TQT_DBusData::Type elementType =
|
|
qSingleTypeForDBusSignature(signature[1]);
|
|
if (elementType != TQT_DBusData::Invalid)
|
|
{
|
|
TQT_DBusDataList list(elementType);
|
|
result << TQT_DBusData::fromList(list);
|
|
signature = signature.mid(2);
|
|
}
|
|
else
|
|
{
|
|
signature = signature.mid(1);
|
|
bool array = signature[0] != '{';
|
|
|
|
TQValueList<TQT_DBusData> elementContainer =
|
|
parseSignature(signature);
|
|
Q_ASSERT(elementContainer.count() == 1);
|
|
|
|
if (array)
|
|
{
|
|
TQT_DBusDataList list(elementContainer[0]);
|
|
result << TQT_DBusData::fromList(list);
|
|
}
|
|
else
|
|
result << elementContainer[0];
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
TQT_DBusData::Type elementType =
|
|
qSingleTypeForDBusSignature(signature[0]);
|
|
if (elementType != TQT_DBusData::Invalid)
|
|
{
|
|
switch (elementType)
|
|
{
|
|
case TQT_DBusData::Bool:
|
|
result << TQT_DBusData::fromBool(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::Byte:
|
|
result << TQT_DBusData::fromByte(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::Int16:
|
|
result << TQT_DBusData::fromInt16(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::UInt16:
|
|
result << TQT_DBusData::fromUInt16(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::Int32:
|
|
result << TQT_DBusData::fromInt32(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::UInt32:
|
|
result << TQT_DBusData::fromUInt32(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::Int64:
|
|
result << TQT_DBusData::fromInt64(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::UInt64:
|
|
result << TQT_DBusData::fromUInt64(
|
|
(0));
|
|
break;
|
|
case TQT_DBusData::String:
|
|
result << TQT_DBusData::fromString(
|
|
(TQString()));
|
|
break;
|
|
case TQT_DBusData::ObjectPath:
|
|
result << TQT_DBusData::fromObjectPath(
|
|
(TQT_DBusObjectPath()));
|
|
break;
|
|
default:
|
|
result << TQT_DBusData();
|
|
tqWarning("TQT_DBusMarshall: unsupported element type %s "
|
|
"at de-marshalling",
|
|
TQT_DBusData::typeName(elementType));
|
|
break;
|
|
}
|
|
signature = signature.mid(1);
|
|
}
|
|
else {
|
|
result << TQT_DBusData();
|
|
signature = signature.mid(1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static TQT_DBusData qFetchParameter(DBusMessageIter *it);
|
|
|
|
void qFetchByteKeyMapEntry(TQT_DBusDataMap<TQ_UINT8>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_UINT8 key = qFetchParameter(&itemIter).toByte();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchInt16KeyMapEntry(TQT_DBusDataMap<TQ_INT16>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_INT16 key = qFetchParameter(&itemIter).toInt16();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchUInt16KeyMapEntry(TQT_DBusDataMap<TQ_UINT16>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_UINT16 key = qFetchParameter(&itemIter).toUInt16();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchInt32KeyMapEntry(TQT_DBusDataMap<TQ_INT32>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_INT32 key = qFetchParameter(&itemIter).toInt32();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchUInt32KeyMapEntry(TQT_DBusDataMap<TQ_UINT32>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_UINT32 key = qFetchParameter(&itemIter).toUInt32();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchInt64KeyMapEntry(TQT_DBusDataMap<TQ_INT64>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_INT64 key = qFetchParameter(&itemIter).toInt64();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchUInt64KeyMapEntry(TQT_DBusDataMap<TQ_UINT64>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQ_UINT64 key = qFetchParameter(&itemIter).toUInt64();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
void qFetchStringKeyMapEntry(TQT_DBusDataMap<TQString>& map, DBusMessageIter* it)
|
|
{
|
|
DBusMessageIter itemIter;
|
|
dbus_message_iter_recurse(it, &itemIter);
|
|
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
|
|
|
|
TQString key = qFetchParameter(&itemIter).toString();
|
|
|
|
dbus_message_iter_next(&itemIter);
|
|
|
|
map.insert(key, qFetchParameter(&itemIter));
|
|
}
|
|
|
|
static TQT_DBusData qFetchMap(DBusMessageIter *it, const TQT_DBusData& 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: {
|
|
TQT_DBusDataMap<TQ_UINT8> map = prototype.toByteKeyMap();
|
|
do {
|
|
qFetchByteKeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromByteKeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_INT16: {
|
|
TQT_DBusDataMap<TQ_INT16> map = prototype.toInt16KeyMap();
|
|
do {
|
|
qFetchInt16KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromInt16KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_UINT16: {
|
|
TQT_DBusDataMap<TQ_UINT16> map = prototype.toUInt16KeyMap();
|
|
do {
|
|
qFetchUInt16KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromUInt16KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_INT32: {
|
|
TQT_DBusDataMap<TQ_INT32> map = prototype.toInt32KeyMap();
|
|
do {
|
|
qFetchInt32KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromInt32KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_UINT32: {
|
|
TQT_DBusDataMap<TQ_UINT32> map = prototype.toUInt32KeyMap();
|
|
do {
|
|
qFetchUInt32KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromUInt32KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_INT64: {
|
|
TQT_DBusDataMap<TQ_INT64> map = prototype.toInt64KeyMap();
|
|
do {
|
|
qFetchInt64KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromInt64KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_UINT64: {
|
|
TQT_DBusDataMap<TQ_UINT64> map = prototype.toUInt64KeyMap();
|
|
do {
|
|
qFetchUInt64KeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromUInt64KeyMap(map);
|
|
}
|
|
|
|
case DBUS_TYPE_STRING: // fall through
|
|
case DBUS_TYPE_OBJECT_PATH: // fall through
|
|
case DBUS_TYPE_SIGNATURE: {
|
|
TQT_DBusDataMap<TQString> map = prototype.toStringKeyMap();
|
|
do {
|
|
qFetchStringKeyMapEntry(map, it);
|
|
} while (dbus_message_iter_next(it));
|
|
|
|
return TQT_DBusData::fromStringKeyMap(map);
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return prototype;
|
|
}
|
|
|
|
static TQT_DBusData qFetchParameter(DBusMessageIter *it)
|
|
{
|
|
switch (dbus_message_iter_get_arg_type(it)) {
|
|
case DBUS_TYPE_BOOLEAN:
|
|
return TQT_DBusData::fromBool(qIterGet<dbus_bool_t>(it));
|
|
case DBUS_TYPE_BYTE:
|
|
return TQT_DBusData::fromByte(qIterGet<unsigned char>(it));
|
|
case DBUS_TYPE_INT16:
|
|
return TQT_DBusData::fromInt16(qIterGet<dbus_int16_t>(it));
|
|
case DBUS_TYPE_UINT16:
|
|
return TQT_DBusData::fromUInt16(qIterGet<dbus_uint16_t>(it));
|
|
case DBUS_TYPE_INT32:
|
|
return TQT_DBusData::fromInt32(qIterGet<dbus_int32_t>(it));
|
|
case DBUS_TYPE_UINT32:
|
|
return TQT_DBusData::fromUInt32(qIterGet<dbus_uint32_t>(it));
|
|
case DBUS_TYPE_INT64:
|
|
return TQT_DBusData::fromInt64(qIterGet<dbus_int64_t>(it));
|
|
case DBUS_TYPE_UINT64:
|
|
return TQT_DBusData::fromUInt64(qIterGet<dbus_uint64_t>(it));
|
|
case DBUS_TYPE_DOUBLE:
|
|
return TQT_DBusData::fromDouble(qIterGet<double>(it));
|
|
case DBUS_TYPE_STRING:
|
|
case DBUS_TYPE_SIGNATURE:
|
|
return TQT_DBusData::fromString(TQString::fromUtf8(qIterGet<char *>(it)));
|
|
case DBUS_TYPE_OBJECT_PATH:
|
|
return TQT_DBusData::fromObjectPath(TQT_DBusObjectPath(qIterGet<char *>(it)));
|
|
case DBUS_TYPE_ARRAY: {
|
|
int arrayType = dbus_message_iter_get_element_type(it);
|
|
|
|
char* sig = dbus_message_iter_get_signature(it);
|
|
TQCString signature = sig;
|
|
dbus_free(sig);
|
|
|
|
TQValueList<TQT_DBusData> prototypeList = parseSignature(signature);
|
|
|
|
if (arrayType == DBUS_TYPE_DICT_ENTRY) {
|
|
DBusMessageIter sub;
|
|
dbus_message_iter_recurse(it, &sub);
|
|
|
|
return qFetchMap(&sub, prototypeList[0]);
|
|
|
|
// } else if (arrayType == DBUS_TYPE_BYTE) {
|
|
// DBusMessageIter sub;
|
|
// dbus_message_iter_recurse(it, &sub);
|
|
// int len = dbus_message_iter_get_array_len(&sub);
|
|
// char* data;
|
|
// dbus_message_iter_get_fixed_array(&sub,&data,&len);
|
|
// return TQCString(data,len);
|
|
// } else {
|
|
|
|
} else {
|
|
TQT_DBusDataList list = prototypeList[0].toList();
|
|
|
|
DBusMessageIter arrayIt;
|
|
dbus_message_iter_recurse(it, &arrayIt);
|
|
|
|
while (dbus_message_iter_get_arg_type(&arrayIt) != DBUS_TYPE_INVALID) {
|
|
list << qFetchParameter(&arrayIt);
|
|
|
|
dbus_message_iter_next(&arrayIt);
|
|
}
|
|
|
|
return TQT_DBusData::fromList(list);
|
|
}
|
|
}
|
|
case DBUS_TYPE_VARIANT: {
|
|
TQT_DBusVariant dvariant;
|
|
DBusMessageIter sub;
|
|
dbus_message_iter_recurse(it, &sub);
|
|
|
|
char* signature = dbus_message_iter_get_signature(&sub);
|
|
dvariant.signature = TQString::fromUtf8(signature);
|
|
dbus_free(signature);
|
|
|
|
dvariant.value = qFetchParameter(&sub);
|
|
|
|
return TQT_DBusData::fromVariant(dvariant);
|
|
}
|
|
case DBUS_TYPE_STRUCT: {
|
|
TQValueList<TQT_DBusData> memberList;
|
|
|
|
DBusMessageIter subIt;
|
|
dbus_message_iter_recurse(it, &subIt);
|
|
|
|
uint index = 0;
|
|
while (dbus_message_iter_get_arg_type(&subIt) != DBUS_TYPE_INVALID) {
|
|
memberList << qFetchParameter(&subIt);
|
|
|
|
dbus_message_iter_next(&subIt);
|
|
++index;
|
|
}
|
|
|
|
return TQT_DBusData::fromStruct(memberList);
|
|
}
|
|
#if 0
|
|
case DBUS_TYPE_INVALID:
|
|
// TODO: check if there is better way to detect empty arrays
|
|
return TQT_DBusData();
|
|
break;
|
|
#endif
|
|
default:
|
|
tqWarning("TQT_DBusMarshall: Don't know how to de-marshall type %d '%c'",
|
|
dbus_message_iter_get_arg_type(it),
|
|
dbus_message_iter_get_arg_type(it));
|
|
return TQT_DBusData();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TQT_DBusMarshall::messageToList(TQValueList<TQT_DBusData>& list, DBusMessage* message)
|
|
{
|
|
Q_ASSERT(message);
|
|
|
|
DBusMessageIter it;
|
|
if (!dbus_message_iter_init(message, &it)) return;
|
|
|
|
do
|
|
{
|
|
list << qFetchParameter(&it);
|
|
}
|
|
while (dbus_message_iter_next(&it));
|
|
}
|
|
|
|
static void tqAppendToMessage(DBusMessageIter *it, const TQString &str)
|
|
{
|
|
TQByteArray ba = str.utf8();
|
|
const char *cdata = ba.data();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_STRING, &cdata);
|
|
}
|
|
|
|
static void tqAppendToMessage(DBusMessageIter *it, const TQT_DBusObjectPath &path)
|
|
{
|
|
const char *cdata = path.data();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_OBJECT_PATH, &cdata);
|
|
}
|
|
|
|
static const char* qDBusTypeForTQT_DBusType(TQT_DBusData::Type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case TQT_DBusData::Invalid:
|
|
return 0;
|
|
|
|
case TQT_DBusData::Bool:
|
|
return DBUS_TYPE_BOOLEAN_AS_STRING;
|
|
|
|
case TQT_DBusData::Byte:
|
|
return DBUS_TYPE_BYTE_AS_STRING;
|
|
|
|
case TQT_DBusData::Int16:
|
|
return DBUS_TYPE_INT16_AS_STRING;
|
|
|
|
case TQT_DBusData::UInt16:
|
|
return DBUS_TYPE_UINT16_AS_STRING;
|
|
|
|
case TQT_DBusData::Int32:
|
|
return DBUS_TYPE_INT32_AS_STRING;
|
|
|
|
case TQT_DBusData::UInt32:
|
|
return DBUS_TYPE_UINT32_AS_STRING;
|
|
|
|
case TQT_DBusData::Int64:
|
|
return DBUS_TYPE_INT64_AS_STRING;
|
|
|
|
case TQT_DBusData::UInt64:
|
|
return DBUS_TYPE_UINT64_AS_STRING;
|
|
|
|
case TQT_DBusData::Double:
|
|
return DBUS_TYPE_DOUBLE_AS_STRING;
|
|
|
|
case TQT_DBusData::String:
|
|
return DBUS_TYPE_STRING_AS_STRING;
|
|
|
|
case TQT_DBusData::ObjectPath:
|
|
return DBUS_TYPE_OBJECT_PATH_AS_STRING;
|
|
|
|
case TQT_DBusData::List:
|
|
return DBUS_TYPE_ARRAY_AS_STRING;
|
|
|
|
case TQT_DBusData::Struct:
|
|
return DBUS_TYPE_STRUCT_AS_STRING;
|
|
|
|
case TQT_DBusData::Variant:
|
|
return DBUS_TYPE_VARIANT_AS_STRING;
|
|
|
|
case TQT_DBusData::Map:
|
|
return DBUS_TYPE_DICT_ENTRY_AS_STRING;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var);
|
|
|
|
static void qDBusByteKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_UINT8> map = var.toByteKeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_UINT8>::const_iterator 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_BYTE, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_INT16> map = var.toInt16KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_INT16>::const_iterator 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_INT16, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusUInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_UINT16> map = var.toUInt16KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_UINT16>::const_iterator 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);
|
|
}
|
|
|
|
static void qDBusInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_INT32> map = var.toInt32KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_INT32>::const_iterator 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_INT32, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusUInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_UINT32> map = var.toUInt32KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_UINT32>::const_iterator 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_UINT32, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_INT64> map = var.toInt64KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_INT64>::const_iterator 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_INT64, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusUInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQ_UINT64> map = var.toUInt64KeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQ_UINT64>::const_iterator 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_UINT64, &(mit.key()));
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusStringKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQString> map = var.toStringKeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQString>::const_iterator mit = map.begin();
|
|
for (; mit != map.end(); ++mit)
|
|
{
|
|
DBusMessageIter itemIterator;
|
|
dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
|
|
0, &itemIterator);
|
|
|
|
tqAppendToMessage(&itemIterator, mit.key());
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusObjectPathKeyMapToIterator(DBusMessageIter* it,
|
|
const TQT_DBusData& var)
|
|
{
|
|
DBusMessageIter sub;
|
|
TQCString sig;
|
|
|
|
TQT_DBusDataMap<TQT_DBusObjectPath> map = var.toObjectPathKeyMap();
|
|
|
|
sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
|
|
sig += qDBusTypeForTQT_DBusType(map.keyType());
|
|
|
|
if (map.hasContainerValueType())
|
|
sig += map.containerValueType().buildDBusSignature();
|
|
else
|
|
sig += qDBusTypeForTQT_DBusType(map.valueType());
|
|
sig += DBUS_DICT_ENTRY_END_CHAR;
|
|
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
|
|
|
|
TQT_DBusDataMap<TQT_DBusObjectPath>::const_iterator mit = map.begin();
|
|
for (; mit != map.end(); ++mit)
|
|
{
|
|
DBusMessageIter itemIterator;
|
|
dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
|
|
0, &itemIterator);
|
|
|
|
tqAppendToMessage(&itemIterator, mit.key());
|
|
qDBusDataToIterator(&itemIterator, mit.data());
|
|
|
|
dbus_message_iter_close_container(&sub, &itemIterator);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
|
|
static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var)
|
|
{
|
|
switch (var.type())
|
|
{
|
|
case TQT_DBusData::Bool:
|
|
{
|
|
dbus_bool_t value = var.toBool();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_BOOLEAN, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Byte:
|
|
{
|
|
TQ_UINT8 value = var.toByte();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Int16: {
|
|
TQ_INT16 value = var.toInt16();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::UInt16: {
|
|
TQ_UINT16 value = var.toUInt16();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Int32: {
|
|
TQ_INT32 value = var.toInt32();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::UInt32: {
|
|
TQ_UINT32 value = var.toUInt32();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Int64: {
|
|
TQ_INT64 value = var.toInt64();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::UInt64: {
|
|
TQ_UINT64 value = var.toUInt64();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Double: {
|
|
double value = var.toDouble();
|
|
dbus_message_iter_append_basic(it, DBUS_TYPE_DOUBLE, &value);
|
|
break;
|
|
}
|
|
case TQT_DBusData::String:
|
|
tqAppendToMessage(it, var.toString());
|
|
break;
|
|
case TQT_DBusData::ObjectPath:
|
|
tqAppendToMessage(it, var.toObjectPath());
|
|
break;
|
|
case TQT_DBusData::List: {
|
|
TQT_DBusDataList list = var.toList();
|
|
|
|
TQCString signature = 0;
|
|
if (list.hasContainerItemType())
|
|
signature = list.containerItemType().buildDBusSignature();
|
|
else
|
|
signature = qDBusTypeForTQT_DBusType(list.type());
|
|
|
|
DBusMessageIter sub;
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
|
|
signature.data(), &sub);
|
|
|
|
const TQValueList<TQT_DBusData> valueList = var.toTQValueList();
|
|
TQValueList<TQT_DBusData>::const_iterator listIt = valueList.begin();
|
|
TQValueList<TQT_DBusData>::const_iterator listEndIt = valueList.end();
|
|
for (; listIt != listEndIt; ++listIt)
|
|
{
|
|
qDBusDataToIterator(&sub, *listIt);
|
|
}
|
|
dbus_message_iter_close_container(it, &sub);
|
|
break;
|
|
}
|
|
case TQT_DBusData::Map: {
|
|
switch (var.keyType()) {
|
|
case TQT_DBusData::Byte:
|
|
qDBusByteKeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::Int16:
|
|
qDBusInt16KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::UInt16:
|
|
qDBusUInt16KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::Int32:
|
|
qDBusInt32KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::UInt32:
|
|
qDBusUInt32KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::Int64:
|
|
qDBusInt64KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::UInt64:
|
|
qDBusUInt64KeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::String:
|
|
qDBusStringKeyMapToIterator(it, var);
|
|
break;
|
|
case TQT_DBusData::ObjectPath:
|
|
qDBusObjectPathKeyMapToIterator(it, var);
|
|
break;
|
|
default:
|
|
tqWarning("TQT_DBusMarshall: unhandled map key type %s "
|
|
"at marshalling",
|
|
TQT_DBusData::typeName(var.keyType()));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case TQT_DBusData::Variant: {
|
|
TQT_DBusVariant 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 TQT_DBusData::Struct: {
|
|
TQValueList<TQT_DBusData> memberList = var.toStruct();
|
|
if (memberList.isEmpty()) break;
|
|
|
|
DBusMessageIter sub;
|
|
dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub);
|
|
|
|
TQValueList<TQT_DBusData>::const_iterator memberIt = memberList.begin();
|
|
TQValueList<TQT_DBusData>::const_iterator memberEndIt = memberList.end();
|
|
for (; memberIt != memberEndIt; ++memberIt)
|
|
{
|
|
qDBusDataToIterator(&sub, *memberIt);
|
|
}
|
|
|
|
dbus_message_iter_close_container(it, &sub);
|
|
}
|
|
#if 0
|
|
case TQVariant::ByteArray: {
|
|
const TQByteArray 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:
|
|
//tqWarning("Don't know how to handle type %s", var.typeName());
|
|
break;
|
|
}
|
|
}
|
|
|
|
void qListToIterator(DBusMessageIter* it, const TQValueList<TQT_DBusData>& list)
|
|
{
|
|
if (list.isEmpty()) return;
|
|
|
|
TQValueList<TQT_DBusData>::const_iterator listIt = list.begin();
|
|
TQValueList<TQT_DBusData>::const_iterator listEndIt = list.end();
|
|
for (; listIt != listEndIt; ++listIt)
|
|
{
|
|
qDBusDataToIterator(it, *listIt);
|
|
}
|
|
}
|
|
|
|
void TQT_DBusMarshall::listToMessage(const TQValueList<TQT_DBusData> &list, DBusMessage *msg)
|
|
{
|
|
Q_ASSERT(msg);
|
|
DBusMessageIter it;
|
|
dbus_message_iter_init_append(msg, &it);
|
|
qListToIterator(&it, list);
|
|
}
|