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);
QDBusArgument(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 
swap(QDBusArgument & other)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 };
Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QDBusArgument)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