1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtDBus module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #ifndef QDBUSARGUMENT_H |
41 | #define QDBUSARGUMENT_H |
42 | |
43 | #include <QtDBus/qtdbusglobal.h> |
44 | #include <QtCore/qbytearray.h> |
45 | #include <QtCore/qhash.h> |
46 | #include <QtCore/qglobal.h> |
47 | #include <QtCore/qlist.h> |
48 | #include <QtCore/qmap.h> |
49 | #include <QtCore/qstring.h> |
50 | #include <QtCore/qstringlist.h> |
51 | #include <QtCore/qvariant.h> |
52 | #include <QtDBus/qdbusextratypes.h> |
53 | |
54 | #ifndef QT_NO_DBUS |
55 | |
56 | QT_BEGIN_NAMESPACE |
57 | |
58 | |
59 | class QDBusUnixFileDescriptor; |
60 | |
61 | class QDBusArgumentPrivate; |
62 | class QDBusDemarshaller; |
63 | class QDBusMarshaller; |
64 | class Q_DBUS_EXPORT QDBusArgument |
65 | { |
66 | public: |
67 | enum ElementType { |
68 | BasicType, |
69 | VariantType, |
70 | ArrayType, |
71 | StructureType, |
72 | MapType, |
73 | MapEntryType, |
74 | UnknownType = -1 |
75 | }; |
76 | |
77 | QDBusArgument(); |
78 | QDBusArgument(const QDBusArgument &other); |
79 | QDBusArgument(QDBusArgument &&other) noexcept : d(other.d) { other.d = nullptr; } |
80 | QDBusArgument &operator=(QDBusArgument &&other) noexcept { swap(other); return *this; } |
81 | QDBusArgument &operator=(const QDBusArgument &other); |
82 | ~QDBusArgument(); |
83 | |
84 | void swap(QDBusArgument &other) noexcept { qSwap(d, other.d); } |
85 | |
86 | // used for marshalling (Qt -> D-BUS) |
87 | QDBusArgument &operator<<(uchar arg); |
88 | QDBusArgument &operator<<(bool arg); |
89 | QDBusArgument &operator<<(short arg); |
90 | QDBusArgument &operator<<(ushort arg); |
91 | QDBusArgument &operator<<(int arg); |
92 | QDBusArgument &operator<<(uint arg); |
93 | QDBusArgument &operator<<(qlonglong arg); |
94 | QDBusArgument &operator<<(qulonglong arg); |
95 | QDBusArgument &operator<<(double arg); |
96 | QDBusArgument &operator<<(const QString &arg); |
97 | QDBusArgument &operator<<(const QDBusVariant &arg); |
98 | QDBusArgument &operator<<(const QDBusObjectPath &arg); |
99 | QDBusArgument &operator<<(const QDBusSignature &arg); |
100 | QDBusArgument &operator<<(const QDBusUnixFileDescriptor &arg); |
101 | QDBusArgument &operator<<(const QStringList &arg); |
102 | QDBusArgument &operator<<(const QByteArray &arg); |
103 | |
104 | void beginStructure(); |
105 | void endStructure(); |
106 | void beginArray(int elementMetaTypeId); |
107 | void endArray(); |
108 | void beginMap(int keyMetaTypeId, int valueMetaTypeId); |
109 | void endMap(); |
110 | void beginMapEntry(); |
111 | void endMapEntry(); |
112 | |
113 | void appendVariant(const QVariant &v); |
114 | |
115 | // used for de-marshalling (D-BUS -> Qt) |
116 | QString currentSignature() const; |
117 | ElementType currentType() const; |
118 | |
119 | const QDBusArgument &operator>>(uchar &arg) const; |
120 | const QDBusArgument &operator>>(bool &arg) const; |
121 | const QDBusArgument &operator>>(short &arg) const; |
122 | const QDBusArgument &operator>>(ushort &arg) const; |
123 | const QDBusArgument &operator>>(int &arg) const; |
124 | const QDBusArgument &operator>>(uint &arg) const; |
125 | const QDBusArgument &operator>>(qlonglong &arg) const; |
126 | const QDBusArgument &operator>>(qulonglong &arg) const; |
127 | const QDBusArgument &operator>>(double &arg) const; |
128 | const QDBusArgument &operator>>(QString &arg) const; |
129 | const QDBusArgument &operator>>(QDBusVariant &arg) const; |
130 | const QDBusArgument &operator>>(QDBusObjectPath &arg) const; |
131 | const QDBusArgument &operator>>(QDBusSignature &arg) const; |
132 | const QDBusArgument &operator>>(QDBusUnixFileDescriptor &arg) const; |
133 | const QDBusArgument &operator>>(QStringList &arg) const; |
134 | const QDBusArgument &operator>>(QByteArray &arg) const; |
135 | |
136 | void beginStructure() const; |
137 | void endStructure() const; |
138 | void beginArray() const; |
139 | void endArray() const; |
140 | void beginMap() const; |
141 | void endMap() const; |
142 | void beginMapEntry() const; |
143 | void endMapEntry() const; |
144 | bool atEnd() const; |
145 | |
146 | QVariant asVariant() const; |
147 | |
148 | protected: |
149 | QDBusArgument(QDBusArgumentPrivate *d); |
150 | friend class QDBusArgumentPrivate; |
151 | mutable QDBusArgumentPrivate *d; |
152 | }; |
153 | Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QDBusArgument) |
154 | |
155 | QT_END_NAMESPACE |
156 | Q_DECLARE_METATYPE(QDBusArgument) |
157 | QT_BEGIN_NAMESPACE |
158 | |
159 | // ### Qt6: remove the defaulted T * = nullptr from these two (MSVC6 work-around): |
160 | template<typename T> inline T qdbus_cast(const QDBusArgument &arg, T * = nullptr) |
161 | { |
162 | T item; |
163 | arg >> item; |
164 | return item; |
165 | } |
166 | |
167 | template<typename T> inline T qdbus_cast(const QVariant &v, T * = nullptr) |
168 | { |
169 | int id = v.userType(); |
170 | if (id == qMetaTypeId<QDBusArgument>()) |
171 | return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v)); |
172 | else |
173 | return qvariant_cast<T>(v); |
174 | } |
175 | |
176 | // specialize for QVariant, allowing it to be used in place of QDBusVariant |
177 | template<> inline QVariant qdbus_cast<QVariant>(const QDBusArgument &arg, QVariant *) |
178 | { |
179 | QDBusVariant item; |
180 | arg >> item; |
181 | return item.variant(); |
182 | } |
183 | template<> inline QVariant qdbus_cast<QVariant>(const QVariant &v, QVariant *) |
184 | { |
185 | return qdbus_cast<QDBusVariant>(v).variant(); |
186 | } |
187 | |
188 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QVariant &v); |
189 | |
190 | // QVariant types |
191 | #ifndef QDBUS_NO_SPECIALTYPES |
192 | |
193 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDate &date); |
194 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDate &date); |
195 | |
196 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QTime &time); |
197 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QTime &time); |
198 | |
199 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDateTime &dt); |
200 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDateTime &dt); |
201 | |
202 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRect &rect); |
203 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRect &rect); |
204 | |
205 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRectF &rect); |
206 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRectF &rect); |
207 | |
208 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSize &size); |
209 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSize &size); |
210 | |
211 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSizeF &size); |
212 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSizeF &size); |
213 | |
214 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPoint &pt); |
215 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPoint &pt); |
216 | |
217 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPointF &pt); |
218 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPointF &pt); |
219 | |
220 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLine &line); |
221 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLine &line); |
222 | |
223 | Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLineF &line); |
224 | Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLineF &line); |
225 | #endif |
226 | |
227 | template<template <typename> class Container, typename T> |
228 | inline QDBusArgument &operator<<(QDBusArgument &arg, const Container<T> &list) |
229 | { |
230 | int id = qMetaTypeId<T>(); |
231 | arg.beginArray(id); |
232 | typename Container<T>::const_iterator it = list.begin(); |
233 | typename Container<T>::const_iterator end = list.end(); |
234 | for ( ; it != end; ++it) |
235 | arg << *it; |
236 | arg.endArray(); |
237 | return arg; |
238 | } |
239 | |
240 | template<template <typename> class Container, typename T> |
241 | inline const QDBusArgument &operator>>(const QDBusArgument &arg, Container<T> &list) |
242 | { |
243 | arg.beginArray(); |
244 | list.clear(); |
245 | while (!arg.atEnd()) { |
246 | T item; |
247 | arg >> item; |
248 | list.push_back(item); |
249 | } |
250 | |
251 | arg.endArray(); |
252 | return arg; |
253 | } |
254 | |
255 | // QList specializations |
256 | template<typename T> |
257 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QList<T> &list) |
258 | { |
259 | int id = qMetaTypeId<T>(); |
260 | arg.beginArray(id); |
261 | typename QList<T>::ConstIterator it = list.constBegin(); |
262 | typename QList<T>::ConstIterator end = list.constEnd(); |
263 | for ( ; it != end; ++it) |
264 | arg << *it; |
265 | arg.endArray(); |
266 | return arg; |
267 | } |
268 | |
269 | template<typename T> |
270 | inline const QDBusArgument &operator>>(const QDBusArgument &arg, QList<T> &list) |
271 | { |
272 | arg.beginArray(); |
273 | list.clear(); |
274 | while (!arg.atEnd()) { |
275 | T item; |
276 | arg >> item; |
277 | list.push_back(item); |
278 | } |
279 | arg.endArray(); |
280 | |
281 | return arg; |
282 | } |
283 | |
284 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantList &list) |
285 | { |
286 | int id = qMetaTypeId<QDBusVariant>(); |
287 | arg.beginArray(id); |
288 | QVariantList::ConstIterator it = list.constBegin(); |
289 | QVariantList::ConstIterator end = list.constEnd(); |
290 | for ( ; it != end; ++it) |
291 | arg << QDBusVariant(*it); |
292 | arg.endArray(); |
293 | return arg; |
294 | } |
295 | |
296 | // QMap specializations |
297 | template<typename Key, typename T> |
298 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QMap<Key, T> &map) |
299 | { |
300 | int kid = qMetaTypeId<Key>(); |
301 | int vid = qMetaTypeId<T>(); |
302 | arg.beginMap(kid, vid); |
303 | typename QMap<Key, T>::ConstIterator it = map.constBegin(); |
304 | typename QMap<Key, T>::ConstIterator end = map.constEnd(); |
305 | for ( ; it != end; ++it) { |
306 | arg.beginMapEntry(); |
307 | arg << it.key() << it.value(); |
308 | arg.endMapEntry(); |
309 | } |
310 | arg.endMap(); |
311 | return arg; |
312 | } |
313 | |
314 | template<typename Key, typename T> |
315 | inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap<Key, T> &map) |
316 | { |
317 | arg.beginMap(); |
318 | map.clear(); |
319 | while (!arg.atEnd()) { |
320 | Key key; |
321 | T value; |
322 | arg.beginMapEntry(); |
323 | arg >> key >> value; |
324 | static_cast<QMultiMap<Key, T> &>(map).insert(key, value); |
325 | arg.endMapEntry(); |
326 | } |
327 | arg.endMap(); |
328 | return arg; |
329 | } |
330 | |
331 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map) |
332 | { |
333 | arg.beginMap(QMetaType::QString, qMetaTypeId<QDBusVariant>()); |
334 | QVariantMap::ConstIterator it = map.constBegin(); |
335 | QVariantMap::ConstIterator end = map.constEnd(); |
336 | for ( ; it != end; ++it) { |
337 | arg.beginMapEntry(); |
338 | arg << it.key() << QDBusVariant(it.value()); |
339 | arg.endMapEntry(); |
340 | } |
341 | arg.endMap(); |
342 | return arg; |
343 | } |
344 | |
345 | // QHash specializations |
346 | template<typename Key, typename T> |
347 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QHash<Key, T> &map) |
348 | { |
349 | int kid = qMetaTypeId<Key>(); |
350 | int vid = qMetaTypeId<T>(); |
351 | arg.beginMap(kid, vid); |
352 | typename QHash<Key, T>::ConstIterator it = map.constBegin(); |
353 | typename QHash<Key, T>::ConstIterator end = map.constEnd(); |
354 | for ( ; it != end; ++it) { |
355 | arg.beginMapEntry(); |
356 | arg << it.key() << it.value(); |
357 | arg.endMapEntry(); |
358 | } |
359 | arg.endMap(); |
360 | return arg; |
361 | } |
362 | |
363 | template<typename Key, typename T> |
364 | inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash<Key, T> &map) |
365 | { |
366 | arg.beginMap(); |
367 | map.clear(); |
368 | while (!arg.atEnd()) { |
369 | Key key; |
370 | T value; |
371 | arg.beginMapEntry(); |
372 | arg >> key >> value; |
373 | static_cast<QMultiHash<Key, T> &>(map).insert(key, value); |
374 | arg.endMapEntry(); |
375 | } |
376 | arg.endMap(); |
377 | return arg; |
378 | } |
379 | |
380 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantHash &map) |
381 | { |
382 | arg.beginMap(QMetaType::QString, qMetaTypeId<QDBusVariant>()); |
383 | QVariantHash::ConstIterator it = map.constBegin(); |
384 | QVariantHash::ConstIterator end = map.constEnd(); |
385 | for ( ; it != end; ++it) { |
386 | arg.beginMapEntry(); |
387 | arg << it.key() << QDBusVariant(it.value()); |
388 | arg.endMapEntry(); |
389 | } |
390 | arg.endMap(); |
391 | return arg; |
392 | } |
393 | |
394 | template <typename T1, typename T2> |
395 | inline QDBusArgument &operator<<(QDBusArgument &arg, const QPair<T1, T2> &pair) |
396 | { |
397 | arg.beginStructure(); |
398 | arg << pair.first << pair.second; |
399 | arg.endStructure(); |
400 | return arg; |
401 | } |
402 | |
403 | template <typename T1, typename T2> |
404 | inline const QDBusArgument &operator>>(const QDBusArgument &arg, QPair<T1, T2> &pair) |
405 | { |
406 | arg.beginStructure(); |
407 | arg >> pair.first >> pair.second; |
408 | arg.endStructure(); |
409 | return arg; |
410 | } |
411 | |
412 | QT_END_NAMESPACE |
413 | |
414 | #endif // QT_NO_DBUS |
415 | #endif |
416 | |