d55f2b1fb9
This reverts commit 5f542f3cca,
since it breaks streaming of types derived from QList and
the docs state that this should be possible without providing
custom op<</>> for such types.
Task-number: QTBUG-53376
Change-Id: I2bde714ac384f2aed67ad30decea702fb79aef1b
Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
425 lines
13 KiB
C++
425 lines
13 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtDBus module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef QDBUSARGUMENT_H
|
|
#define QDBUSARGUMENT_H
|
|
|
|
#include <QtCore/qbytearray.h>
|
|
#include <QtCore/qhash.h>
|
|
#include <QtCore/qglobal.h>
|
|
#include <QtCore/qlist.h>
|
|
#include <QtCore/qmap.h>
|
|
#include <QtCore/qstring.h>
|
|
#include <QtCore/qstringlist.h>
|
|
#include <QtCore/qvariant.h>
|
|
#include <QtDBus/qdbusextratypes.h>
|
|
#include <QtDBus/qdbusmacros.h>
|
|
|
|
#ifndef QT_NO_DBUS
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
|
|
class QDBusUnixFileDescriptor;
|
|
|
|
class QDBusArgumentPrivate;
|
|
class QDBusDemarshaller;
|
|
class QDBusMarshaller;
|
|
class Q_DBUS_EXPORT QDBusArgument
|
|
{
|
|
public:
|
|
enum ElementType {
|
|
BasicType,
|
|
VariantType,
|
|
ArrayType,
|
|
StructureType,
|
|
MapType,
|
|
MapEntryType,
|
|
UnknownType = -1
|
|
};
|
|
|
|
QDBusArgument();
|
|
QDBusArgument(const QDBusArgument &other);
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
QDBusArgument(QDBusArgument &&other) Q_DECL_NOTHROW : d(other.d) { other.d = Q_NULLPTR; }
|
|
QDBusArgument &operator=(QDBusArgument &&other) Q_DECL_NOTHROW { swap(other); return *this; }
|
|
#endif
|
|
QDBusArgument &operator=(const QDBusArgument &other);
|
|
~QDBusArgument();
|
|
|
|
void swap(QDBusArgument &other) Q_DECL_NOTHROW { qSwap(d, other.d); }
|
|
|
|
// used for marshalling (Qt -> D-BUS)
|
|
QDBusArgument &operator<<(uchar arg);
|
|
QDBusArgument &operator<<(bool arg);
|
|
QDBusArgument &operator<<(short arg);
|
|
QDBusArgument &operator<<(ushort arg);
|
|
QDBusArgument &operator<<(int arg);
|
|
QDBusArgument &operator<<(uint arg);
|
|
QDBusArgument &operator<<(qlonglong arg);
|
|
QDBusArgument &operator<<(qulonglong arg);
|
|
QDBusArgument &operator<<(double arg);
|
|
QDBusArgument &operator<<(const QString &arg);
|
|
QDBusArgument &operator<<(const QDBusVariant &arg);
|
|
QDBusArgument &operator<<(const QDBusObjectPath &arg);
|
|
QDBusArgument &operator<<(const QDBusSignature &arg);
|
|
QDBusArgument &operator<<(const QDBusUnixFileDescriptor &arg);
|
|
QDBusArgument &operator<<(const QStringList &arg);
|
|
QDBusArgument &operator<<(const QByteArray &arg);
|
|
|
|
void beginStructure();
|
|
void endStructure();
|
|
void beginArray(int elementMetaTypeId);
|
|
void endArray();
|
|
void beginMap(int keyMetaTypeId, int valueMetaTypeId);
|
|
void endMap();
|
|
void beginMapEntry();
|
|
void endMapEntry();
|
|
|
|
void appendVariant(const QVariant &v);
|
|
|
|
// used for de-marshalling (D-BUS -> Qt)
|
|
QString currentSignature() const;
|
|
ElementType currentType() const;
|
|
|
|
const QDBusArgument &operator>>(uchar &arg) const;
|
|
const QDBusArgument &operator>>(bool &arg) const;
|
|
const QDBusArgument &operator>>(short &arg) const;
|
|
const QDBusArgument &operator>>(ushort &arg) const;
|
|
const QDBusArgument &operator>>(int &arg) const;
|
|
const QDBusArgument &operator>>(uint &arg) const;
|
|
const QDBusArgument &operator>>(qlonglong &arg) const;
|
|
const QDBusArgument &operator>>(qulonglong &arg) const;
|
|
const QDBusArgument &operator>>(double &arg) const;
|
|
const QDBusArgument &operator>>(QString &arg) const;
|
|
const QDBusArgument &operator>>(QDBusVariant &arg) const;
|
|
const QDBusArgument &operator>>(QDBusObjectPath &arg) const;
|
|
const QDBusArgument &operator>>(QDBusSignature &arg) const;
|
|
const QDBusArgument &operator>>(QDBusUnixFileDescriptor &arg) const;
|
|
const QDBusArgument &operator>>(QStringList &arg) const;
|
|
const QDBusArgument &operator>>(QByteArray &arg) const;
|
|
|
|
void beginStructure() const;
|
|
void endStructure() const;
|
|
void beginArray() const;
|
|
void endArray() const;
|
|
void beginMap() const;
|
|
void endMap() const;
|
|
void beginMapEntry() const;
|
|
void endMapEntry() const;
|
|
bool atEnd() const;
|
|
|
|
QVariant asVariant() const;
|
|
|
|
protected:
|
|
QDBusArgument(QDBusArgumentPrivate *d);
|
|
friend class QDBusArgumentPrivate;
|
|
mutable QDBusArgumentPrivate *d;
|
|
};
|
|
Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QDBusArgument)
|
|
|
|
QT_END_NAMESPACE
|
|
Q_DECLARE_METATYPE(QDBusArgument)
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
template<typename T> inline T qdbus_cast(const QDBusArgument &arg
|
|
#ifndef Q_QDOC
|
|
, T * = Q_NULLPTR
|
|
#endif
|
|
)
|
|
{
|
|
T item;
|
|
arg >> item;
|
|
return item;
|
|
}
|
|
|
|
template<typename T> inline T qdbus_cast(const QVariant &v
|
|
#ifndef Q_QDOC
|
|
, T * = Q_NULLPTR
|
|
#endif
|
|
)
|
|
{
|
|
int id = v.userType();
|
|
if (id == qMetaTypeId<QDBusArgument>())
|
|
return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v));
|
|
else
|
|
return qvariant_cast<T>(v);
|
|
}
|
|
|
|
// specialize for QVariant, allowing it to be used in place of QDBusVariant
|
|
template<> inline QVariant qdbus_cast<QVariant>(const QDBusArgument &arg, QVariant *)
|
|
{
|
|
QDBusVariant item;
|
|
arg >> item;
|
|
return item.variant();
|
|
}
|
|
template<> inline QVariant qdbus_cast<QVariant>(const QVariant &v, QVariant *)
|
|
{
|
|
return qdbus_cast<QDBusVariant>(v).variant();
|
|
}
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QVariant &v);
|
|
|
|
// QVariant types
|
|
#ifndef QDBUS_NO_SPECIALTYPES
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDate &date);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDate &date);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QTime &time);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QTime &time);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDateTime &dt);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDateTime &dt);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRect &rect);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRect &rect);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRectF &rect);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRectF &rect);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSize &size);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSize &size);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSizeF &size);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSizeF &size);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPoint &pt);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPoint &pt);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPointF &pt);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPointF &pt);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLine &line);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLine &line);
|
|
|
|
Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLineF &line);
|
|
Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLineF &line);
|
|
#endif
|
|
|
|
template<template <typename> class Container, typename T>
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const Container<T> &list)
|
|
{
|
|
int id = qMetaTypeId<T>();
|
|
arg.beginArray(id);
|
|
typename Container<T>::const_iterator it = list.begin();
|
|
typename Container<T>::const_iterator end = list.end();
|
|
for ( ; it != end; ++it)
|
|
arg << *it;
|
|
arg.endArray();
|
|
return arg;
|
|
}
|
|
|
|
template<template <typename> class Container, typename T>
|
|
inline const QDBusArgument &operator>>(const QDBusArgument &arg, Container<T> &list)
|
|
{
|
|
arg.beginArray();
|
|
list.clear();
|
|
while (!arg.atEnd()) {
|
|
T item;
|
|
arg >> item;
|
|
list.push_back(item);
|
|
}
|
|
|
|
arg.endArray();
|
|
return arg;
|
|
}
|
|
|
|
// QList specializations
|
|
template<typename T>
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QList<T> &list)
|
|
{
|
|
int id = qMetaTypeId<T>();
|
|
arg.beginArray(id);
|
|
typename QList<T>::ConstIterator it = list.constBegin();
|
|
typename QList<T>::ConstIterator end = list.constEnd();
|
|
for ( ; it != end; ++it)
|
|
arg << *it;
|
|
arg.endArray();
|
|
return arg;
|
|
}
|
|
|
|
template<typename T>
|
|
inline const QDBusArgument &operator>>(const QDBusArgument &arg, QList<T> &list)
|
|
{
|
|
arg.beginArray();
|
|
list.clear();
|
|
while (!arg.atEnd()) {
|
|
T item;
|
|
arg >> item;
|
|
list.push_back(item);
|
|
}
|
|
arg.endArray();
|
|
|
|
return arg;
|
|
}
|
|
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantList &list)
|
|
{
|
|
int id = qMetaTypeId<QDBusVariant>();
|
|
arg.beginArray(id);
|
|
QVariantList::ConstIterator it = list.constBegin();
|
|
QVariantList::ConstIterator end = list.constEnd();
|
|
for ( ; it != end; ++it)
|
|
arg << QDBusVariant(*it);
|
|
arg.endArray();
|
|
return arg;
|
|
}
|
|
|
|
// QMap specializations
|
|
template<typename Key, typename T>
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QMap<Key, T> &map)
|
|
{
|
|
int kid = qMetaTypeId<Key>();
|
|
int vid = qMetaTypeId<T>();
|
|
arg.beginMap(kid, vid);
|
|
typename QMap<Key, T>::ConstIterator it = map.constBegin();
|
|
typename QMap<Key, T>::ConstIterator end = map.constEnd();
|
|
for ( ; it != end; ++it) {
|
|
arg.beginMapEntry();
|
|
arg << it.key() << it.value();
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
template<typename Key, typename T>
|
|
inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap<Key, T> &map)
|
|
{
|
|
arg.beginMap();
|
|
map.clear();
|
|
while (!arg.atEnd()) {
|
|
Key key;
|
|
T value;
|
|
arg.beginMapEntry();
|
|
arg >> key >> value;
|
|
map.insertMulti(key, value);
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map)
|
|
{
|
|
arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
|
|
QVariantMap::ConstIterator it = map.constBegin();
|
|
QVariantMap::ConstIterator end = map.constEnd();
|
|
for ( ; it != end; ++it) {
|
|
arg.beginMapEntry();
|
|
arg << it.key() << QDBusVariant(it.value());
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
// QHash specializations
|
|
template<typename Key, typename T>
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QHash<Key, T> &map)
|
|
{
|
|
int kid = qMetaTypeId<Key>();
|
|
int vid = qMetaTypeId<T>();
|
|
arg.beginMap(kid, vid);
|
|
typename QHash<Key, T>::ConstIterator it = map.constBegin();
|
|
typename QHash<Key, T>::ConstIterator end = map.constEnd();
|
|
for ( ; it != end; ++it) {
|
|
arg.beginMapEntry();
|
|
arg << it.key() << it.value();
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
template<typename Key, typename T>
|
|
inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash<Key, T> &map)
|
|
{
|
|
arg.beginMap();
|
|
map.clear();
|
|
while (!arg.atEnd()) {
|
|
Key key;
|
|
T value;
|
|
arg.beginMapEntry();
|
|
arg >> key >> value;
|
|
map.insertMulti(key, value);
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantHash &map)
|
|
{
|
|
arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
|
|
QVariantHash::ConstIterator it = map.constBegin();
|
|
QVariantHash::ConstIterator end = map.constEnd();
|
|
for ( ; it != end; ++it) {
|
|
arg.beginMapEntry();
|
|
arg << it.key() << QDBusVariant(it.value());
|
|
arg.endMapEntry();
|
|
}
|
|
arg.endMap();
|
|
return arg;
|
|
}
|
|
|
|
template <typename T1, typename T2>
|
|
inline QDBusArgument &operator<<(QDBusArgument &arg, const QPair<T1, T2> &pair)
|
|
{
|
|
arg.beginStructure();
|
|
arg << pair.first << pair.second;
|
|
arg.endStructure();
|
|
return arg;
|
|
}
|
|
|
|
template <typename T1, typename T2>
|
|
inline const QDBusArgument &operator>>(const QDBusArgument &arg, QPair<T1, T2> &pair)
|
|
{
|
|
arg.beginStructure();
|
|
arg >> pair.first >> pair.second;
|
|
arg.endStructure();
|
|
return arg;
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#endif // QT_NO_DBUS
|
|
#endif
|