DBus-1-TQt: tqdbusmarshall.cpp Source File

00001 /* qdbusmarshall.cpp
00002  *
00003  * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org>
00004  * Copyright (C) 2007 Kevin Krammer <kevin.krammer@gmx.at>
00005  *
00006  * Licensed under the Academic Free License version 2.1
00007  *
00008  * This program is free software; you can redistribute it and/or modify
00009  * it under the terms of the GNU General Public License as published by
00010  * the Free Software Foundation; either version 2 of the License, or
00011  * (at your option) any later version.
00012  *
00013  * This program is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016  * GNU General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU General Public License
00019  * along with this program; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00021  * USA.
00022  *
00023  */
00024 
00025 #include "tqdbusmarshall.h"
00026 #include "tqdbusdata.h"
00027 #include "tqdbusdatalist.h"
00028 #include "tqdbusdatamap.h"
00029 #include "tqdbusobjectpath.h"
00030 #include "tqdbusunixfd.h"
00031 #include "tqdbusvariant.h"
00032 
00033 #include <tqvariant.h>
00034 #include <tqvaluelist.h>
00035 #include <tqmap.h>
00036 #include <tqstringlist.h>
00037 #include <tqvaluevector.h>
00038 
00039 #include <dbus/dbus.h>
00040 
00041 template <typename T>
00042 inline T qIterGet(DBusMessageIter *it)
00043 {
00044     T t;
00045     dbus_message_iter_get_basic(it, &t);
00046     return t;
00047 }
00048 
00049 static TQT_DBusData::Type qSingleTypeForDBusSignature(char signature)
00050 {
00051     switch (signature)
00052     {
00053         case 'b': return TQT_DBusData::Bool;
00054         case 'y': return TQT_DBusData::Byte;
00055         case 'n': return TQT_DBusData::Int16;
00056         case 'q': return TQT_DBusData::UInt16;
00057         case 'i': return TQT_DBusData::Int32;
00058         case 'u': return TQT_DBusData::UInt32;
00059         case 'x': return TQT_DBusData::Int64;
00060         case 't': return TQT_DBusData::UInt64;
00061         case 'd': return TQT_DBusData::Double;
00062         case 's': return TQT_DBusData::String;
00063         case 'o': return TQT_DBusData::ObjectPath;
00064         case 'g': return TQT_DBusData::String;
00065         case 'v': return TQT_DBusData::Variant;
00066         case 'h': return TQT_DBusData::UnixFd;
00067 
00068         default:
00069             break;
00070     }
00071 
00072     return TQT_DBusData::Invalid;
00073 }
00074 
00075 static TQValueList<TQT_DBusData> parseSignature(TQCString& signature)
00076 {
00077 //    tqDebug("parseSignature(%s)", signature.data());
00078     TQValueList<TQT_DBusData> result;
00079 
00080     while (!signature.isEmpty())
00081     {
00082         switch (signature[0])
00083         {
00084             case '(': {
00085                 signature = signature.mid(1);
00086                 TQValueList<TQT_DBusData> memberList = parseSignature(signature);
00087                 result << TQT_DBusData::fromStruct(memberList);
00088                 Q_ASSERT(!signature.isEmpty() && signature[0] == ')');
00089                 signature = signature.mid(1);
00090                 break;
00091             }
00092             case ')': return result;
00093             case '{': {
00094                 TQT_DBusData::Type keyType =
00095                     qSingleTypeForDBusSignature(signature[1]);
00096                 TQT_DBusData::Type valueType =
00097                     qSingleTypeForDBusSignature(signature[2]);
00098                 if (valueType != TQT_DBusData::Invalid)
00099                 {
00100                     switch (keyType)
00101                     {
00102                         case TQT_DBusData::Byte:
00103                             result << TQT_DBusData::fromByteKeyMap(
00104                                 TQT_DBusDataMap<TQ_UINT8>(valueType));
00105                             break;
00106                         case TQT_DBusData::Int16:
00107                             result << TQT_DBusData::fromInt16KeyMap(
00108                                 TQT_DBusDataMap<TQ_INT16>(valueType));
00109                             break;
00110                         case TQT_DBusData::UInt16:
00111                             result << TQT_DBusData::fromUInt16KeyMap(
00112                                 TQT_DBusDataMap<TQ_UINT16>(valueType));
00113                             break;
00114                         case TQT_DBusData::Int32:
00115                             result << TQT_DBusData::fromInt32KeyMap(
00116                                 TQT_DBusDataMap<TQ_INT32>(valueType));
00117                             break;
00118                         case TQT_DBusData::UInt32:
00119                             result << TQT_DBusData::fromUInt32KeyMap(
00120                                 TQT_DBusDataMap<TQ_UINT32>(valueType));
00121                             break;
00122                         case TQT_DBusData::Int64:
00123                             result << TQT_DBusData::fromInt64KeyMap(
00124                                 TQT_DBusDataMap<TQ_INT64>(valueType));
00125                             break;
00126                         case TQT_DBusData::UInt64:
00127                             result << TQT_DBusData::fromUInt64KeyMap(
00128                                 TQT_DBusDataMap<TQ_UINT64>(valueType));
00129                             break;
00130                         case TQT_DBusData::String:
00131                             result << TQT_DBusData::fromStringKeyMap(
00132                                 TQT_DBusDataMap<TQString>(valueType));
00133                             break;
00134                         case TQT_DBusData::ObjectPath:
00135                             result << TQT_DBusData::fromObjectPathKeyMap(
00136                                 TQT_DBusDataMap<TQT_DBusObjectPath>(valueType));
00137                             break;
00138                         case TQT_DBusData::UnixFd:
00139                             result << TQT_DBusData::fromUnixFdKeyMap(
00140                                 TQT_DBusDataMap<TQT_DBusUnixFd>(valueType));
00141                             break;
00142                         default:
00143                             tqWarning("TQT_DBusMarshall: unsupported map key type %s "
00144                                      "at de-marshalling",
00145                                      TQT_DBusData::typeName(keyType));
00146                             break;
00147                     }
00148                     signature = signature.mid(3);
00149                 }
00150                 else
00151                 {
00152                     signature = signature.mid(2);
00153                     TQValueList<TQT_DBusData> valueContainer =
00154                         parseSignature(signature);
00155                     Q_ASSERT(valueContainer.count() == 1);
00156 
00157                     switch (keyType)
00158                     {
00159                         case TQT_DBusData::Byte:
00160                             result << TQT_DBusData::fromByteKeyMap(
00161                                 TQT_DBusDataMap<TQ_UINT8>(valueContainer[0]));
00162                             break;
00163                         case TQT_DBusData::Int16:
00164                             result << TQT_DBusData::fromInt16KeyMap(
00165                                 TQT_DBusDataMap<TQ_INT16>(valueContainer[0]));
00166                             break;
00167                         case TQT_DBusData::UInt16:
00168                             result << TQT_DBusData::fromUInt16KeyMap(
00169                                 TQT_DBusDataMap<TQ_UINT16>(valueContainer[0]));
00170                             break;
00171                         case TQT_DBusData::Int32:
00172                             result << TQT_DBusData::fromInt32KeyMap(
00173                                 TQT_DBusDataMap<TQ_INT32>(valueContainer[0]));
00174                             break;
00175                         case TQT_DBusData::UInt32:
00176                             result << TQT_DBusData::fromUInt32KeyMap(
00177                                 TQT_DBusDataMap<TQ_UINT32>(valueContainer[0]));
00178                             break;
00179                         case TQT_DBusData::Int64:
00180                             result << TQT_DBusData::fromInt64KeyMap(
00181                                 TQT_DBusDataMap<TQ_INT64>(valueContainer[0]));
00182                             break;
00183                         case TQT_DBusData::UInt64:
00184                             result << TQT_DBusData::fromUInt64KeyMap(
00185                                 TQT_DBusDataMap<TQ_UINT64>(valueContainer[0]));
00186                             break;
00187                         case TQT_DBusData::String:
00188                             result << TQT_DBusData::fromStringKeyMap(
00189                                 TQT_DBusDataMap<TQString>(valueContainer[0]));
00190                             break;
00191                         case TQT_DBusData::ObjectPath:
00192                             result << TQT_DBusData::fromObjectPathKeyMap(
00193                                 TQT_DBusDataMap<TQT_DBusObjectPath>(valueContainer[0]));
00194                             break;
00195                         case TQT_DBusData::UnixFd:
00196                             result << TQT_DBusData::fromUnixFdKeyMap(
00197                                 TQT_DBusDataMap<TQT_DBusUnixFd>(valueContainer[0]));
00198                             break;
00199                         default:
00200                             tqWarning("TQT_DBusMarshall: unsupported map key type %s "
00201                                      "at de-marshalling",
00202                                      TQT_DBusData::typeName(keyType));
00203                             break;
00204                     }
00205                 }
00206                 Q_ASSERT(!signature.isEmpty() && signature[0] == '}');
00207                 signature = signature.mid(1);
00208                 break;
00209             }
00210             case '}': return result;
00211             case 'a': {
00212                 TQT_DBusData::Type elementType =
00213                     qSingleTypeForDBusSignature(signature[1]);
00214                 if (elementType != TQT_DBusData::Invalid)
00215                 {
00216                     TQT_DBusDataList list(elementType);
00217                     result << TQT_DBusData::fromList(list);
00218                     signature = signature.mid(2);
00219                 }
00220                 else
00221                 {
00222                     signature = signature.mid(1);
00223                     bool array = signature[0] != '{';
00224 
00225                     TQValueList<TQT_DBusData> elementContainer =
00226                         parseSignature(signature);
00227                     Q_ASSERT(elementContainer.count() == 1);
00228 
00229                     if (array)
00230                     {
00231                         TQT_DBusDataList list(elementContainer[0]);
00232                         result << TQT_DBusData::fromList(list);
00233                     }
00234                     else
00235                         result << elementContainer[0];
00236                 }
00237                 break;
00238             }
00239             default:
00240                 TQT_DBusData::Type elementType =
00241                     qSingleTypeForDBusSignature(signature[0]);
00242                 if (elementType != TQT_DBusData::Invalid)
00243                 {
00244                     switch (elementType)
00245                     {
00246                         case TQT_DBusData::Bool:
00247                             result << TQT_DBusData::fromBool(
00248                                 (0));
00249                             break;
00250                         case TQT_DBusData::Byte:
00251                             result << TQT_DBusData::fromByte(
00252                                 (0));
00253                             break;
00254                         case TQT_DBusData::Int16:
00255                             result << TQT_DBusData::fromInt16(
00256                                 (0));
00257                             break;
00258                         case TQT_DBusData::UInt16:
00259                             result << TQT_DBusData::fromUInt16(
00260                                 (0));
00261                             break;
00262                         case TQT_DBusData::Int32:
00263                             result << TQT_DBusData::fromInt32(
00264                                 (0));
00265                             break;
00266                         case TQT_DBusData::UInt32:
00267                             result << TQT_DBusData::fromUInt32(
00268                                 (0));
00269                             break;
00270                         case TQT_DBusData::Int64:
00271                             result << TQT_DBusData::fromInt64(
00272                                 (0));
00273                             break;
00274                         case TQT_DBusData::UInt64:
00275                             result << TQT_DBusData::fromUInt64(
00276                                 (0));
00277                             break;
00278                         case TQT_DBusData::String:
00279                             result << TQT_DBusData::fromString(
00280                                 (TQString()));
00281                             break;
00282                         case TQT_DBusData::ObjectPath:
00283                             result << TQT_DBusData::fromObjectPath(
00284                                 (TQT_DBusObjectPath()));
00285                             break;
00286                         case TQT_DBusData::UnixFd:
00287                             result << TQT_DBusData::fromUnixFd(
00288                                 (TQT_DBusUnixFd()));
00289                             break;
00290                         default:
00291                             result << TQT_DBusData();
00292                             tqWarning("TQT_DBusMarshall: unsupported element type %s "
00293                                      "at de-marshalling",
00294                                      TQT_DBusData::typeName(elementType));
00295                             break;
00296                     }
00297                     signature = signature.mid(1);
00298                 }
00299                 else {
00300                     result << TQT_DBusData();
00301                     signature = signature.mid(1);
00302                 }
00303                 break;
00304         }
00305     }
00306 
00307     return result;
00308 }
00309 
00310 static TQT_DBusData qFetchParameter(DBusMessageIter *it);
00311 
00312 void qFetchByteKeyMapEntry(TQT_DBusDataMap<TQ_UINT8>& map, DBusMessageIter* it)
00313 {
00314     DBusMessageIter itemIter;
00315     dbus_message_iter_recurse(it, &itemIter);
00316     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00317 
00318     TQ_UINT8 key = qFetchParameter(&itemIter).toByte();
00319 
00320     dbus_message_iter_next(&itemIter);
00321 
00322     map.insert(key, qFetchParameter(&itemIter));
00323 }
00324 
00325 void qFetchInt16KeyMapEntry(TQT_DBusDataMap<TQ_INT16>& map, DBusMessageIter* it)
00326 {
00327     DBusMessageIter itemIter;
00328     dbus_message_iter_recurse(it, &itemIter);
00329     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00330 
00331     TQ_INT16 key = qFetchParameter(&itemIter).toInt16();
00332 
00333     dbus_message_iter_next(&itemIter);
00334 
00335     map.insert(key, qFetchParameter(&itemIter));
00336 }
00337 
00338 void qFetchUInt16KeyMapEntry(TQT_DBusDataMap<TQ_UINT16>& map, DBusMessageIter* it)
00339 {
00340     DBusMessageIter itemIter;
00341     dbus_message_iter_recurse(it, &itemIter);
00342     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00343 
00344     TQ_UINT16 key = qFetchParameter(&itemIter).toUInt16();
00345 
00346     dbus_message_iter_next(&itemIter);
00347 
00348     map.insert(key, qFetchParameter(&itemIter));
00349 }
00350 
00351 void qFetchInt32KeyMapEntry(TQT_DBusDataMap<TQ_INT32>& map, DBusMessageIter* it)
00352 {
00353     DBusMessageIter itemIter;
00354     dbus_message_iter_recurse(it, &itemIter);
00355     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00356 
00357     TQ_INT32 key = qFetchParameter(&itemIter).toInt32();
00358 
00359     dbus_message_iter_next(&itemIter);
00360 
00361     map.insert(key, qFetchParameter(&itemIter));
00362 }
00363 
00364 void qFetchUInt32KeyMapEntry(TQT_DBusDataMap<TQ_UINT32>& map, DBusMessageIter* it)
00365 {
00366     DBusMessageIter itemIter;
00367     dbus_message_iter_recurse(it, &itemIter);
00368     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00369 
00370     TQ_UINT32 key = qFetchParameter(&itemIter).toUInt32();
00371 
00372     dbus_message_iter_next(&itemIter);
00373 
00374     map.insert(key, qFetchParameter(&itemIter));
00375 }
00376 
00377 void qFetchInt64KeyMapEntry(TQT_DBusDataMap<TQ_INT64>& map, DBusMessageIter* it)
00378 {
00379     DBusMessageIter itemIter;
00380     dbus_message_iter_recurse(it, &itemIter);
00381     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00382 
00383     TQ_INT64 key = qFetchParameter(&itemIter).toInt64();
00384 
00385     dbus_message_iter_next(&itemIter);
00386 
00387     map.insert(key, qFetchParameter(&itemIter));
00388 }
00389 
00390 void qFetchUInt64KeyMapEntry(TQT_DBusDataMap<TQ_UINT64>& map, DBusMessageIter* it)
00391 {
00392     DBusMessageIter itemIter;
00393     dbus_message_iter_recurse(it, &itemIter);
00394     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00395 
00396     TQ_UINT64 key = qFetchParameter(&itemIter).toUInt64();
00397 
00398     dbus_message_iter_next(&itemIter);
00399 
00400     map.insert(key, qFetchParameter(&itemIter));
00401 }
00402 
00403 void qFetchObjectPathKeyMapEntry(TQT_DBusDataMap<TQT_DBusObjectPath>& map, DBusMessageIter* it)
00404 {
00405     DBusMessageIter itemIter;
00406     dbus_message_iter_recurse(it, &itemIter);
00407     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00408 
00409     TQT_DBusObjectPath key = qFetchParameter(&itemIter).toObjectPath();
00410 
00411     dbus_message_iter_next(&itemIter);
00412 
00413     map.insert(key, qFetchParameter(&itemIter));
00414 }
00415 
00416 void qFetchStringKeyMapEntry(TQT_DBusDataMap<TQString>& map, DBusMessageIter* it)
00417 {
00418     DBusMessageIter itemIter;
00419     dbus_message_iter_recurse(it, &itemIter);
00420     Q_ASSERT(dbus_message_iter_has_next(&itemIter));
00421 
00422     TQString key = qFetchParameter(&itemIter).toString();
00423 
00424     dbus_message_iter_next(&itemIter);
00425 
00426     map.insert(key, qFetchParameter(&itemIter));
00427 }
00428 
00429 static TQT_DBusData qFetchMap(DBusMessageIter *it, const TQT_DBusData& prototype)
00430 {
00431     if (dbus_message_iter_get_arg_type(it) == DBUS_TYPE_INVALID)
00432         return prototype;
00433 
00434     DBusMessageIter itemIter;
00435     dbus_message_iter_recurse(it, &itemIter);
00436     if (dbus_message_iter_get_arg_type(&itemIter) == DBUS_TYPE_INVALID)
00437         return prototype;
00438 
00439     switch (dbus_message_iter_get_arg_type(&itemIter)) {
00440         case DBUS_TYPE_BYTE: {
00441             TQT_DBusDataMap<TQ_UINT8> map = prototype.toByteKeyMap();
00442             do {
00443                 qFetchByteKeyMapEntry(map, it);
00444             } while (dbus_message_iter_next(it));
00445 
00446             return TQT_DBusData::fromByteKeyMap(map);
00447         }
00448 
00449         case DBUS_TYPE_INT16: {
00450             TQT_DBusDataMap<TQ_INT16> map = prototype.toInt16KeyMap();
00451             do {
00452                 qFetchInt16KeyMapEntry(map, it);
00453             } while (dbus_message_iter_next(it));
00454 
00455             return TQT_DBusData::fromInt16KeyMap(map);
00456         }
00457 
00458         case DBUS_TYPE_UINT16: {
00459             TQT_DBusDataMap<TQ_UINT16> map = prototype.toUInt16KeyMap();
00460             do {
00461                 qFetchUInt16KeyMapEntry(map, it);
00462             } while (dbus_message_iter_next(it));
00463 
00464             return TQT_DBusData::fromUInt16KeyMap(map);
00465         }
00466 
00467         case DBUS_TYPE_INT32: {
00468             TQT_DBusDataMap<TQ_INT32> map = prototype.toInt32KeyMap();
00469             do {
00470                 qFetchInt32KeyMapEntry(map, it);
00471             } while (dbus_message_iter_next(it));
00472 
00473             return TQT_DBusData::fromInt32KeyMap(map);
00474         }
00475 
00476         case DBUS_TYPE_UINT32: {
00477             TQT_DBusDataMap<TQ_UINT32> map = prototype.toUInt32KeyMap();
00478             do {
00479                 qFetchUInt32KeyMapEntry(map, it);
00480             } while (dbus_message_iter_next(it));
00481 
00482             return TQT_DBusData::fromUInt32KeyMap(map);
00483         }
00484 
00485         case DBUS_TYPE_INT64: {
00486             TQT_DBusDataMap<TQ_INT64> map = prototype.toInt64KeyMap();
00487             do {
00488                 qFetchInt64KeyMapEntry(map, it);
00489             } while (dbus_message_iter_next(it));
00490 
00491             return TQT_DBusData::fromInt64KeyMap(map);
00492         }
00493 
00494         case DBUS_TYPE_UINT64: {
00495             TQT_DBusDataMap<TQ_UINT64> map = prototype.toUInt64KeyMap();
00496             do {
00497                 qFetchUInt64KeyMapEntry(map, it);
00498             } while (dbus_message_iter_next(it));
00499 
00500             return TQT_DBusData::fromUInt64KeyMap(map);
00501         }
00502 
00503         case DBUS_TYPE_OBJECT_PATH:  {
00504             TQT_DBusDataMap<TQT_DBusObjectPath> map = prototype.toObjectPathKeyMap();
00505             do {
00506               qFetchObjectPathKeyMapEntry(map, it);
00507             } while (dbus_message_iter_next(it));
00508 
00509             return TQT_DBusData::fromObjectPathKeyMap(map);
00510         }
00511         case DBUS_TYPE_STRING:      // fall through
00512         case DBUS_TYPE_SIGNATURE: {
00513             TQT_DBusDataMap<TQString> map = prototype.toStringKeyMap();
00514             do {
00515                 qFetchStringKeyMapEntry(map, it);
00516             } while (dbus_message_iter_next(it));
00517 
00518             return TQT_DBusData::fromStringKeyMap(map);
00519         }
00520 
00521         default:
00522             break;
00523     }
00524 
00525     return prototype;
00526 }
00527 
00528 static TQT_DBusData qFetchParameter(DBusMessageIter *it)
00529 {
00530     switch (dbus_message_iter_get_arg_type(it)) {
00531     case DBUS_TYPE_BOOLEAN:
00532         return TQT_DBusData::fromBool(qIterGet<dbus_bool_t>(it));
00533     case DBUS_TYPE_BYTE:
00534         return TQT_DBusData::fromByte(qIterGet<unsigned char>(it));
00535     case DBUS_TYPE_INT16:
00536        return TQT_DBusData::fromInt16(qIterGet<dbus_int16_t>(it));
00537     case DBUS_TYPE_UINT16:
00538         return TQT_DBusData::fromUInt16(qIterGet<dbus_uint16_t>(it));
00539     case DBUS_TYPE_INT32:
00540         return TQT_DBusData::fromInt32(qIterGet<dbus_int32_t>(it));
00541     case DBUS_TYPE_UINT32:
00542         return TQT_DBusData::fromUInt32(qIterGet<dbus_uint32_t>(it));
00543     case DBUS_TYPE_INT64:
00544         return TQT_DBusData::fromInt64(qIterGet<dbus_int64_t>(it));
00545     case DBUS_TYPE_UINT64:
00546         return TQT_DBusData::fromUInt64(qIterGet<dbus_uint64_t>(it));
00547     case DBUS_TYPE_DOUBLE:
00548         return TQT_DBusData::fromDouble(qIterGet<double>(it));
00549     case DBUS_TYPE_STRING:
00550     case DBUS_TYPE_SIGNATURE:
00551         return TQT_DBusData::fromString(TQString::fromUtf8(qIterGet<char *>(it)));
00552     case DBUS_TYPE_OBJECT_PATH:
00553         return TQT_DBusData::fromObjectPath(TQT_DBusObjectPath(qIterGet<char *>(it)));
00554     case DBUS_TYPE_ARRAY: {
00555         int arrayType = dbus_message_iter_get_element_type(it);
00556 
00557         char* sig = dbus_message_iter_get_signature(it);
00558         TQCString signature = sig;
00559         dbus_free(sig);
00560 
00561         TQValueList<TQT_DBusData> prototypeList = parseSignature(signature);
00562 
00563         if (arrayType == DBUS_TYPE_DICT_ENTRY) {
00564             DBusMessageIter sub;
00565             dbus_message_iter_recurse(it, &sub);
00566 
00567             return qFetchMap(&sub, prototypeList[0]);
00568         } else {
00569             TQT_DBusDataList list = prototypeList[0].toList();
00570 
00571             DBusMessageIter arrayIt;
00572             dbus_message_iter_recurse(it, &arrayIt);
00573 
00574             while (dbus_message_iter_get_arg_type(&arrayIt) != DBUS_TYPE_INVALID) {
00575                 list << qFetchParameter(&arrayIt);
00576 
00577                 dbus_message_iter_next(&arrayIt);
00578             }
00579 
00580             return TQT_DBusData::fromList(list);
00581         }
00582     }
00583     case DBUS_TYPE_VARIANT: {
00584         TQT_DBusVariant dvariant;
00585         DBusMessageIter sub;
00586         dbus_message_iter_recurse(it, &sub);
00587 
00588         char* signature = dbus_message_iter_get_signature(&sub);
00589         dvariant.signature = TQString::fromUtf8(signature);
00590         dbus_free(signature);
00591 
00592         dvariant.value = qFetchParameter(&sub);
00593 
00594         return TQT_DBusData::fromVariant(dvariant);
00595     }
00596     case DBUS_TYPE_STRUCT: {
00597         TQValueList<TQT_DBusData> memberList;
00598 
00599         DBusMessageIter subIt;
00600         dbus_message_iter_recurse(it, &subIt);
00601 
00602         uint index = 0;
00603         while (dbus_message_iter_get_arg_type(&subIt) != DBUS_TYPE_INVALID) {
00604             memberList << qFetchParameter(&subIt);
00605 
00606             dbus_message_iter_next(&subIt);
00607             ++index;
00608         }
00609 
00610         return TQT_DBusData::fromStruct(memberList);
00611     }
00612     case DBUS_TYPE_UNIX_FD: {
00613         TQT_DBusUnixFd unixFd;
00614         unixFd.giveFileDescriptor(qIterGet<dbus_uint32_t>(it));
00615         return TQT_DBusData::fromUnixFd(unixFd);
00616     }
00617 #if 0
00618     case DBUS_TYPE_INVALID:
00619         // TODO: check if there is better way to detect empty arrays
00620         return TQT_DBusData();
00621         break;
00622 #endif
00623     default:
00624         tqWarning("TQT_DBusMarshall: Don't know how to de-marshall type %d '%c'",
00625                  dbus_message_iter_get_arg_type(it),
00626                  dbus_message_iter_get_arg_type(it));
00627         return TQT_DBusData();
00628         break;
00629     }
00630 }
00631 
00632 void TQT_DBusMarshall::messageToList(TQValueList<TQT_DBusData>& list, DBusMessage* message)
00633 {
00634     Q_ASSERT(message);
00635 
00636     DBusMessageIter it;
00637     if (!dbus_message_iter_init(message, &it)) return;
00638 
00639     do
00640     {
00641         list << qFetchParameter(&it);
00642     }
00643     while (dbus_message_iter_next(&it));
00644 }
00645 
00646 static void tqAppendToMessage(DBusMessageIter *it, const TQString &str)
00647 {
00648     TQByteArray ba = str.utf8();
00649     const char *cdata = ba.data();
00650     dbus_message_iter_append_basic(it, DBUS_TYPE_STRING, &cdata);
00651 }
00652 
00653 static void tqAppendToMessage(DBusMessageIter *it, const TQT_DBusObjectPath &path)
00654 {
00655     const char *cdata = path.data();
00656     dbus_message_iter_append_basic(it, DBUS_TYPE_OBJECT_PATH, &cdata);
00657 }
00658 
00659 static void tqAppendToMessage(DBusMessageIter *it, const TQT_DBusUnixFd &unixFd)
00660 {
00661     const dbus_int32_t cdata = unixFd.fileDescriptor();
00662     dbus_message_iter_append_basic(it, DBUS_TYPE_UNIX_FD, &cdata);
00663 }
00664 
00665 static const char* qDBusTypeForTQT_DBusType(TQT_DBusData::Type type)
00666 {
00667     switch (type)
00668     {
00669         case TQT_DBusData::Invalid:
00670             return 0;
00671 
00672         case TQT_DBusData::Bool:
00673             return DBUS_TYPE_BOOLEAN_AS_STRING;
00674 
00675         case TQT_DBusData::Byte:
00676             return DBUS_TYPE_BYTE_AS_STRING;
00677 
00678         case TQT_DBusData::Int16:
00679             return DBUS_TYPE_INT16_AS_STRING;
00680 
00681         case TQT_DBusData::UInt16:
00682             return DBUS_TYPE_UINT16_AS_STRING;
00683 
00684         case TQT_DBusData::Int32:
00685             return DBUS_TYPE_INT32_AS_STRING;
00686 
00687         case TQT_DBusData::UInt32:
00688             return DBUS_TYPE_UINT32_AS_STRING;
00689 
00690         case TQT_DBusData::Int64:
00691             return DBUS_TYPE_INT64_AS_STRING;
00692 
00693         case TQT_DBusData::UInt64:
00694             return DBUS_TYPE_UINT64_AS_STRING;
00695 
00696         case TQT_DBusData::Double:
00697             return DBUS_TYPE_DOUBLE_AS_STRING;
00698 
00699         case TQT_DBusData::String:
00700             return DBUS_TYPE_STRING_AS_STRING;
00701 
00702         case TQT_DBusData::ObjectPath:
00703             return DBUS_TYPE_OBJECT_PATH_AS_STRING;
00704 
00705         case TQT_DBusData::List:
00706             return DBUS_TYPE_ARRAY_AS_STRING;
00707 
00708         case TQT_DBusData::Struct:
00709             return DBUS_TYPE_STRUCT_AS_STRING;
00710 
00711         case TQT_DBusData::Variant:
00712             return DBUS_TYPE_VARIANT_AS_STRING;
00713 
00714         case TQT_DBusData::Map:
00715             return DBUS_TYPE_DICT_ENTRY_AS_STRING;
00716 
00717         case TQT_DBusData::UnixFd:
00718             return DBUS_TYPE_UNIX_FD_AS_STRING;
00719     }
00720     return 0;
00721 }
00722 
00723 static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var);
00724 
00725 static void qDBusByteKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00726 {
00727     DBusMessageIter sub;
00728     TQCString sig;
00729 
00730     TQT_DBusDataMap<TQ_UINT8> map = var.toByteKeyMap();
00731 
00732     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00733     sig += qDBusTypeForTQT_DBusType(map.keyType());
00734 
00735     if (map.hasContainerValueType())
00736         sig += map.containerValueType().buildDBusSignature();
00737     else
00738         sig += qDBusTypeForTQT_DBusType(map.valueType());
00739     sig += DBUS_DICT_ENTRY_END_CHAR;
00740 
00741     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00742 
00743     TQT_DBusDataMap<TQ_UINT8>::const_iterator mit = map.begin();
00744     for (; mit != map.end(); ++mit)
00745     {
00746         DBusMessageIter itemIterator;
00747         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00748                                          0, &itemIterator);
00749 
00750         dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &(mit.key()));
00751         qDBusDataToIterator(&itemIterator, mit.data());
00752 
00753         dbus_message_iter_close_container(&sub, &itemIterator);
00754     }
00755 
00756     dbus_message_iter_close_container(it, &sub);
00757 }
00758 
00759 static void qDBusInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00760 {
00761     DBusMessageIter sub;
00762     TQCString sig;
00763 
00764     TQT_DBusDataMap<TQ_INT16> map = var.toInt16KeyMap();
00765 
00766     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00767     sig += qDBusTypeForTQT_DBusType(map.keyType());
00768 
00769     if (map.hasContainerValueType())
00770         sig += map.containerValueType().buildDBusSignature();
00771     else
00772         sig += qDBusTypeForTQT_DBusType(map.valueType());
00773     sig += DBUS_DICT_ENTRY_END_CHAR;
00774 
00775     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00776 
00777     TQT_DBusDataMap<TQ_INT16>::const_iterator mit = map.begin();
00778     for (; mit != map.end(); ++mit)
00779     {
00780         DBusMessageIter itemIterator;
00781         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00782                                          0, &itemIterator);
00783 
00784         dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &(mit.key()));
00785         qDBusDataToIterator(&itemIterator, mit.data());
00786 
00787         dbus_message_iter_close_container(&sub, &itemIterator);
00788     }
00789 
00790     dbus_message_iter_close_container(it, &sub);
00791 }
00792 
00793 static void qDBusUInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00794 {
00795     DBusMessageIter sub;
00796     TQCString sig;
00797 
00798     TQT_DBusDataMap<TQ_UINT16> map = var.toUInt16KeyMap();
00799 
00800     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00801     sig += qDBusTypeForTQT_DBusType(map.keyType());
00802 
00803     if (map.hasContainerValueType())
00804         sig += map.containerValueType().buildDBusSignature();
00805     else
00806         sig += qDBusTypeForTQT_DBusType(map.valueType());
00807     sig += DBUS_DICT_ENTRY_END_CHAR;
00808 
00809     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00810 
00811     TQT_DBusDataMap<TQ_UINT16>::const_iterator mit = map.begin();
00812     for (; mit != map.end(); ++mit)
00813     {
00814         DBusMessageIter itemIterator;
00815         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00816                                          0, &itemIterator);
00817 
00818         dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &(mit.key()));
00819         qDBusDataToIterator(&itemIterator, mit.data());
00820 
00821         dbus_message_iter_close_container(&sub, &itemIterator);
00822     }
00823 
00824     dbus_message_iter_close_container(it, &sub);
00825 }
00826 
00827 static void qDBusInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00828 {
00829     DBusMessageIter sub;
00830     TQCString sig;
00831 
00832     TQT_DBusDataMap<TQ_INT32> map = var.toInt32KeyMap();
00833 
00834     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00835     sig += qDBusTypeForTQT_DBusType(map.keyType());
00836 
00837     if (map.hasContainerValueType())
00838         sig += map.containerValueType().buildDBusSignature();
00839     else
00840         sig += qDBusTypeForTQT_DBusType(map.valueType());
00841     sig += DBUS_DICT_ENTRY_END_CHAR;
00842 
00843     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00844 
00845     TQT_DBusDataMap<TQ_INT32>::const_iterator mit = map.begin();
00846     for (; mit != map.end(); ++mit)
00847     {
00848         DBusMessageIter itemIterator;
00849         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00850                                          0, &itemIterator);
00851 
00852         dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &(mit.key()));
00853         qDBusDataToIterator(&itemIterator, mit.data());
00854 
00855         dbus_message_iter_close_container(&sub, &itemIterator);
00856     }
00857 
00858     dbus_message_iter_close_container(it, &sub);
00859 }
00860 
00861 static void qDBusUInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00862 {
00863     DBusMessageIter sub;
00864     TQCString sig;
00865 
00866     TQT_DBusDataMap<TQ_UINT32> map = var.toUInt32KeyMap();
00867 
00868     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00869     sig += qDBusTypeForTQT_DBusType(map.keyType());
00870 
00871     if (map.hasContainerValueType())
00872         sig += map.containerValueType().buildDBusSignature();
00873     else
00874         sig += qDBusTypeForTQT_DBusType(map.valueType());
00875     sig += DBUS_DICT_ENTRY_END_CHAR;
00876 
00877     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00878 
00879     TQT_DBusDataMap<TQ_UINT32>::const_iterator mit = map.begin();
00880     for (; mit != map.end(); ++mit)
00881     {
00882         DBusMessageIter itemIterator;
00883         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00884                                          0, &itemIterator);
00885 
00886         dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &(mit.key()));
00887         qDBusDataToIterator(&itemIterator, mit.data());
00888 
00889         dbus_message_iter_close_container(&sub, &itemIterator);
00890     }
00891 
00892     dbus_message_iter_close_container(it, &sub);
00893 }
00894 
00895 static void qDBusInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00896 {
00897     DBusMessageIter sub;
00898     TQCString sig;
00899 
00900     TQT_DBusDataMap<TQ_INT64> map = var.toInt64KeyMap();
00901 
00902     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00903     sig += qDBusTypeForTQT_DBusType(map.keyType());
00904 
00905     if (map.hasContainerValueType())
00906         sig += map.containerValueType().buildDBusSignature();
00907     else
00908         sig += qDBusTypeForTQT_DBusType(map.valueType());
00909     sig += DBUS_DICT_ENTRY_END_CHAR;
00910 
00911     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00912 
00913     TQT_DBusDataMap<TQ_INT64>::const_iterator mit = map.begin();
00914     for (; mit != map.end(); ++mit)
00915     {
00916         DBusMessageIter itemIterator;
00917         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00918                                          0, &itemIterator);
00919 
00920         dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &(mit.key()));
00921         qDBusDataToIterator(&itemIterator, mit.data());
00922 
00923         dbus_message_iter_close_container(&sub, &itemIterator);
00924     }
00925 
00926     dbus_message_iter_close_container(it, &sub);
00927 }
00928 
00929 static void qDBusUInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00930 {
00931     DBusMessageIter sub;
00932     TQCString sig;
00933 
00934     TQT_DBusDataMap<TQ_UINT64> map = var.toUInt64KeyMap();
00935 
00936     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00937     sig += qDBusTypeForTQT_DBusType(map.keyType());
00938 
00939     if (map.hasContainerValueType())
00940         sig += map.containerValueType().buildDBusSignature();
00941     else
00942         sig += qDBusTypeForTQT_DBusType(map.valueType());
00943     sig += DBUS_DICT_ENTRY_END_CHAR;
00944 
00945     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00946 
00947     TQT_DBusDataMap<TQ_UINT64>::const_iterator mit = map.begin();
00948     for (; mit != map.end(); ++mit)
00949     {
00950         DBusMessageIter itemIterator;
00951         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00952                                          0, &itemIterator);
00953 
00954         dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &(mit.key()));
00955         qDBusDataToIterator(&itemIterator, mit.data());
00956 
00957         dbus_message_iter_close_container(&sub, &itemIterator);
00958     }
00959 
00960     dbus_message_iter_close_container(it, &sub);
00961 }
00962 
00963 static void qDBusStringKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
00964 {
00965     DBusMessageIter sub;
00966     TQCString sig;
00967 
00968     TQT_DBusDataMap<TQString> map = var.toStringKeyMap();
00969 
00970     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
00971     sig += qDBusTypeForTQT_DBusType(map.keyType());
00972 
00973     if (map.hasContainerValueType())
00974         sig += map.containerValueType().buildDBusSignature();
00975     else
00976         sig += qDBusTypeForTQT_DBusType(map.valueType());
00977     sig += DBUS_DICT_ENTRY_END_CHAR;
00978 
00979     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
00980 
00981     TQT_DBusDataMap<TQString>::const_iterator mit = map.begin();
00982     for (; mit != map.end(); ++mit)
00983     {
00984         DBusMessageIter itemIterator;
00985         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
00986                                          0, &itemIterator);
00987 
00988         tqAppendToMessage(&itemIterator, mit.key());
00989         qDBusDataToIterator(&itemIterator, mit.data());
00990 
00991         dbus_message_iter_close_container(&sub, &itemIterator);
00992     }
00993 
00994     dbus_message_iter_close_container(it, &sub);
00995 }
00996 
00997 static void qDBusObjectPathKeyMapToIterator(DBusMessageIter* it,
00998                                             const TQT_DBusData& var)
00999 {
01000     DBusMessageIter sub;
01001     TQCString sig;
01002 
01003     TQT_DBusDataMap<TQT_DBusObjectPath> map = var.toObjectPathKeyMap();
01004 
01005     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
01006     sig += qDBusTypeForTQT_DBusType(map.keyType());
01007 
01008     if (map.hasContainerValueType())
01009         sig += map.containerValueType().buildDBusSignature();
01010     else
01011         sig += qDBusTypeForTQT_DBusType(map.valueType());
01012     sig += DBUS_DICT_ENTRY_END_CHAR;
01013 
01014     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
01015 
01016     TQT_DBusDataMap<TQT_DBusObjectPath>::const_iterator mit = map.begin();
01017     for (; mit != map.end(); ++mit)
01018     {
01019         DBusMessageIter itemIterator;
01020         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
01021                                          0, &itemIterator);
01022 
01023         tqAppendToMessage(&itemIterator, mit.key());
01024         qDBusDataToIterator(&itemIterator, mit.data());
01025 
01026         dbus_message_iter_close_container(&sub, &itemIterator);
01027     }
01028 
01029     dbus_message_iter_close_container(it, &sub);
01030 }
01031 
01032 static void qDBusUnixFdKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
01033 {
01034     DBusMessageIter sub;
01035     TQCString sig;
01036 
01037     TQT_DBusDataMap<TQT_DBusUnixFd> map = var.toUnixFdKeyMap();
01038 
01039     sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
01040     sig += qDBusTypeForTQT_DBusType(map.keyType());
01041 
01042     if (map.hasContainerValueType())
01043         sig += map.containerValueType().buildDBusSignature();
01044     else
01045         sig += qDBusTypeForTQT_DBusType(map.valueType());
01046     sig += DBUS_DICT_ENTRY_END_CHAR;
01047 
01048     dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
01049 
01050     TQT_DBusDataMap<TQT_DBusUnixFd>::const_iterator mit = map.begin();
01051     for (; mit != map.end(); ++mit)
01052     {
01053         DBusMessageIter itemIterator;
01054         dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
01055                                          0, &itemIterator);
01056 
01057         dbus_message_iter_append_basic(it, DBUS_TYPE_UNIX_FD, &(mit.key()));
01058         qDBusDataToIterator(&itemIterator, mit.data());
01059 
01060         dbus_message_iter_close_container(&sub, &itemIterator);
01061     }
01062 
01063     dbus_message_iter_close_container(it, &sub);
01064 }
01065 
01066 static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var)
01067 {
01068     switch (var.type())
01069     {
01070         case TQT_DBusData::Bool:
01071         {
01072             dbus_bool_t value = var.toBool();
01073             dbus_message_iter_append_basic(it, DBUS_TYPE_BOOLEAN, &value);
01074             break;
01075         }
01076         case TQT_DBusData::Byte:
01077         {
01078             TQ_UINT8 value = var.toByte();
01079             dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &value);
01080             break;
01081         }
01082         case TQT_DBusData::Int16: {
01083             TQ_INT16 value = var.toInt16();
01084             dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &value);
01085             break;
01086         }
01087         case TQT_DBusData::UInt16: {
01088             TQ_UINT16 value = var.toUInt16();
01089             dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &value);
01090             break;
01091         }
01092         case TQT_DBusData::Int32: {
01093             TQ_INT32 value = var.toInt32();
01094             dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &value);
01095             break;
01096         }
01097         case TQT_DBusData::UInt32: {
01098             TQ_UINT32 value = var.toUInt32();
01099             dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &value);
01100             break;
01101         }
01102         case TQT_DBusData::Int64: {
01103             TQ_INT64 value = var.toInt64();
01104             dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &value);
01105             break;
01106         }
01107         case TQT_DBusData::UInt64: {
01108             TQ_UINT64 value = var.toUInt64();
01109             dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &value);
01110             break;
01111         }
01112         case TQT_DBusData::Double: {
01113             double value = var.toDouble();
01114             dbus_message_iter_append_basic(it, DBUS_TYPE_DOUBLE, &value);
01115             break;
01116         }
01117         case TQT_DBusData::String:
01118             tqAppendToMessage(it, var.toString());
01119             break;
01120         case TQT_DBusData::ObjectPath:
01121             tqAppendToMessage(it, var.toObjectPath());
01122             break;
01123         case TQT_DBusData::UnixFd: {
01124             tqAppendToMessage(it, var.toUnixFd());
01125             break;
01126         }
01127         case TQT_DBusData::List: {
01128             TQT_DBusDataList list = var.toList();
01129 
01130             TQCString signature = 0;
01131             if (list.hasContainerItemType())
01132                 signature = list.containerItemType().buildDBusSignature();
01133             else
01134                 signature = qDBusTypeForTQT_DBusType(list.type());
01135 
01136             DBusMessageIter sub;
01137             dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
01138                                              signature.data(), &sub);
01139 
01140             const TQValueList<TQT_DBusData> valueList = var.toTQValueList();
01141             TQValueList<TQT_DBusData>::const_iterator listIt    = valueList.begin();
01142             TQValueList<TQT_DBusData>::const_iterator listEndIt = valueList.end();
01143             for (; listIt != listEndIt; ++listIt)
01144             {
01145                 qDBusDataToIterator(&sub, *listIt);
01146             }
01147             dbus_message_iter_close_container(it, &sub);
01148             break;
01149         }
01150         case TQT_DBusData::Map: {
01151             switch (var.keyType()) {
01152                 case TQT_DBusData::Byte:
01153                     qDBusByteKeyMapToIterator(it, var);
01154                     break;
01155                 case TQT_DBusData::Int16:
01156                     qDBusInt16KeyMapToIterator(it, var);
01157                     break;
01158                 case TQT_DBusData::UInt16:
01159                     qDBusUInt16KeyMapToIterator(it, var);
01160                     break;
01161                 case TQT_DBusData::Int32:
01162                     qDBusInt32KeyMapToIterator(it, var);
01163                     break;
01164                 case TQT_DBusData::UInt32:
01165                     qDBusUInt32KeyMapToIterator(it, var);
01166                     break;
01167                 case TQT_DBusData::Int64:
01168                     qDBusInt64KeyMapToIterator(it, var);
01169                     break;
01170                 case TQT_DBusData::UInt64:
01171                     qDBusUInt64KeyMapToIterator(it, var);
01172                     break;
01173                 case TQT_DBusData::String:
01174                     qDBusStringKeyMapToIterator(it, var);
01175                     break;
01176                 case TQT_DBusData::ObjectPath:
01177                     qDBusObjectPathKeyMapToIterator(it, var);
01178                     break;
01179                 case TQT_DBusData::UnixFd:
01180                     qDBusUnixFdKeyMapToIterator(it, var);
01181                     break;
01182                 default:
01183                     tqWarning("TQT_DBusMarshall: unhandled map key type %s "
01184                              "at marshalling",
01185                              TQT_DBusData::typeName(var.keyType()));
01186                     break;
01187             }
01188             break;
01189         }
01190         case TQT_DBusData::Variant: {
01191             TQT_DBusVariant variant = var.toVariant();
01192             if (variant.signature.isEmpty() || !variant.value.isValid()) break;
01193 
01194             DBusMessageIter sub;
01195             dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT,
01196                                              variant.signature.utf8(), &sub);
01197 
01198             qDBusDataToIterator(&sub, variant.value);
01199 
01200             dbus_message_iter_close_container(it, &sub);
01201             break;
01202         }
01203         case TQT_DBusData::Struct: {
01204             TQValueList<TQT_DBusData> memberList = var.toStruct();
01205             if (memberList.isEmpty()) break;
01206 
01207             DBusMessageIter sub;
01208             dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub);
01209 
01210             TQValueList<TQT_DBusData>::const_iterator memberIt    = memberList.begin();
01211             TQValueList<TQT_DBusData>::const_iterator memberEndIt = memberList.end();
01212             for (; memberIt != memberEndIt; ++memberIt)
01213             {
01214                 qDBusDataToIterator(&sub, *memberIt);
01215             }
01216 
01217             dbus_message_iter_close_container(it, &sub);
01218         }
01219 #if 0
01220         case TQVariant::ByteArray: {
01221             const TQByteArray array = var.toByteArray();
01222             const char* cdata = array.data();
01223                 DBusMessageIter sub;
01224                 dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub);
01225             dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.size());
01226                 dbus_message_iter_close_container(it, &sub);
01227         break;
01228         }
01229 #endif
01230         default:
01231             //tqWarning("Don't know how to handle type %s", var.typeName());
01232             break;
01233     }
01234 }
01235 
01236 void qListToIterator(DBusMessageIter* it, const TQValueList<TQT_DBusData>& list)
01237 {
01238     if (list.isEmpty()) return;
01239 
01240     TQValueList<TQT_DBusData>::const_iterator listIt    = list.begin();
01241     TQValueList<TQT_DBusData>::const_iterator listEndIt = list.end();
01242     for (; listIt != listEndIt; ++listIt)
01243     {
01244         qDBusDataToIterator(it, *listIt);
01245     }
01246 }
01247 
01248 void TQT_DBusMarshall::listToMessage(const TQValueList<TQT_DBusData> &list, DBusMessage *msg)
01249 {
01250     Q_ASSERT(msg);
01251     DBusMessageIter it;
01252     dbus_message_iter_init_append(msg, &it);
01253     qListToIterator(&it, list);
01254 }