1// Copyright (C) 2022 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#ifndef QTCLASSHELPERMACROS_H
5#define QTCLASSHELPERMACROS_H
6
7#include <QtCore/qtconfigmacros.h>
8
9#if 0
10#pragma qt_class(QtClassHelperMacros)
11#pragma qt_sync_stop_processing
12#endif
13
14QT_BEGIN_NAMESPACE
15
16#if defined(__cplusplus)
17
18/*
19 Some classes do not permit copies to be made of an object. These
20 classes contains a private copy constructor and assignment
21 operator to disable copying (the compiler gives an error message).
22*/
23#define Q_DISABLE_COPY(Class) \
24 Class(const Class &) = delete;\
25 Class &operator=(const Class &) = delete;
26
27#define Q_DISABLE_COPY_MOVE(Class) \
28 Q_DISABLE_COPY(Class) \
29 Class(Class &&) = delete; \
30 Class &operator=(Class &&) = delete;
31
32/*
33 Implementing a move assignment operator using an established
34 technique (move-and-swap, pure swap) is just boilerplate.
35 Here's a couple of *private* macros for convenience.
36
37 To know which one to use:
38
39 * if you don't have a move constructor (*) => use pure swap;
40 * if you have a move constructor, then
41 * if your class holds just memory (no file handles, no user-defined
42 datatypes, etc.) => use pure swap;
43 * use move and swap.
44
45 The preference should always go for the move-and-swap one, as it
46 will deterministically destroy the data previously held in *this,
47 and not "dump" it in the moved-from object (which may then be alive
48 for longer).
49
50 The requirement for either macro is the presence of a member swap(),
51 which any value class that defines its own special member functions
52 should have anyhow.
53
54 (*) Many value classes in Qt do not have move constructors; mostly,
55 the implicitly shared classes using QSharedDataPointer and friends.
56 The reason is mostly historical: those classes require either an
57 out-of-line move constructor, which we could not provide before we
58 made C++11 mandatory (and that we don't like anyhow), or
59 an out-of-line dtor for the Q(E)DSP<Private> member (cf. QPixmap).
60
61 If you can however add a move constructor to a class lacking it,
62 consider doing so, then reevaluate which macro to choose.
63*/
64#define QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(Class) \
65 Class &operator=(Class &&other) noexcept { \
66 Class moved(std::move(other)); \
67 swap(moved); \
68 return *this; \
69 }
70
71#define QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(Class) \
72 Class &operator=(Class &&other) noexcept { \
73 swap(other); \
74 return *this; \
75 }
76
77/*
78 These macros can be used to define tag structs in the preferred way (ie.
79 with explicit default ctor).
80
81 The _STRUCT version only defines the tag type, no variable, while the
82 normal macro defines also a variable (and appends _t to the type name to
83 distinguish the two).
84
85 E.g. if we were std, we could use
86
87 QT_DEFINE_TAG(nullopt); // nullopt of type nullopt_t
88
89 The variable will be constexpr by default. If you want to make it static,
90 or inline, or both, prepend those keywords:
91
92 static QT_DEFINE_TAG(MyTag); // static constexpr
93 static inline QT_DEFINE_TAG(MyTag); // static inline constexpr
94*/
95#define QT_DEFINE_TAG_STRUCT(TAG) \
96 struct TAG { explicit TAG () = default; }
97#define QT_DEFINE_TAG(TAG) \
98 constexpr QT_DEFINE_TAG_STRUCT(TAG ## _t) TAG{}
99
100
101template <typename T> inline T *qGetPtrHelper(T *ptr) noexcept { return ptr; }
102template <typename Ptr> inline auto qGetPtrHelper(Ptr &ptr) noexcept -> decltype(ptr.get())
103{ static_assert(noexcept(ptr.get()), "Smart d pointers for Q_DECLARE_PRIVATE must have noexcept get()"); return ptr.get(); }
104
105class QObject;
106class QObjectPrivate;
107namespace QtPrivate {
108 template <typename ObjPrivate> void assertObjectType(QObjectPrivate *d);
109 inline const QObject *getQObject(const QObjectPrivate *d);
110}
111
112#define Q_DECLARE_PRIVATE(Class) \
113 inline Class##Private* d_func() noexcept \
114 { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr));) } \
115 inline const Class##Private* d_func() const noexcept \
116 { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr));) } \
117 friend class Class##Private;
118
119#define Q_DECLARE_PRIVATE_D(Dptr, Class) \
120 inline Class##Private* d_func() noexcept \
121 { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(Dptr));) } \
122 inline const Class##Private* d_func() const noexcept \
123 { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(Dptr));) } \
124 friend class Class##Private;
125
126#define Q_DECLARE_PUBLIC(Class) \
127 inline Class* q_func() noexcept { return static_cast<Class *>(q_ptr); } \
128 inline const Class* q_func() const noexcept { return static_cast<const Class *>(q_ptr); } \
129 friend class Class; \
130 friend const QObject *QtPrivate::getQObject(const QObjectPrivate *d); \
131 template <typename ObjPrivate> friend void QtPrivate::assertObjectType(QObjectPrivate *d);
132
133#define Q_D(Class) Class##Private * const d = d_func()
134#define Q_Q(Class) Class * const q = q_func()
135
136/*
137 Specialize a shared type with:
138
139 Q_DECLARE_SHARED(type)
140
141 where 'type' is the name of the type to specialize. NOTE: shared
142 types must define a member-swap, and be defined in the same
143 namespace as Qt for this to work.
144
145 For types defined in a namespace within QT_NAMESPACE, use
146 Q_DECLARE_SHARED_NS/_EXT instead. The _NS macro needs to be placed
147 inside the nested namespace:
148
149 namespace ns {
150 // ~~~ type defined here ~~~
151 Q_DECLARE_SHARED_NS(ns, type)
152 }
153
154 while the _NS_EXT macro goes into the QT_NAMESPACE, outside any
155 nested namespaces:
156
157 namespace ns {
158 // ~~~ type defined here ~~~
159 }
160 Q_DECLARE_SHARED_NS_EXT(ns, type)
161
162 The latter then also works for more deeply-nested namespaces:
163
164 Q_DECLARE_SHARED_NS_EXT(ns1::ns2, type)
165
166 Q_DECLARE_SHARED_NS does, too, if all namespaces were opened in one statement:
167
168 namespace ns1::ns2 {
169 Q_DECLARE_SHARED_NS(ns1::ns2, type);
170 }
171*/
172
173#define Q_DECLARE_SHARED(TYPE) \
174QT_DECLARE_ADL_SWAP(TYPE) \
175Q_DECLARE_TYPEINFO(TYPE, Q_RELOCATABLE_TYPE); \
176/* end */
177
178#define Q_DECLARE_SHARED_NS(NS, TYPE) \
179QT_DECLARE_ADL_SWAP(TYPE) \
180} /* namespace NS */ \
181Q_DECLARE_TYPEINFO(NS :: TYPE, Q_RELOCATABLE_TYPE); \
182namespace NS { \
183/* end */
184
185#define Q_DECLARE_SHARED_NS_EXT(NS, TYPE) \
186namespace NS { \
187QT_DECLARE_ADL_SWAP(TYPE) \
188} /* namespace NS */ \
189Q_DECLARE_TYPEINFO(NS :: TYPE, Q_RELOCATABLE_TYPE); \
190/* end */
191
192#define QT_DECLARE_ADL_SWAP(TYPE) \
193inline void swap(TYPE &value1, TYPE &value2) \
194 noexcept(noexcept(value1.swap(value2))) \
195{ value1.swap(value2); }
196
197#endif // __cplusplus
198
199QT_END_NAMESPACE
200
201#endif // QTCLASSHELPERMACROS_H
202

Provided by KDAB

Privacy Policy
Learn Advanced QML with KDAB
Find out more

source code of qtbase/src/corelib/global/qtclasshelpermacros.h