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
|
// Copyright (C) 2022 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 QTCLASSHELPERMACROS_H
#define QTCLASSHELPERMACROS_H
#include <QtCore/qtconfigmacros.h>
#if 0
#pragma qt_class(QtClassHelperMacros)
#pragma qt_sync_stop_processing
#endif
QT_BEGIN_NAMESPACE
#if defined(__cplusplus)
/*
Some classes do not permit copies to be made of an object. These
classes contains a private copy constructor and assignment
operator to disable copying (the compiler gives an error message).
*/
#define Q_DISABLE_COPY(Class) \
Class(const Class &) = delete;\
Class &operator=(const Class &) = delete;
#define Q_DISABLE_COPY_MOVE(Class) \
Q_DISABLE_COPY(Class) \
Class(Class &&) = delete; \
Class &operator=(Class &&) = delete;
/*
Implementing a move assignment operator using an established
technique (move-and-swap, pure swap) is just boilerplate.
Here's a couple of *private* macros for convenience.
To know which one to use:
* if you don't have a move constructor (*) => use pure swap;
* if you have a move constructor, then
* if your class holds just memory (no file handles, no user-defined
datatypes, etc.) => use pure swap;
* use move and swap.
The preference should always go for the move-and-swap one, as it
will deterministically destroy the data previously held in *this,
and not "dump" it in the moved-from object (which may then be alive
for longer).
The requirement for either macro is the presence of a member swap(),
which any value class that defines its own special member functions
should have anyhow.
(*) Many value classes in Qt do not have move constructors; mostly,
the implicitly shared classes using QSharedDataPointer and friends.
The reason is mostly historical: those classes require either an
out-of-line move constructor, which we could not provide before we
made C++11 mandatory (and that we don't like anyhow), or
an out-of-line dtor for the Q(E)DSP<Private> member (cf. QPixmap).
If you can however add a move constructor to a class lacking it,
consider doing so, then reevaluate which macro to choose.
*/
#define QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(Class) \
Class &operator=(Class &&other) noexcept { \
Class moved(std::move(other)); \
swap(moved); \
return *this; \
}
#define QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(Class) \
Class &operator=(Class &&other) noexcept { \
swap(other); \
return *this; \
}
template <typename T> inline T *qGetPtrHelper(T *ptr) noexcept { return ptr; }
template <typename Ptr> inline auto qGetPtrHelper(Ptr &ptr) noexcept -> decltype(ptr.get())
{ static_assert(noexcept(ptr.get()), "Smart d pointers for Q_DECLARE_PRIVATE must have noexcept get()"); return ptr.get(); }
class QObject;
class QObjectPrivate;
namespace QtPrivate {
template <typename ObjPrivate> void assertObjectType(QObjectPrivate *d);
inline const QObject *getQObject(const QObjectPrivate *d);
}
#define Q_DECLARE_PRIVATE(Class) \
inline Class##Private* d_func() noexcept \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr));) } \
inline const Class##Private* d_func() const noexcept \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr));) } \
friend class Class##Private;
#define Q_DECLARE_PRIVATE_D(Dptr, Class) \
inline Class##Private* d_func() noexcept \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(Dptr));) } \
inline const Class##Private* d_func() const noexcept \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(Dptr));) } \
friend class Class##Private;
#define Q_DECLARE_PUBLIC(Class) \
inline Class* q_func() noexcept { return static_cast<Class *>(q_ptr); } \
inline const Class* q_func() const noexcept { return static_cast<const Class *>(q_ptr); } \
friend class Class; \
friend const QObject *QtPrivate::getQObject(const QObjectPrivate *d); \
template <typename ObjPrivate> friend void QtPrivate::assertObjectType(QObjectPrivate *d);
#define Q_D(Class) Class##Private * const d = d_func()
#define Q_Q(Class) Class * const q = q_func()
/*
Specialize a shared type with:
Q_DECLARE_SHARED(type)
where 'type' is the name of the type to specialize. NOTE: shared
types must define a member-swap, and be defined in the same
namespace as Qt for this to work.
*/
#define Q_DECLARE_SHARED(TYPE) \
Q_DECLARE_TYPEINFO(TYPE, Q_RELOCATABLE_TYPE); \
inline void swap(TYPE &value1, TYPE &value2) \
noexcept(noexcept(value1.swap(value2))) \
{ value1.swap(value2); }
#endif // __cplusplus
QT_END_NAMESPACE
#endif // QTCLASSHELPERMACROS_H
|
