DBus-1-TQt  1.0
tqdbusmarshall.cpp
Go to the documentation of this file.
1 /* qdbusmarshall.cpp
2  *
3  * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org>
4  * Copyright (C) 2007 Kevin Krammer <kevin.krammer@gmx.at>
5  *
6  * Licensed under the Academic Free License version 2.1
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
21  * USA.
22  *
23  */
24 
25 #include "tqdbusmarshall.h"
26 #include "tqdbusdata.h"
27 #include "tqdbusdatalist.h"
28 #include "tqdbusdatamap.h"
29 #include "tqdbusobjectpath.h"
30 #include "tqdbusunixfd.h"
31 #include "tqdbusvariant.h"
32 
33 #include <tqvariant.h>
34 #include <tqvaluelist.h>
35 #include <tqmap.h>
36 #include <tqstringlist.h>
37 #include <tqvaluevector.h>
38 
39 #include <dbus/dbus.h>
40 
41 template <typename T>
42 inline T qIterGet(DBusMessageIter *it)
43 {
44  T t;
45  dbus_message_iter_get_basic(it, &t);
46  return t;
47 }
48 
50 {
51  switch (signature)
52  {
53  case 'b': return TQT_DBusData::Bool;
54  case 'y': return TQT_DBusData::Byte;
55  case 'n': return TQT_DBusData::Int16;
56  case 'q': return TQT_DBusData::UInt16;
57  case 'i': return TQT_DBusData::Int32;
58  case 'u': return TQT_DBusData::UInt32;
59  case 'x': return TQT_DBusData::Int64;
60  case 't': return TQT_DBusData::UInt64;
61  case 'd': return TQT_DBusData::Double;
62  case 's': return TQT_DBusData::String;
63  case 'o': return TQT_DBusData::ObjectPath;
64  case 'g': return TQT_DBusData::String;
65  case 'v': return TQT_DBusData::Variant;
66  case 'h': return TQT_DBusData::UnixFd;
67 
68  default:
69  break;
70  }
71 
72  return TQT_DBusData::Invalid;
73 }
74 
75 static TQValueList<TQT_DBusData> parseSignature(TQCString& signature)
76 {
77 // tqDebug("parseSignature(%s)", signature.data());
79 
80  while (!signature.isEmpty())
81  {
82  switch (signature[0])
83  {
84  case '(': {
85  signature = signature.mid(1);
86  TQValueList<TQT_DBusData> memberList = parseSignature(signature);
87  result << TQT_DBusData::fromStruct(memberList);
88  Q_ASSERT(!signature.isEmpty() && signature[0] == ')');
89  signature = signature.mid(1);
90  break;
91  }
92  case ')': return result;
93  case '{': {
94  TQT_DBusData::Type keyType =
95  qSingleTypeForDBusSignature(signature[1]);
96  TQT_DBusData::Type valueType =
97  qSingleTypeForDBusSignature(signature[2]);
98  if (valueType != TQT_DBusData::Invalid)
99  {
100  switch (keyType)
101  {
102  case TQT_DBusData::Byte:
104  TQT_DBusDataMap<TQ_UINT8>(valueType));
105  break;
106  case TQT_DBusData::Int16:
108  TQT_DBusDataMap<TQ_INT16>(valueType));
109  break;
112  TQT_DBusDataMap<TQ_UINT16>(valueType));
113  break;
114  case TQT_DBusData::Int32:
116  TQT_DBusDataMap<TQ_INT32>(valueType));
117  break;
120  TQT_DBusDataMap<TQ_UINT32>(valueType));
121  break;
122  case TQT_DBusData::Int64:
124  TQT_DBusDataMap<TQ_INT64>(valueType));
125  break;
128  TQT_DBusDataMap<TQ_UINT64>(valueType));
129  break;
132  TQT_DBusDataMap<TQString>(valueType));
133  break;
137  break;
141  break;
142  default:
143  tqWarning("TQT_DBusMarshall: unsupported map key type %s "
144  "at de-marshalling",
145  TQT_DBusData::typeName(keyType));
146  break;
147  }
148  signature = signature.mid(3);
149  }
150  else
151  {
152  signature = signature.mid(2);
153  TQValueList<TQT_DBusData> valueContainer =
154  parseSignature(signature);
155  Q_ASSERT(valueContainer.count() == 1);
156 
157  switch (keyType)
158  {
159  case TQT_DBusData::Byte:
161  TQT_DBusDataMap<TQ_UINT8>(valueContainer[0]));
162  break;
163  case TQT_DBusData::Int16:
165  TQT_DBusDataMap<TQ_INT16>(valueContainer[0]));
166  break;
169  TQT_DBusDataMap<TQ_UINT16>(valueContainer[0]));
170  break;
171  case TQT_DBusData::Int32:
173  TQT_DBusDataMap<TQ_INT32>(valueContainer[0]));
174  break;
177  TQT_DBusDataMap<TQ_UINT32>(valueContainer[0]));
178  break;
179  case TQT_DBusData::Int64:
181  TQT_DBusDataMap<TQ_INT64>(valueContainer[0]));
182  break;
185  TQT_DBusDataMap<TQ_UINT64>(valueContainer[0]));
186  break;
189  TQT_DBusDataMap<TQString>(valueContainer[0]));
190  break;
193  TQT_DBusDataMap<TQT_DBusObjectPath>(valueContainer[0]));
194  break;
197  TQT_DBusDataMap<TQT_DBusUnixFd>(valueContainer[0]));
198  break;
199  default:
200  tqWarning("TQT_DBusMarshall: unsupported map key type %s "
201  "at de-marshalling",
202  TQT_DBusData::typeName(keyType));
203  break;
204  }
205  }
206  Q_ASSERT(!signature.isEmpty() && signature[0] == '}');
207  signature = signature.mid(1);
208  break;
209  }
210  case '}': return result;
211  case 'a': {
212  TQT_DBusData::Type elementType =
213  qSingleTypeForDBusSignature(signature[1]);
214  if (elementType != TQT_DBusData::Invalid)
215  {
216  TQT_DBusDataList list(elementType);
217  result << TQT_DBusData::fromList(list);
218  signature = signature.mid(2);
219  }
220  else
221  {
222  signature = signature.mid(1);
223  bool array = signature[0] != '{';
224 
225  TQValueList<TQT_DBusData> elementContainer =
226  parseSignature(signature);
227  Q_ASSERT(elementContainer.count() == 1);
228 
229  if (array)
230  {
231  TQT_DBusDataList list(elementContainer[0]);
232  result << TQT_DBusData::fromList(list);
233  }
234  else
235  result << elementContainer[0];
236  }
237  break;
238  }
239  default:
240  TQT_DBusData::Type elementType =
241  qSingleTypeForDBusSignature(signature[0]);
242  if (elementType != TQT_DBusData::Invalid)
243  {
244  switch (elementType)
245  {
246  case TQT_DBusData::Bool:
247  result << TQT_DBusData::fromBool(
248  (0));
249  break;
250  case TQT_DBusData::Byte:
251  result << TQT_DBusData::fromByte(
252  (0));
253  break;
254  case TQT_DBusData::Int16:
255  result << TQT_DBusData::fromInt16(
256  (0));
257  break;
259  result << TQT_DBusData::fromUInt16(
260  (0));
261  break;
262  case TQT_DBusData::Int32:
263  result << TQT_DBusData::fromInt32(
264  (0));
265  break;
267  result << TQT_DBusData::fromUInt32(
268  (0));
269  break;
270  case TQT_DBusData::Int64:
271  result << TQT_DBusData::fromInt64(
272  (0));
273  break;
275  result << TQT_DBusData::fromUInt64(
276  (0));
277  break;
279  result << TQT_DBusData::fromString(
280  (TQString()));
281  break;
284  (TQT_DBusObjectPath()));
285  break;
287  result << TQT_DBusData::fromUnixFd(
288  (TQT_DBusUnixFd()));
289  break;
290  default:
291  result << TQT_DBusData();
292  tqWarning("TQT_DBusMarshall: unsupported element type %s "
293  "at de-marshalling",
294  TQT_DBusData::typeName(elementType));
295  break;
296  }
297  signature = signature.mid(1);
298  }
299  else {
300  result << TQT_DBusData();
301  signature = signature.mid(1);
302  }
303  break;
304  }
305  }
306 
307  return result;
308 }
309 
310 static TQT_DBusData qFetchParameter(DBusMessageIter *it);
311 
312 void qFetchByteKeyMapEntry(TQT_DBusDataMap<TQ_UINT8>& map, DBusMessageIter* it)
313 {
314  DBusMessageIter itemIter;
315  dbus_message_iter_recurse(it, &itemIter);
316  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
317 
318  TQ_UINT8 key = qFetchParameter(&itemIter).toByte();
319 
320  dbus_message_iter_next(&itemIter);
321 
322  map.insert(key, qFetchParameter(&itemIter));
323 }
324 
325 void qFetchInt16KeyMapEntry(TQT_DBusDataMap<TQ_INT16>& map, DBusMessageIter* it)
326 {
327  DBusMessageIter itemIter;
328  dbus_message_iter_recurse(it, &itemIter);
329  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
330 
331  TQ_INT16 key = qFetchParameter(&itemIter).toInt16();
332 
333  dbus_message_iter_next(&itemIter);
334 
335  map.insert(key, qFetchParameter(&itemIter));
336 }
337 
339 {
340  DBusMessageIter itemIter;
341  dbus_message_iter_recurse(it, &itemIter);
342  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
343 
344  TQ_UINT16 key = qFetchParameter(&itemIter).toUInt16();
345 
346  dbus_message_iter_next(&itemIter);
347 
348  map.insert(key, qFetchParameter(&itemIter));
349 }
350 
351 void qFetchInt32KeyMapEntry(TQT_DBusDataMap<TQ_INT32>& map, DBusMessageIter* it)
352 {
353  DBusMessageIter itemIter;
354  dbus_message_iter_recurse(it, &itemIter);
355  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
356 
357  TQ_INT32 key = qFetchParameter(&itemIter).toInt32();
358 
359  dbus_message_iter_next(&itemIter);
360 
361  map.insert(key, qFetchParameter(&itemIter));
362 }
363 
365 {
366  DBusMessageIter itemIter;
367  dbus_message_iter_recurse(it, &itemIter);
368  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
369 
370  TQ_UINT32 key = qFetchParameter(&itemIter).toUInt32();
371 
372  dbus_message_iter_next(&itemIter);
373 
374  map.insert(key, qFetchParameter(&itemIter));
375 }
376 
377 void qFetchInt64KeyMapEntry(TQT_DBusDataMap<TQ_INT64>& map, DBusMessageIter* it)
378 {
379  DBusMessageIter itemIter;
380  dbus_message_iter_recurse(it, &itemIter);
381  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
382 
383  TQ_INT64 key = qFetchParameter(&itemIter).toInt64();
384 
385  dbus_message_iter_next(&itemIter);
386 
387  map.insert(key, qFetchParameter(&itemIter));
388 }
389 
391 {
392  DBusMessageIter itemIter;
393  dbus_message_iter_recurse(it, &itemIter);
394  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
395 
396  TQ_UINT64 key = qFetchParameter(&itemIter).toUInt64();
397 
398  dbus_message_iter_next(&itemIter);
399 
400  map.insert(key, qFetchParameter(&itemIter));
401 }
402 
404 {
405  DBusMessageIter itemIter;
406  dbus_message_iter_recurse(it, &itemIter);
407  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
408 
410 
411  dbus_message_iter_next(&itemIter);
412 
413  map.insert(key, qFetchParameter(&itemIter));
414 }
415 
416 void qFetchStringKeyMapEntry(TQT_DBusDataMap<TQString>& map, DBusMessageIter* it)
417 {
418  DBusMessageIter itemIter;
419  dbus_message_iter_recurse(it, &itemIter);
420  Q_ASSERT(dbus_message_iter_has_next(&itemIter));
421 
422  TQString key = qFetchParameter(&itemIter).toString();
423 
424  dbus_message_iter_next(&itemIter);
425 
426  map.insert(key, qFetchParameter(&itemIter));
427 }
428 
429 static TQT_DBusData qFetchMap(DBusMessageIter *it, const TQT_DBusData& prototype)
430 {
431  if (dbus_message_iter_get_arg_type(it) == DBUS_TYPE_INVALID)
432  return prototype;
433 
434  DBusMessageIter itemIter;
435  dbus_message_iter_recurse(it, &itemIter);
436  if (dbus_message_iter_get_arg_type(&itemIter) == DBUS_TYPE_INVALID)
437  return prototype;
438 
439  switch (dbus_message_iter_get_arg_type(&itemIter)) {
440  case DBUS_TYPE_BYTE: {
441  TQT_DBusDataMap<TQ_UINT8> map = prototype.toByteKeyMap();
442  do {
443  qFetchByteKeyMapEntry(map, it);
444  } while (dbus_message_iter_next(it));
445 
446  return TQT_DBusData::fromByteKeyMap(map);
447  }
448 
449  case DBUS_TYPE_INT16: {
450  TQT_DBusDataMap<TQ_INT16> map = prototype.toInt16KeyMap();
451  do {
452  qFetchInt16KeyMapEntry(map, it);
453  } while (dbus_message_iter_next(it));
454 
455  return TQT_DBusData::fromInt16KeyMap(map);
456  }
457 
458  case DBUS_TYPE_UINT16: {
459  TQT_DBusDataMap<TQ_UINT16> map = prototype.toUInt16KeyMap();
460  do {
461  qFetchUInt16KeyMapEntry(map, it);
462  } while (dbus_message_iter_next(it));
463 
464  return TQT_DBusData::fromUInt16KeyMap(map);
465  }
466 
467  case DBUS_TYPE_INT32: {
468  TQT_DBusDataMap<TQ_INT32> map = prototype.toInt32KeyMap();
469  do {
470  qFetchInt32KeyMapEntry(map, it);
471  } while (dbus_message_iter_next(it));
472 
473  return TQT_DBusData::fromInt32KeyMap(map);
474  }
475 
476  case DBUS_TYPE_UINT32: {
477  TQT_DBusDataMap<TQ_UINT32> map = prototype.toUInt32KeyMap();
478  do {
479  qFetchUInt32KeyMapEntry(map, it);
480  } while (dbus_message_iter_next(it));
481 
482  return TQT_DBusData::fromUInt32KeyMap(map);
483  }
484 
485  case DBUS_TYPE_INT64: {
486  TQT_DBusDataMap<TQ_INT64> map = prototype.toInt64KeyMap();
487  do {
488  qFetchInt64KeyMapEntry(map, it);
489  } while (dbus_message_iter_next(it));
490 
491  return TQT_DBusData::fromInt64KeyMap(map);
492  }
493 
494  case DBUS_TYPE_UINT64: {
495  TQT_DBusDataMap<TQ_UINT64> map = prototype.toUInt64KeyMap();
496  do {
497  qFetchUInt64KeyMapEntry(map, it);
498  } while (dbus_message_iter_next(it));
499 
500  return TQT_DBusData::fromUInt64KeyMap(map);
501  }
502 
503  case DBUS_TYPE_OBJECT_PATH: {
505  do {
507  } while (dbus_message_iter_next(it));
508 
510  }
511  case DBUS_TYPE_STRING: // fall through
512  case DBUS_TYPE_SIGNATURE: {
513  TQT_DBusDataMap<TQString> map = prototype.toStringKeyMap();
514  do {
515  qFetchStringKeyMapEntry(map, it);
516  } while (dbus_message_iter_next(it));
517 
518  return TQT_DBusData::fromStringKeyMap(map);
519  }
520 
521  default:
522  break;
523  }
524 
525  return prototype;
526 }
527 
528 static TQT_DBusData qFetchParameter(DBusMessageIter *it)
529 {
530  switch (dbus_message_iter_get_arg_type(it)) {
531  case DBUS_TYPE_BOOLEAN:
532  return TQT_DBusData::fromBool(qIterGet<dbus_bool_t>(it));
533  case DBUS_TYPE_BYTE:
534  return TQT_DBusData::fromByte(qIterGet<unsigned char>(it));
535  case DBUS_TYPE_INT16:
536  return TQT_DBusData::fromInt16(qIterGet<dbus_int16_t>(it));
537  case DBUS_TYPE_UINT16:
538  return TQT_DBusData::fromUInt16(qIterGet<dbus_uint16_t>(it));
539  case DBUS_TYPE_INT32:
540  return TQT_DBusData::fromInt32(qIterGet<dbus_int32_t>(it));
541  case DBUS_TYPE_UINT32:
542  return TQT_DBusData::fromUInt32(qIterGet<dbus_uint32_t>(it));
543  case DBUS_TYPE_INT64:
544  return TQT_DBusData::fromInt64(qIterGet<dbus_int64_t>(it));
545  case DBUS_TYPE_UINT64:
546  return TQT_DBusData::fromUInt64(qIterGet<dbus_uint64_t>(it));
547  case DBUS_TYPE_DOUBLE:
548  return TQT_DBusData::fromDouble(qIterGet<double>(it));
549  case DBUS_TYPE_STRING:
550  case DBUS_TYPE_SIGNATURE:
551  return TQT_DBusData::fromString(TQString::fromUtf8(qIterGet<char *>(it)));
552  case DBUS_TYPE_OBJECT_PATH:
553  return TQT_DBusData::fromObjectPath(TQT_DBusObjectPath(qIterGet<char *>(it)));
554  case DBUS_TYPE_ARRAY: {
555  int arrayType = dbus_message_iter_get_element_type(it);
556 
557  char* sig = dbus_message_iter_get_signature(it);
558  TQCString signature = sig;
559  dbus_free(sig);
560 
561  TQValueList<TQT_DBusData> prototypeList = parseSignature(signature);
562 
563  if (arrayType == DBUS_TYPE_DICT_ENTRY) {
564  DBusMessageIter sub;
565  dbus_message_iter_recurse(it, &sub);
566 
567  return qFetchMap(&sub, prototypeList[0]);
568  } else {
569  TQT_DBusDataList list = prototypeList[0].toList();
570 
571  DBusMessageIter arrayIt;
572  dbus_message_iter_recurse(it, &arrayIt);
573 
574  while (dbus_message_iter_get_arg_type(&arrayIt) != DBUS_TYPE_INVALID) {
575  list << qFetchParameter(&arrayIt);
576 
577  dbus_message_iter_next(&arrayIt);
578  }
579 
580  return TQT_DBusData::fromList(list);
581  }
582  }
583  case DBUS_TYPE_VARIANT: {
584  TQT_DBusVariant dvariant;
585  DBusMessageIter sub;
586  dbus_message_iter_recurse(it, &sub);
587 
588  char* signature = dbus_message_iter_get_signature(&sub);
589  dvariant.signature = TQString::fromUtf8(signature);
590  dbus_free(signature);
591 
592  dvariant.value = qFetchParameter(&sub);
593 
594  return TQT_DBusData::fromVariant(dvariant);
595  }
596  case DBUS_TYPE_STRUCT: {
597  TQValueList<TQT_DBusData> memberList;
598 
599  DBusMessageIter subIt;
600  dbus_message_iter_recurse(it, &subIt);
601 
602  uint index = 0;
603  while (dbus_message_iter_get_arg_type(&subIt) != DBUS_TYPE_INVALID) {
604  memberList << qFetchParameter(&subIt);
605 
606  dbus_message_iter_next(&subIt);
607  ++index;
608  }
609 
610  return TQT_DBusData::fromStruct(memberList);
611  }
612  case DBUS_TYPE_UNIX_FD: {
613  TQT_DBusUnixFd unixFd;
614  unixFd.giveFileDescriptor(qIterGet<dbus_uint32_t>(it));
615  return TQT_DBusData::fromUnixFd(unixFd);
616  }
617 #if 0
618  case DBUS_TYPE_INVALID:
619  // TODO: check if there is better way to detect empty arrays
620  return TQT_DBusData();
621  break;
622 #endif
623  default:
624  tqWarning("TQT_DBusMarshall: Don't know how to de-marshall type %d '%c'",
625  dbus_message_iter_get_arg_type(it),
626  dbus_message_iter_get_arg_type(it));
627  return TQT_DBusData();
628  break;
629  }
630 }
631 
633 {
634  Q_ASSERT(message);
635 
636  DBusMessageIter it;
637  if (!dbus_message_iter_init(message, &it)) return;
638 
639  do
640  {
641  list << qFetchParameter(&it);
642  }
643  while (dbus_message_iter_next(&it));
644 }
645 
646 static void tqAppendToMessage(DBusMessageIter *it, const TQString &str)
647 {
648  TQByteArray ba = str.utf8();
649  const char *cdata = ba.data();
650  dbus_message_iter_append_basic(it, DBUS_TYPE_STRING, &cdata);
651 }
652 
653 static void tqAppendToMessage(DBusMessageIter *it, const TQT_DBusObjectPath &path)
654 {
655  const char *cdata = path.ascii();
656  dbus_message_iter_append_basic(it, DBUS_TYPE_OBJECT_PATH, &cdata);
657 }
658 
659 static void tqAppendToMessage(DBusMessageIter *it, const TQT_DBusUnixFd &unixFd)
660 {
661  const dbus_int32_t cdata = unixFd.fileDescriptor();
662  dbus_message_iter_append_basic(it, DBUS_TYPE_UNIX_FD, &cdata);
663 }
664 
666 {
667  switch (type)
668  {
670  return 0;
671 
672  case TQT_DBusData::Bool:
673  return DBUS_TYPE_BOOLEAN_AS_STRING;
674 
675  case TQT_DBusData::Byte:
676  return DBUS_TYPE_BYTE_AS_STRING;
677 
678  case TQT_DBusData::Int16:
679  return DBUS_TYPE_INT16_AS_STRING;
680 
682  return DBUS_TYPE_UINT16_AS_STRING;
683 
684  case TQT_DBusData::Int32:
685  return DBUS_TYPE_INT32_AS_STRING;
686 
688  return DBUS_TYPE_UINT32_AS_STRING;
689 
690  case TQT_DBusData::Int64:
691  return DBUS_TYPE_INT64_AS_STRING;
692 
694  return DBUS_TYPE_UINT64_AS_STRING;
695 
697  return DBUS_TYPE_DOUBLE_AS_STRING;
698 
700  return DBUS_TYPE_STRING_AS_STRING;
701 
703  return DBUS_TYPE_OBJECT_PATH_AS_STRING;
704 
705  case TQT_DBusData::List:
706  return DBUS_TYPE_ARRAY_AS_STRING;
707 
709  return DBUS_TYPE_STRUCT_AS_STRING;
710 
712  return DBUS_TYPE_VARIANT_AS_STRING;
713 
714  case TQT_DBusData::Map:
715  return DBUS_TYPE_DICT_ENTRY_AS_STRING;
716 
719  }
720  return 0;
721 }
722 
723 static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var);
724 
725 static void qDBusByteKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
726 {
727  DBusMessageIter sub;
728  TQCString sig;
729 
731 
732  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
733  sig += qDBusTypeForTQT_DBusType(map.keyType());
734 
735  if (map.hasContainerValueType())
736  sig += map.containerValueType().buildDBusSignature();
737  else
738  sig += qDBusTypeForTQT_DBusType(map.valueType());
739  sig += DBUS_DICT_ENTRY_END_CHAR;
740 
741  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
742 
744  for (; mit != map.end(); ++mit)
745  {
746  DBusMessageIter itemIterator;
747  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
748  0, &itemIterator);
749 
750  dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &(mit.key()));
751  qDBusDataToIterator(&itemIterator, mit.data());
752 
753  dbus_message_iter_close_container(&sub, &itemIterator);
754  }
755 
756  dbus_message_iter_close_container(it, &sub);
757 }
758 
759 static void qDBusInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
760 {
761  DBusMessageIter sub;
762  TQCString sig;
763 
765 
766  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
767  sig += qDBusTypeForTQT_DBusType(map.keyType());
768 
769  if (map.hasContainerValueType())
770  sig += map.containerValueType().buildDBusSignature();
771  else
772  sig += qDBusTypeForTQT_DBusType(map.valueType());
773  sig += DBUS_DICT_ENTRY_END_CHAR;
774 
775  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
776 
778  for (; mit != map.end(); ++mit)
779  {
780  DBusMessageIter itemIterator;
781  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
782  0, &itemIterator);
783 
784  dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &(mit.key()));
785  qDBusDataToIterator(&itemIterator, mit.data());
786 
787  dbus_message_iter_close_container(&sub, &itemIterator);
788  }
789 
790  dbus_message_iter_close_container(it, &sub);
791 }
792 
793 static void qDBusUInt16KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
794 {
795  DBusMessageIter sub;
796  TQCString sig;
797 
799 
800  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
801  sig += qDBusTypeForTQT_DBusType(map.keyType());
802 
803  if (map.hasContainerValueType())
804  sig += map.containerValueType().buildDBusSignature();
805  else
806  sig += qDBusTypeForTQT_DBusType(map.valueType());
807  sig += DBUS_DICT_ENTRY_END_CHAR;
808 
809  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
810 
812  for (; mit != map.end(); ++mit)
813  {
814  DBusMessageIter itemIterator;
815  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
816  0, &itemIterator);
817 
818  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &(mit.key()));
819  qDBusDataToIterator(&itemIterator, mit.data());
820 
821  dbus_message_iter_close_container(&sub, &itemIterator);
822  }
823 
824  dbus_message_iter_close_container(it, &sub);
825 }
826 
827 static void qDBusInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
828 {
829  DBusMessageIter sub;
830  TQCString sig;
831 
833 
834  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
835  sig += qDBusTypeForTQT_DBusType(map.keyType());
836 
837  if (map.hasContainerValueType())
838  sig += map.containerValueType().buildDBusSignature();
839  else
840  sig += qDBusTypeForTQT_DBusType(map.valueType());
841  sig += DBUS_DICT_ENTRY_END_CHAR;
842 
843  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
844 
846  for (; mit != map.end(); ++mit)
847  {
848  DBusMessageIter itemIterator;
849  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
850  0, &itemIterator);
851 
852  dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &(mit.key()));
853  qDBusDataToIterator(&itemIterator, mit.data());
854 
855  dbus_message_iter_close_container(&sub, &itemIterator);
856  }
857 
858  dbus_message_iter_close_container(it, &sub);
859 }
860 
861 static void qDBusUInt32KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
862 {
863  DBusMessageIter sub;
864  TQCString sig;
865 
867 
868  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
869  sig += qDBusTypeForTQT_DBusType(map.keyType());
870 
871  if (map.hasContainerValueType())
872  sig += map.containerValueType().buildDBusSignature();
873  else
874  sig += qDBusTypeForTQT_DBusType(map.valueType());
875  sig += DBUS_DICT_ENTRY_END_CHAR;
876 
877  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
878 
880  for (; mit != map.end(); ++mit)
881  {
882  DBusMessageIter itemIterator;
883  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
884  0, &itemIterator);
885 
886  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &(mit.key()));
887  qDBusDataToIterator(&itemIterator, mit.data());
888 
889  dbus_message_iter_close_container(&sub, &itemIterator);
890  }
891 
892  dbus_message_iter_close_container(it, &sub);
893 }
894 
895 static void qDBusInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
896 {
897  DBusMessageIter sub;
898  TQCString sig;
899 
901 
902  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
903  sig += qDBusTypeForTQT_DBusType(map.keyType());
904 
905  if (map.hasContainerValueType())
906  sig += map.containerValueType().buildDBusSignature();
907  else
908  sig += qDBusTypeForTQT_DBusType(map.valueType());
909  sig += DBUS_DICT_ENTRY_END_CHAR;
910 
911  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
912 
914  for (; mit != map.end(); ++mit)
915  {
916  DBusMessageIter itemIterator;
917  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
918  0, &itemIterator);
919 
920  dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &(mit.key()));
921  qDBusDataToIterator(&itemIterator, mit.data());
922 
923  dbus_message_iter_close_container(&sub, &itemIterator);
924  }
925 
926  dbus_message_iter_close_container(it, &sub);
927 }
928 
929 static void qDBusUInt64KeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
930 {
931  DBusMessageIter sub;
932  TQCString sig;
933 
935 
936  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
937  sig += qDBusTypeForTQT_DBusType(map.keyType());
938 
939  if (map.hasContainerValueType())
940  sig += map.containerValueType().buildDBusSignature();
941  else
942  sig += qDBusTypeForTQT_DBusType(map.valueType());
943  sig += DBUS_DICT_ENTRY_END_CHAR;
944 
945  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
946 
948  for (; mit != map.end(); ++mit)
949  {
950  DBusMessageIter itemIterator;
951  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
952  0, &itemIterator);
953 
954  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &(mit.key()));
955  qDBusDataToIterator(&itemIterator, mit.data());
956 
957  dbus_message_iter_close_container(&sub, &itemIterator);
958  }
959 
960  dbus_message_iter_close_container(it, &sub);
961 }
962 
963 static void qDBusStringKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
964 {
965  DBusMessageIter sub;
966  TQCString sig;
967 
969 
970  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
971  sig += qDBusTypeForTQT_DBusType(map.keyType());
972 
973  if (map.hasContainerValueType())
974  sig += map.containerValueType().buildDBusSignature();
975  else
976  sig += qDBusTypeForTQT_DBusType(map.valueType());
977  sig += DBUS_DICT_ENTRY_END_CHAR;
978 
979  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
980 
982  for (; mit != map.end(); ++mit)
983  {
984  DBusMessageIter itemIterator;
985  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
986  0, &itemIterator);
987 
988  tqAppendToMessage(&itemIterator, mit.key());
989  qDBusDataToIterator(&itemIterator, mit.data());
990 
991  dbus_message_iter_close_container(&sub, &itemIterator);
992  }
993 
994  dbus_message_iter_close_container(it, &sub);
995 }
996 
997 static void qDBusObjectPathKeyMapToIterator(DBusMessageIter* it,
998  const TQT_DBusData& var)
999 {
1000  DBusMessageIter sub;
1001  TQCString sig;
1002 
1004 
1005  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
1006  sig += qDBusTypeForTQT_DBusType(map.keyType());
1007 
1008  if (map.hasContainerValueType())
1009  sig += map.containerValueType().buildDBusSignature();
1010  else
1011  sig += qDBusTypeForTQT_DBusType(map.valueType());
1012  sig += DBUS_DICT_ENTRY_END_CHAR;
1013 
1014  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
1015 
1017  for (; mit != map.end(); ++mit)
1018  {
1019  DBusMessageIter itemIterator;
1020  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
1021  0, &itemIterator);
1022 
1023  tqAppendToMessage(&itemIterator, mit.key());
1024  qDBusDataToIterator(&itemIterator, mit.data());
1025 
1026  dbus_message_iter_close_container(&sub, &itemIterator);
1027  }
1028 
1029  dbus_message_iter_close_container(it, &sub);
1030 }
1031 
1032 static void qDBusUnixFdKeyMapToIterator(DBusMessageIter* it, const TQT_DBusData& var)
1033 {
1034  DBusMessageIter sub;
1035  TQCString sig;
1036 
1038 
1039  sig += DBUS_DICT_ENTRY_BEGIN_CHAR;
1040  sig += qDBusTypeForTQT_DBusType(map.keyType());
1041 
1042  if (map.hasContainerValueType())
1043  sig += map.containerValueType().buildDBusSignature();
1044  else
1045  sig += qDBusTypeForTQT_DBusType(map.valueType());
1046  sig += DBUS_DICT_ENTRY_END_CHAR;
1047 
1048  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, sig.data(), &sub);
1049 
1051  for (; mit != map.end(); ++mit)
1052  {
1053  DBusMessageIter itemIterator;
1054  dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY,
1055  0, &itemIterator);
1056 
1057  dbus_message_iter_append_basic(it, DBUS_TYPE_UNIX_FD, &(mit.key()));
1058  qDBusDataToIterator(&itemIterator, mit.data());
1059 
1060  dbus_message_iter_close_container(&sub, &itemIterator);
1061  }
1062 
1063  dbus_message_iter_close_container(it, &sub);
1064 }
1065 
1066 static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var)
1067 {
1068  switch (var.type())
1069  {
1070  case TQT_DBusData::Bool:
1071  {
1072  dbus_bool_t value = var.toBool();
1073  dbus_message_iter_append_basic(it, DBUS_TYPE_BOOLEAN, &value);
1074  break;
1075  }
1076  case TQT_DBusData::Byte:
1077  {
1078  TQ_UINT8 value = var.toByte();
1079  dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &value);
1080  break;
1081  }
1082  case TQT_DBusData::Int16: {
1083  TQ_INT16 value = var.toInt16();
1084  dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &value);
1085  break;
1086  }
1087  case TQT_DBusData::UInt16: {
1088  TQ_UINT16 value = var.toUInt16();
1089  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &value);
1090  break;
1091  }
1092  case TQT_DBusData::Int32: {
1093  TQ_INT32 value = var.toInt32();
1094  dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &value);
1095  break;
1096  }
1097  case TQT_DBusData::UInt32: {
1098  TQ_UINT32 value = var.toUInt32();
1099  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &value);
1100  break;
1101  }
1102  case TQT_DBusData::Int64: {
1103  TQ_INT64 value = var.toInt64();
1104  dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &value);
1105  break;
1106  }
1107  case TQT_DBusData::UInt64: {
1108  TQ_UINT64 value = var.toUInt64();
1109  dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &value);
1110  break;
1111  }
1112  case TQT_DBusData::Double: {
1113  double value = var.toDouble();
1114  dbus_message_iter_append_basic(it, DBUS_TYPE_DOUBLE, &value);
1115  break;
1116  }
1117  case TQT_DBusData::String:
1118  tqAppendToMessage(it, var.toString());
1119  break;
1121  tqAppendToMessage(it, var.toObjectPath());
1122  break;
1123  case TQT_DBusData::UnixFd: {
1124  tqAppendToMessage(it, var.toUnixFd());
1125  break;
1126  }
1127  case TQT_DBusData::List: {
1128  TQT_DBusDataList list = var.toList();
1129 
1130  TQCString signature = 0;
1131  if (list.hasContainerItemType())
1132  signature = list.containerItemType().buildDBusSignature();
1133  else
1134  signature = qDBusTypeForTQT_DBusType(list.type());
1135 
1136  DBusMessageIter sub;
1137  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY,
1138  signature.data(), &sub);
1139 
1140  const TQValueList<TQT_DBusData> valueList = var.toTQValueList();
1141  TQValueList<TQT_DBusData>::const_iterator listIt = valueList.begin();
1142  TQValueList<TQT_DBusData>::const_iterator listEndIt = valueList.end();
1143  for (; listIt != listEndIt; ++listIt)
1144  {
1145  qDBusDataToIterator(&sub, *listIt);
1146  }
1147  dbus_message_iter_close_container(it, &sub);
1148  break;
1149  }
1150  case TQT_DBusData::Map: {
1151  switch (var.keyType()) {
1152  case TQT_DBusData::Byte:
1153  qDBusByteKeyMapToIterator(it, var);
1154  break;
1155  case TQT_DBusData::Int16:
1156  qDBusInt16KeyMapToIterator(it, var);
1157  break;
1158  case TQT_DBusData::UInt16:
1159  qDBusUInt16KeyMapToIterator(it, var);
1160  break;
1161  case TQT_DBusData::Int32:
1162  qDBusInt32KeyMapToIterator(it, var);
1163  break;
1164  case TQT_DBusData::UInt32:
1165  qDBusUInt32KeyMapToIterator(it, var);
1166  break;
1167  case TQT_DBusData::Int64:
1168  qDBusInt64KeyMapToIterator(it, var);
1169  break;
1170  case TQT_DBusData::UInt64:
1171  qDBusUInt64KeyMapToIterator(it, var);
1172  break;
1173  case TQT_DBusData::String:
1174  qDBusStringKeyMapToIterator(it, var);
1175  break;
1178  break;
1179  case TQT_DBusData::UnixFd:
1180  qDBusUnixFdKeyMapToIterator(it, var);
1181  break;
1182  default:
1183  tqWarning("TQT_DBusMarshall: unhandled map key type %s "
1184  "at marshalling",
1186  break;
1187  }
1188  break;
1189  }
1190  case TQT_DBusData::Variant: {
1191  TQT_DBusVariant variant = var.toVariant();
1192  if (variant.signature.isEmpty() || !variant.value.isValid()) break;
1193 
1194  DBusMessageIter sub;
1195  dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT,
1196  variant.signature.utf8(), &sub);
1197 
1198  qDBusDataToIterator(&sub, variant.value);
1199 
1200  dbus_message_iter_close_container(it, &sub);
1201  break;
1202  }
1203  case TQT_DBusData::Struct: {
1204  TQValueList<TQT_DBusData> memberList = var.toStruct();
1205  if (memberList.isEmpty()) break;
1206 
1207  DBusMessageIter sub;
1208  dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub);
1209 
1210  TQValueList<TQT_DBusData>::const_iterator memberIt = memberList.begin();
1211  TQValueList<TQT_DBusData>::const_iterator memberEndIt = memberList.end();
1212  for (; memberIt != memberEndIt; ++memberIt)
1213  {
1214  qDBusDataToIterator(&sub, *memberIt);
1215  }
1216 
1217  dbus_message_iter_close_container(it, &sub);
1218  }
1219 #if 0
1220  case TQVariant::ByteArray: {
1221  const TQByteArray array = var.toByteArray();
1222  const char* cdata = array.data();
1223  DBusMessageIter sub;
1224  dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub);
1225  dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.size());
1226  dbus_message_iter_close_container(it, &sub);
1227  break;
1228  }
1229 #endif
1230  default:
1231  //tqWarning("Don't know how to handle type %s", var.typeName());
1232  break;
1233  }
1234 }
1235 
1236 void qListToIterator(DBusMessageIter* it, const TQValueList<TQT_DBusData>& list)
1237 {
1238  if (list.isEmpty()) return;
1239 
1240  TQValueList<TQT_DBusData>::const_iterator listIt = list.begin();
1241  TQValueList<TQT_DBusData>::const_iterator listEndIt = list.end();
1242  for (; listIt != listEndIt; ++listIt)
1243  {
1244  qDBusDataToIterator(it, *listIt);
1245  }
1246 }
1247 
1249 {
1250  Q_ASSERT(msg);
1251  DBusMessageIter it;
1252  dbus_message_iter_init_append(msg, &it);
1253  qListToIterator(&it, list);
1254 }
Type keyType() const
Returns the Type of the key type for maps.
Definition: tqdbusdata.cpp:322
bool insert(const T &key, const TQT_DBusData &data)
Inserts a given value for a given key.
bool hasContainerValueType() const
Checks whether the value type is a data container itself.
#define DBUS_TYPE_UNIX_FD
Definition: tqdbusunixfd.h:35
const char * typeName() const
Returns the string representation of the object&#39;s Type.
Definition: tqdbusdata.h:385
static void qDBusObjectPathKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchStringKeyMapEntry(TQT_DBusDataMap< TQString > &map, DBusMessageIter *it)
static TQT_DBusData fromInt64(TQ_INT64 value)
Creates a data object for the given signed 64-bit integer value.
Definition: tqdbusdata.cpp:493
TQT_DBusVariant toVariant(bool *ok=0) const
Tries to get the encapsulated variant value.
Definition: tqdbusdata.cpp:721
#define DBUS_TYPE_UNIX_FD_AS_STRING
Definition: tqdbusunixfd.h:39
static TQT_DBusData fromUInt64KeyMap(const TQT_DBusDataMap< TQ_UINT64 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:888
const_iterator end() const
Returns an iterator to an invalid position.
static const char * qDBusTypeForTQT_DBusType(TQT_DBusData::Type type)
void qFetchUInt32KeyMapEntry(TQT_DBusDataMap< TQ_UINT32 > &map, DBusMessageIter *it)
TQT_DBusData::Type keyType() const
Returns the key type of the map object.
Data type for representing a D-Bus variant.
Definition: tqdbusvariant.h:56
static TQValueList< TQT_DBusData > parseSignature(TQCString &signature)
void giveFileDescriptor(int fileDescriptor)
Give unix file handle.
static TQT_DBusData::Type qSingleTypeForDBusSignature(char signature)
void qFetchUInt64KeyMapEntry(TQT_DBusDataMap< TQ_UINT64 > &map, DBusMessageIter *it)
static TQT_DBusData fromObjectPath(const TQT_DBusObjectPath &value)
Creates a data object for the given object path value.
Definition: tqdbusdata.cpp:585
const_iterator begin() const
Returns an iterator to the first item according to the key sort order.
static TQT_DBusData qFetchMap(DBusMessageIter *it, const TQT_DBusData &prototype)
static TQT_DBusData fromString(const TQString &value)
Creates a data object for the given string value.
Definition: tqdbusdata.cpp:562
static TQT_DBusData fromByte(TQ_UINT8 value)
Creates a data object for the given byte (unsigned char) value.
Definition: tqdbusdata.cpp:378
TQ_UINT16 toUInt16(bool *ok=0) const
Tries to get the encapsulated unsigned 16-bit integer value.
Definition: tqdbusdata.cpp:434
TQT_DBusData containerItemType() const
Returns a container prototype for the list&#39;s element type.
static void messageToList(TQValueList< TQT_DBusData > &list, DBusMessage *message)
TQT_DBusObjectPath toObjectPath(bool *ok=0) const
Tries to get the encapsulated object path value.
Definition: tqdbusdata.cpp:598
TQT_DBusData::Type type() const
Returns the element type of the list object.
Class for representing D-Bus unix file handles.
Definition: tqdbusunixfd.h:51
bool toBool(bool *ok=0) const
Tries to get the encapsulated boolean value.
Definition: tqdbusdata.cpp:365
static TQT_DBusData fromInt64KeyMap(const TQT_DBusDataMap< TQ_INT64 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:864
TQT_DBusDataList toList(bool *ok=0) const
Tries to get the encapsulated list.
Definition: tqdbusdata.cpp:649
TQString signature
The D-Bus data signature of the data contained in value.
void qFetchObjectPathKeyMapEntry(TQT_DBusDataMap< TQT_DBusObjectPath > &map, DBusMessageIter *it)
Class to transport lists of D-Bus data types.
TQMapConstIterator< T, TQT_DBusData > const_iterator
Definition: tqdbusdatamap.h:82
void qFetchInt32KeyMapEntry(TQT_DBusDataMap< TQ_INT32 > &map, DBusMessageIter *it)
void qFetchInt16KeyMapEntry(TQT_DBusDataMap< TQ_INT16 > &map, DBusMessageIter *it)
bool hasContainerItemType() const
Checks whether the element type is a data container itself.
TQValueList< TQT_DBusData > toTQValueList(bool *ok=0) const
Tries to get the encapsulated list.
Definition: tqdbusdata.cpp:667
static void qDBusUnixFdKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static TQT_DBusData fromStruct(const TQValueList< TQT_DBusData > &memberList)
Creates a data object for the given struct&#39;s memberList.
Definition: tqdbusdata.cpp:681
TQValueList< TQT_DBusData > toStruct(bool *ok=0) const
Tries to get the encapsulated struct memberList.
Definition: tqdbusdata.cpp:698
void qFetchByteKeyMapEntry(TQT_DBusDataMap< TQ_UINT8 > &map, DBusMessageIter *it)
static void qDBusStringKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
bool isValid() const
Checks whether the data object contains a valid content.
Definition: tqdbusdata.h:349
static TQT_DBusData fromUInt64(TQ_UINT64 value)
Creates a data object for the given unsigned 64-bit integer value.
Definition: tqdbusdata.cpp:516
static TQT_DBusData fromInt16(TQ_INT16 value)
Creates a data object for the given signed 16-bit integer value.
Definition: tqdbusdata.cpp:401
Type type() const
Returns the Type of the data object.
Definition: tqdbusdata.cpp:317
TQ_INT32 toInt32(bool *ok=0) const
Tries to get the encapsulated signed 32-bit integer value.
Definition: tqdbusdata.cpp:457
static TQT_DBusData fromUnixFd(const TQT_DBusUnixFd &value)
Creates a data object for the given unix file handle value.
Definition: tqdbusdata.cpp:611
static void tqAppendToMessage(DBusMessageIter *it, const TQString &str)
TQ_INT64 toInt64(bool *ok=0) const
Tries to get the encapsulated signed 64-bit integer value.
Definition: tqdbusdata.cpp:503
static void qDBusUInt16KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static TQT_DBusData fromList(const TQT_DBusDataList &list)
Creates a data object for the given list.
Definition: tqdbusdata.cpp:637
TQT_DBusData::Type valueType() const
Returns the value type of the map object.
double toDouble(bool *ok=0) const
Tries to get the encapsulated double value.
Definition: tqdbusdata.cpp:549
static void qDBusUInt32KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
Class for accurately representing D-Bus data types.
Definition: tqdbusdata.h:58
static TQT_DBusData fromUInt16(TQ_UINT16 value)
Creates a data object for the given unsigned 16-bit integer value.
Definition: tqdbusdata.cpp:424
static TQT_DBusData fromDouble(double value)
Creates a data object for the given double value.
Definition: tqdbusdata.cpp:539
int fileDescriptor() const
Get unix file handle.
static void qDBusDataToIterator(DBusMessageIter *it, const TQT_DBusData &var)
Class for representing D-Bus object paths.
static void qDBusInt16KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchInt64KeyMapEntry(TQT_DBusDataMap< TQ_INT64 > &map, DBusMessageIter *it)
TQCString buildDBusSignature() const
Creates the data objects D-Bus signature.
static TQT_DBusData fromInt16KeyMap(const TQT_DBusDataMap< TQ_INT16 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:766
TQT_DBusUnixFd toUnixFd(bool *ok=0) const
Tries to get the encapsulated unix file handle value.
Definition: tqdbusdata.cpp:624
void qListToIterator(DBusMessageIter *it, const TQValueList< TQT_DBusData > &list)
static TQT_DBusData fromUInt16KeyMap(const TQT_DBusDataMap< TQ_UINT16 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:790
TQT_DBusDataMap< TQ_INT64 > toInt64KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:875
static TQT_DBusData fromBool(bool value)
Creates a data object for the given boolean value.
Definition: tqdbusdata.cpp:355
T qIterGet(DBusMessageIter *it)
TQ_UINT32 toUInt32(bool *ok=0) const
Tries to get the encapsulated unsigned 32-bit integer value.
Definition: tqdbusdata.cpp:480
TQT_DBusData value
The D-Bus data type to transport as a variant.
static TQT_DBusData fromUnixFdKeyMap(const TQT_DBusDataMap< TQT_DBusUnixFd > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:962
static TQT_DBusData fromInt32(TQ_INT32 value)
Creates a data object for the given signed 32-bit integer value.
Definition: tqdbusdata.cpp:447
TQ_UINT8 toByte(bool *ok=0) const
Tries to get the encapsulated byte (unsigned char) value.
Definition: tqdbusdata.cpp:388
TQT_DBusDataMap< TQ_UINT8 > toByteKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:753
static void qDBusInt32KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static void qDBusUInt64KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static TQT_DBusData fromStringKeyMap(const TQT_DBusDataMap< TQString > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:913
static TQT_DBusData qFetchParameter(DBusMessageIter *it)
TQT_DBusDataMap< TQString > toStringKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:924
TQT_DBusDataMap< TQ_INT32 > toInt32KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:826
TQT_DBusDataMap< TQ_INT16 > toInt16KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:777
TQString toString(bool *ok=0) const
Tries to get the encapsulated string value.
Definition: tqdbusdata.cpp:572
TQ_INT16 toInt16(bool *ok=0) const
Tries to get the encapsulated signed 16-bit integer value.
Definition: tqdbusdata.cpp:411
static TQT_DBusData fromUInt32(TQ_UINT32 value)
Creates a data object for the given unsigned 32-bit integer value.
Definition: tqdbusdata.cpp:470
static TQT_DBusData fromInt32KeyMap(const TQT_DBusDataMap< TQ_INT32 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:815
static TQT_DBusData fromVariant(const TQT_DBusVariant &value)
Creates a data object for the given variant value.
Definition: tqdbusdata.cpp:711
static TQT_DBusData fromUInt32KeyMap(const TQT_DBusDataMap< TQ_UINT32 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:839
TQT_DBusDataMap< TQT_DBusObjectPath > toObjectPathKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:948
static void qDBusInt64KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
Type
Enum for the data types used in D-Bus messages.
Definition: tqdbusdata.h:73
TQT_DBusDataMap< TQ_UINT64 > toUInt64KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:899
TQT_DBusDataMap< TQ_UINT16 > toUInt16KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:801
TQT_DBusDataMap< TQT_DBusUnixFd > toUnixFdKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:973
static TQT_DBusData fromObjectPathKeyMap(const TQT_DBusDataMap< TQT_DBusObjectPath > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:937
static void listToMessage(const TQValueList< TQT_DBusData > &list, DBusMessage *message)
TQ_UINT64 toUInt64(bool *ok=0) const
Tries to get the encapsulated unsigned 64-bit integer value.
Definition: tqdbusdata.cpp:526
Class to transport maps of D-Bus data types.
Definition: tqdbusdata.h:38
TQT_DBusData containerValueType() const
Returns a container prototype for the map&#39;s value type.
static TQT_DBusData fromByteKeyMap(const TQT_DBusDataMap< TQ_UINT8 > &map)
Creates a data object for the given map.
Definition: tqdbusdata.cpp:742
void qFetchUInt16KeyMapEntry(TQT_DBusDataMap< TQ_UINT16 > &map, DBusMessageIter *it)
TQT_DBusDataMap< TQ_UINT32 > toUInt32KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Definition: tqdbusdata.cpp:850
static void qDBusByteKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)