DBus-1-TQt 1.0
Loading...
Searching...
No Matches
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
41template <typename T>
42inline 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
73}
74
75static 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 {
104 TQT_DBusDataMap<TQ_UINT8>(valueType));
105 break;
108 TQT_DBusDataMap<TQ_INT16>(valueType));
109 break;
112 TQT_DBusDataMap<TQ_UINT16>(valueType));
113 break;
116 TQT_DBusDataMap<TQ_INT32>(valueType));
117 break;
120 TQT_DBusDataMap<TQ_UINT32>(valueType));
121 break;
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 {
161 TQT_DBusDataMap<TQ_UINT8>(valueContainer[0]));
162 break;
165 TQT_DBusDataMap<TQ_INT16>(valueContainer[0]));
166 break;
169 TQT_DBusDataMap<TQ_UINT16>(valueContainer[0]));
170 break;
173 TQT_DBusDataMap<TQ_INT32>(valueContainer[0]));
174 break;
177 TQT_DBusDataMap<TQ_UINT32>(valueContainer[0]));
178 break;
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 {
247 result << TQT_DBusData::fromBool(
248 (0));
249 break;
251 result << TQT_DBusData::fromByte(
252 (0));
253 break;
255 result << TQT_DBusData::fromInt16(
256 (0));
257 break;
259 result << TQT_DBusData::fromUInt16(
260 (0));
261 break;
263 result << TQT_DBusData::fromInt32(
264 (0));
265 break;
267 result << TQT_DBusData::fromUInt32(
268 (0));
269 break;
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;
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
310static TQT_DBusData qFetchParameter(DBusMessageIter *it);
311
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
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
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
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
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
429static 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
447 }
448
449 case DBUS_TYPE_INT16: {
451 do {
452 qFetchInt16KeyMapEntry(map, it);
453 } while (dbus_message_iter_next(it));
454
456 }
457
458 case DBUS_TYPE_UINT16: {
460 do {
462 } while (dbus_message_iter_next(it));
463
465 }
466
467 case DBUS_TYPE_INT32: {
469 do {
470 qFetchInt32KeyMapEntry(map, it);
471 } while (dbus_message_iter_next(it));
472
474 }
475
476 case DBUS_TYPE_UINT32: {
478 do {
480 } while (dbus_message_iter_next(it));
481
483 }
484
485 case DBUS_TYPE_INT64: {
487 do {
488 qFetchInt64KeyMapEntry(map, it);
489 } while (dbus_message_iter_next(it));
490
492 }
493
494 case DBUS_TYPE_UINT64: {
496 do {
498 } while (dbus_message_iter_next(it));
499
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: {
514 do {
516 } while (dbus_message_iter_next(it));
517
519 }
520
521 default:
522 break;
523 }
524
525 return prototype;
526}
527
528static 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
646static 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
653static 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
659static 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
673 return DBUS_TYPE_BOOLEAN_AS_STRING;
674
676 return DBUS_TYPE_BYTE_AS_STRING;
677
679 return DBUS_TYPE_INT16_AS_STRING;
680
682 return DBUS_TYPE_UINT16_AS_STRING;
683
685 return DBUS_TYPE_INT32_AS_STRING;
686
688 return DBUS_TYPE_UINT32_AS_STRING;
689
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
706 return DBUS_TYPE_ARRAY_AS_STRING;
707
709 return DBUS_TYPE_STRUCT_AS_STRING;
710
712 return DBUS_TYPE_VARIANT_AS_STRING;
713
715 return DBUS_TYPE_DICT_ENTRY_AS_STRING;
716
719 }
720 return 0;
721}
722
723static void qDBusDataToIterator(DBusMessageIter* it, const TQT_DBusData& var);
724
725static 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())
737 else
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
759static 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())
771 else
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
793static 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())
805 else
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
827static 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())
839 else
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
861static 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())
873 else
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
895static 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())
907 else
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
929static 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())
941 else
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
963static 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())
975 else
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
997static 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())
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
1032static 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())
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
1066static 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 }
1118 tqAppendToMessage(it, var.toString());
1119 break;
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:
1154 break;
1157 break;
1160 break;
1163 break;
1166 break;
1169 break;
1172 break;
1175 break;
1178 break;
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
1236void 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}
Class for accurately representing D-Bus data types.
Definition tqdbusdata.h:59
TQT_DBusDataMap< TQT_DBusUnixFd > toUnixFdKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
TQ_UINT32 toUInt32(bool *ok=0) const
Tries to get the encapsulated unsigned 32-bit integer value.
TQT_DBusVariant toVariant(bool *ok=0) const
Tries to get the encapsulated variant value.
bool isValid() const
Checks whether the data object contains a valid content.
Definition tqdbusdata.h:349
TQT_DBusUnixFd toUnixFd(bool *ok=0) const
Tries to get the encapsulated unix file handle value.
Type type() const
Returns the Type of the data object.
TQT_DBusDataMap< TQ_UINT64 > toUInt64KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
static TQT_DBusData fromBool(bool value)
Creates a data object for the given boolean value.
TQString toString(bool *ok=0) const
Tries to get the encapsulated string value.
TQ_INT64 toInt64(bool *ok=0) const
Tries to get the encapsulated signed 64-bit integer value.
static TQT_DBusData fromUInt64(TQ_UINT64 value)
Creates a data object for the given unsigned 64-bit integer value.
TQValueList< TQT_DBusData > toStruct(bool *ok=0) const
Tries to get the encapsulated struct memberList.
static TQT_DBusData fromInt16(TQ_INT16 value)
Creates a data object for the given signed 16-bit integer value.
TQT_DBusDataMap< TQ_INT16 > toInt16KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
static TQT_DBusData fromStringKeyMap(const TQT_DBusDataMap< TQString > &map)
Creates a data object for the given map.
TQ_UINT64 toUInt64(bool *ok=0) const
Tries to get the encapsulated unsigned 64-bit integer value.
static TQT_DBusData fromUInt32KeyMap(const TQT_DBusDataMap< TQ_UINT32 > &map)
Creates a data object for the given map.
static TQT_DBusData fromInt16KeyMap(const TQT_DBusDataMap< TQ_INT16 > &map)
Creates a data object for the given map.
static TQT_DBusData fromUInt16KeyMap(const TQT_DBusDataMap< TQ_UINT16 > &map)
Creates a data object for the given map.
TQ_UINT8 toByte(bool *ok=0) const
Tries to get the encapsulated byte (unsigned char) value.
static TQT_DBusData fromObjectPathKeyMap(const TQT_DBusDataMap< TQT_DBusObjectPath > &map)
Creates a data object for the given map.
TQT_DBusDataMap< TQ_UINT16 > toUInt16KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
Type keyType() const
Returns the Type of the key type for maps.
TQT_DBusDataMap< TQ_UINT32 > toUInt32KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
static TQT_DBusData fromByte(TQ_UINT8 value)
Creates a data object for the given byte (unsigned char) value.
TQT_DBusDataMap< TQString > toStringKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
TQT_DBusDataMap< TQ_INT64 > toInt64KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
TQT_DBusObjectPath toObjectPath(bool *ok=0) const
Tries to get the encapsulated object path value.
const char * typeName() const
Returns the string representation of the object's Type.
Definition tqdbusdata.h:385
static TQT_DBusData fromList(const TQT_DBusDataList &list)
Creates a data object for the given list.
TQ_UINT16 toUInt16(bool *ok=0) const
Tries to get the encapsulated unsigned 16-bit integer value.
TQ_INT32 toInt32(bool *ok=0) const
Tries to get the encapsulated signed 32-bit integer value.
static TQT_DBusData fromUInt32(TQ_UINT32 value)
Creates a data object for the given unsigned 32-bit integer value.
static TQT_DBusData fromStruct(const TQValueList< TQT_DBusData > &memberList)
Creates a data object for the given struct's memberList.
bool toBool(bool *ok=0) const
Tries to get the encapsulated boolean value.
static TQT_DBusData fromDouble(double value)
Creates a data object for the given double value.
static TQT_DBusData fromUnixFdKeyMap(const TQT_DBusDataMap< TQT_DBusUnixFd > &map)
Creates a data object for the given map.
TQ_INT16 toInt16(bool *ok=0) const
Tries to get the encapsulated signed 16-bit integer value.
TQCString buildDBusSignature() const
Creates the data objects D-Bus signature.
static TQT_DBusData fromInt32KeyMap(const TQT_DBusDataMap< TQ_INT32 > &map)
Creates a data object for the given map.
static TQT_DBusData fromObjectPath(const TQT_DBusObjectPath &value)
Creates a data object for the given object path value.
TQValueList< TQT_DBusData > toTQValueList(bool *ok=0) const
Tries to get the encapsulated list.
static TQT_DBusData fromUnixFd(const TQT_DBusUnixFd &value)
Creates a data object for the given unix file handle value.
TQT_DBusDataMap< TQ_UINT8 > toByteKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
static TQT_DBusData fromInt32(TQ_INT32 value)
Creates a data object for the given signed 32-bit integer value.
static TQT_DBusData fromInt64KeyMap(const TQT_DBusDataMap< TQ_INT64 > &map)
Creates a data object for the given map.
Type
Enum for the data types used in D-Bus messages.
Definition tqdbusdata.h:74
TQT_DBusDataMap< TQ_INT32 > toInt32KeyMap(bool *ok=0) const
Tries to get the encapsulated map.
double toDouble(bool *ok=0) const
Tries to get the encapsulated double value.
TQT_DBusDataList toList(bool *ok=0) const
Tries to get the encapsulated list.
static TQT_DBusData fromString(const TQString &value)
Creates a data object for the given string value.
static TQT_DBusData fromInt64(TQ_INT64 value)
Creates a data object for the given signed 64-bit integer value.
TQT_DBusDataMap< TQT_DBusObjectPath > toObjectPathKeyMap(bool *ok=0) const
Tries to get the encapsulated map.
static TQT_DBusData fromVariant(const TQT_DBusVariant &value)
Creates a data object for the given variant value.
static TQT_DBusData fromUInt16(TQ_UINT16 value)
Creates a data object for the given unsigned 16-bit integer value.
static TQT_DBusData fromByteKeyMap(const TQT_DBusDataMap< TQ_UINT8 > &map)
Creates a data object for the given map.
static TQT_DBusData fromUInt64KeyMap(const TQT_DBusDataMap< TQ_UINT64 > &map)
Creates a data object for the given map.
Class to transport lists of D-Bus data types.
TQT_DBusData containerItemType() const
Returns a container prototype for the list's element type.
bool hasContainerItemType() const
Checks whether the element type is a data container itself.
TQT_DBusData::Type type() const
Returns the element type of the list object.
Class to transport maps of D-Bus data types.
TQT_DBusData::Type keyType() const
Returns the key type of the map object.
TQT_DBusData::Type valueType() const
Returns the value type of the map object.
TQMapConstIterator< T, TQT_DBusData > const_iterator
TQT_DBusData containerValueType() const
Returns a container prototype for the map's value type.
const_iterator begin() const
Returns an iterator to the first item according to the key sort order.
const_iterator end() const
Returns an iterator to an invalid position.
bool hasContainerValueType() const
Checks whether the value type is a data container itself.
bool insert(const T &key, const TQT_DBusData &data)
Inserts a given value for a given key.
static void messageToList(TQValueList< TQT_DBusData > &list, DBusMessage *message)
static void listToMessage(const TQValueList< TQT_DBusData > &list, DBusMessage *message)
Class for representing D-Bus object paths.
Class for representing D-Bus unix file handles.
void giveFileDescriptor(int fileDescriptor)
Give unix file handle.
int fileDescriptor() const
Get unix file handle.
Data type for representing a D-Bus variant.
TQT_DBusData value
The D-Bus data type to transport as a variant.
TQString signature
The D-Bus data signature of the data contained in value.
T qIterGet(DBusMessageIter *it)
void qFetchUInt64KeyMapEntry(TQT_DBusDataMap< TQ_UINT64 > &map, DBusMessageIter *it)
static void qDBusUInt32KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static TQT_DBusData qFetchMap(DBusMessageIter *it, const TQT_DBusData &prototype)
static void qDBusUInt64KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static void tqAppendToMessage(DBusMessageIter *it, const TQString &str)
void qFetchInt32KeyMapEntry(TQT_DBusDataMap< TQ_INT32 > &map, DBusMessageIter *it)
static void qDBusInt16KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static TQT_DBusData::Type qSingleTypeForDBusSignature(char signature)
void qFetchStringKeyMapEntry(TQT_DBusDataMap< TQString > &map, DBusMessageIter *it)
static const char * qDBusTypeForTQT_DBusType(TQT_DBusData::Type type)
static void qDBusObjectPathKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static void qDBusInt32KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchObjectPathKeyMapEntry(TQT_DBusDataMap< TQT_DBusObjectPath > &map, DBusMessageIter *it)
static void qDBusUInt16KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchByteKeyMapEntry(TQT_DBusDataMap< TQ_UINT8 > &map, DBusMessageIter *it)
static void qDBusStringKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static void qDBusInt64KeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchUInt32KeyMapEntry(TQT_DBusDataMap< TQ_UINT32 > &map, DBusMessageIter *it)
static void qDBusDataToIterator(DBusMessageIter *it, const TQT_DBusData &var)
static void qDBusUnixFdKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qListToIterator(DBusMessageIter *it, const TQValueList< TQT_DBusData > &list)
static TQValueList< TQT_DBusData > parseSignature(TQCString &signature)
static void qDBusByteKeyMapToIterator(DBusMessageIter *it, const TQT_DBusData &var)
void qFetchInt64KeyMapEntry(TQT_DBusDataMap< TQ_INT64 > &map, DBusMessageIter *it)
void qFetchInt16KeyMapEntry(TQT_DBusDataMap< TQ_INT16 > &map, DBusMessageIter *it)
void qFetchUInt16KeyMapEntry(TQT_DBusDataMap< TQ_UINT16 > &map, DBusMessageIter *it)
static TQT_DBusData qFetchParameter(DBusMessageIter *it)
#define DBUS_TYPE_UNIX_FD_AS_STRING
#define DBUS_TYPE_UNIX_FD