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
|
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
//
// W A R N I N G
// -------------
//
// This file is not part of the public API. This header file may
// change from version to version without notice, or even be
// removed.
//
// We mean it.
//
//
#ifndef QDBUSINTEGRATOR_P_H
#define QDBUSINTEGRATOR_P_H
#include <QtDBus/private/qtdbusglobal_p.h>
#include "qdbus_symbols_p.h"
#include "qcoreevent.h"
#include "qeventloop.h"
#include "qobject.h"
#include "private/qobject_p.h"
#include "qlist.h"
#include "qpointer.h"
#include "qsemaphore.h"
#include "qdbusconnection.h"
#include "qdbusmessage.h"
#include "qdbusconnection_p.h"
#ifndef QT_NO_DBUS
QT_BEGIN_NAMESPACE
class QDBusConnectionPrivate;
class QDBusMessage;
// Really private structs used by qdbusintegrator.cpp
// Things that aren't used by any other file
struct QDBusSlotCache
{
struct Data
{
int slotIdx;
QList<QMetaType> metaTypes;
void swap(Data &other) noexcept
{
qSwap(slotIdx, other.slotIdx);
qSwap(metaTypes, other.metaTypes);
}
};
struct Key
{
QString memberWithSignature;
QDBusConnection::RegisterOptions flags;
friend bool operator==(const Key &lhs, const Key &rhs) noexcept
{
return lhs.memberWithSignature == rhs.memberWithSignature && lhs.flags == rhs.flags;
}
friend size_t qHash(const QDBusSlotCache::Key &key, size_t seed = 0) noexcept
{
return qHashMulti(seed, key.memberWithSignature, key.flags);
}
};
using Hash = QHash<Key, Data>;
Hash hash;
void swap(QDBusSlotCache &other) noexcept { qSwap(hash, other.hash); }
};
Q_DECLARE_SHARED(QDBusSlotCache::Data)
Q_DECLARE_SHARED(QDBusSlotCache)
class QDBusCallDeliveryEvent: public QAbstractMetaCallEvent
{
public:
QDBusCallDeliveryEvent(const QDBusConnection &c, int id, QObject *sender,
const QDBusMessage &msg, const QList<QMetaType> &types)
: QAbstractMetaCallEvent(sender, -1), connection(c), message(msg), metaTypes(types), id(id)
{
}
void placeMetaCall(QObject *object) override
{
QDBusConnectionPrivate::d(connection)->deliverCall(object, message, metaTypes, id);
}
private:
QDBusConnection connection; // just for refcounting
QDBusMessage message;
QList<QMetaType> metaTypes;
int id;
};
class QDBusActivateObjectEvent: public QAbstractMetaCallEvent
{
public:
QDBusActivateObjectEvent(const QDBusConnection &c, QObject *sender,
const QDBusConnectionPrivate::ObjectTreeNode &n,
int p, const QDBusMessage &m, QSemaphore *s = nullptr)
: QAbstractMetaCallEvent(sender, -1, s), connection(c), node(n),
pathStartPos(p), message(m), handled(false)
{ }
~QDBusActivateObjectEvent() override;
void placeMetaCall(QObject *) override;
private:
QDBusConnection connection; // just for refcounting
QDBusConnectionPrivate::ObjectTreeNode node;
int pathStartPos;
QDBusMessage message;
bool handled;
};
class QDBusSpyCallEvent : public QAbstractMetaCallEvent
{
public:
typedef void (*Hook)(const QDBusMessage&);
QDBusSpyCallEvent(QDBusConnectionPrivate *cp, const QDBusConnection &c, const QDBusMessage &msg)
: QAbstractMetaCallEvent(cp, 0), conn(c), msg(msg)
{}
~QDBusSpyCallEvent() override;
void placeMetaCall(QObject *) override;
static inline void invokeSpyHooks(const QDBusMessage &msg);
QDBusConnection conn; // keeps the refcount in QDBusConnectionPrivate up
QDBusMessage msg;
};
QT_END_NAMESPACE
QT_DECL_METATYPE_EXTERN(QDBusSlotCache, Q_DBUS_EXPORT)
#endif // QT_NO_DBUS
#endif
|
