1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QDBUSEXTRATYPES_H
#define QDBUSEXTRATYPES_H
// define some useful types for D-Bus
#include <QtDBus/qtdbusglobal.h>
#include <QtCore/qvariant.h>
#include <QtCore/qstring.h>
#include <QtCore/qhashfunctions.h>
#ifndef QT_NO_DBUS
QT_BEGIN_NAMESPACE
class Q_DBUS_EXPORT QDBusObjectPath
{
QString m_path;
public:
QDBusObjectPath() noexcept : m_path() {}
// compiler-generated copy/move constructor/assignment operators are ok!
// compiler-generated destructor is ok!
inline explicit QDBusObjectPath(const char *path);
inline explicit QDBusObjectPath(QLatin1StringView path);
inline explicit QDBusObjectPath(const QString &path);
explicit QDBusObjectPath(QString &&p) : m_path(std::move(p)) { doCheck(); }
void swap(QDBusObjectPath &other) noexcept { m_path.swap(other.m_path); }
inline void setPath(const QString &path);
inline QString path() const
{ return m_path; }
operator QVariant() const;
private:
void doCheck();
};
Q_DECLARE_SHARED(QDBusObjectPath)
inline QDBusObjectPath::QDBusObjectPath(const char *objectPath)
: m_path(QString::fromLatin1(objectPath))
{ doCheck(); }
inline QDBusObjectPath::QDBusObjectPath(QLatin1StringView objectPath)
: m_path(objectPath)
{ doCheck(); }
inline QDBusObjectPath::QDBusObjectPath(const QString &objectPath)
: m_path(objectPath)
{ doCheck(); }
inline void QDBusObjectPath::setPath(const QString &objectPath)
{ m_path = objectPath; doCheck(); }
inline bool operator==(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs)
{ return lhs.path() == rhs.path(); }
inline bool operator!=(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs)
{ return lhs.path() != rhs.path(); }
inline bool operator<(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs)
{ return lhs.path() < rhs.path(); }
inline size_t qHash(const QDBusObjectPath &objectPath, size_t seed = 0)
{ return qHash(objectPath.path(), seed); }
#ifndef QT_NO_DEBUG_STREAM
Q_DBUS_EXPORT QDebug operator<<(QDebug, const QDBusObjectPath &);
#endif
class Q_DBUS_EXPORT QDBusSignature
{
QString m_signature;
public:
QDBusSignature() noexcept : m_signature() {}
// compiler-generated copy/move constructor/assignment operators are ok!
// compiler-generated destructor is ok!
inline explicit QDBusSignature(const char *signature);
inline explicit QDBusSignature(QLatin1StringView signature);
inline explicit QDBusSignature(const QString &signature);
explicit QDBusSignature(QString &&sig) : m_signature(std::move(sig)) { doCheck(); }
void swap(QDBusSignature &other) noexcept { m_signature.swap(other.m_signature); }
inline void setSignature(const QString &signature);
inline QString signature() const
{ return m_signature; }
private:
void doCheck();
};
Q_DECLARE_SHARED(QDBusSignature)
inline QDBusSignature::QDBusSignature(const char *dBusSignature)
: m_signature(QString::fromLatin1(dBusSignature))
{ doCheck(); }
inline QDBusSignature::QDBusSignature(QLatin1StringView dBusSignature)
: m_signature(dBusSignature)
{ doCheck(); }
inline QDBusSignature::QDBusSignature(const QString &dBusSignature)
: m_signature(dBusSignature)
{ doCheck(); }
inline void QDBusSignature::setSignature(const QString &dBusSignature)
{ m_signature = dBusSignature; doCheck(); }
inline bool operator==(const QDBusSignature &lhs, const QDBusSignature &rhs)
{ return lhs.signature() == rhs.signature(); }
inline bool operator!=(const QDBusSignature &lhs, const QDBusSignature &rhs)
{ return lhs.signature() != rhs.signature(); }
inline bool operator<(const QDBusSignature &lhs, const QDBusSignature &rhs)
{ return lhs.signature() < rhs.signature(); }
inline size_t qHash(const QDBusSignature &signature, size_t seed = 0)
{ return qHash(signature.signature(), seed); }
class QDBusVariant
{
QVariant m_variant;
public:
QDBusVariant() noexcept : m_variant() {}
// compiler-generated copy/move constructor/assignment operators are ok!
// compiler-generated destructor is ok!
inline explicit QDBusVariant(const QVariant &variant);
explicit QDBusVariant(QVariant &&v) noexcept : m_variant(std::move(v)) {}
void swap(QDBusVariant &other) noexcept { m_variant.swap(other.m_variant); }
inline void setVariant(const QVariant &variant);
inline QVariant variant() const
{ return m_variant; }
};
Q_DECLARE_SHARED(QDBusVariant)
inline QDBusVariant::QDBusVariant(const QVariant &dBusVariant)
: m_variant(dBusVariant) { }
inline void QDBusVariant::setVariant(const QVariant &dBusVariant)
{ m_variant = dBusVariant; }
inline bool operator==(const QDBusVariant &v1, const QDBusVariant &v2)
{ return v1.variant() == v2.variant(); }
QT_END_NAMESPACE
QT_DECL_METATYPE_EXTERN(QDBusVariant, Q_DBUS_EXPORT)
QT_DECL_METATYPE_EXTERN(QDBusObjectPath, Q_DBUS_EXPORT)
QT_DECL_METATYPE_EXTERN(QDBusSignature, Q_DBUS_EXPORT)
#endif // QT_NO_DBUS
#endif
|
