1 | // Copyright (C) 2021 The Qt Company Ltd. |
---|---|
2 | // Copyright (C) 2018 Intel Corporation. |
3 | // Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com> |
4 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only |
5 | |
6 | #ifndef QMETATYPE_H |
7 | #define QMETATYPE_H |
8 | |
9 | #include <QtCore/qglobal.h> |
10 | #include <QtCore/qatomic.h> |
11 | #include <QtCore/qbytearray.h> |
12 | #include <QtCore/qcompare.h> |
13 | #include <QtCore/qdatastream.h> |
14 | #include <QtCore/qfloat16.h> |
15 | #include <QtCore/qhashfunctions.h> |
16 | #include <QtCore/qiterable.h> |
17 | #ifndef QT_NO_QOBJECT |
18 | #include <QtCore/qobjectdefs.h> |
19 | #endif |
20 | #include <QtCore/qscopeguard.h> |
21 | #include <QtCore/qttypetraits.h> |
22 | |
23 | #include <array> |
24 | #include <new> |
25 | #include <vector> |
26 | #include <list> |
27 | #include <map> |
28 | #include <functional> |
29 | #include <optional> |
30 | #include <QtCore/q20type_traits.h> |
31 | |
32 | #ifdef Bool |
33 | #error qmetatype.h must be included before any header file that defines Bool |
34 | #endif |
35 | |
36 | QT_BEGIN_NAMESPACE |
37 | |
38 | // from qcborcommon.h |
39 | enum class QCborSimpleType : quint8; |
40 | |
41 | template <typename T> |
42 | struct QMetaTypeId2; |
43 | |
44 | template <typename T> |
45 | inline constexpr int qMetaTypeId(); |
46 | |
47 | // F is a tuple: (QMetaType::TypeName, QMetaType::TypeNameID, RealType) |
48 | #define QT_FOR_EACH_STATIC_PRIMITIVE_NON_VOID_TYPE(F)\ |
49 | F(Bool, 1, bool) \ |
50 | F(Int, 2, int) \ |
51 | F(UInt, 3, uint) \ |
52 | F(LongLong, 4, qlonglong) \ |
53 | F(ULongLong, 5, qulonglong) \ |
54 | F(Double, 6, double) \ |
55 | F(Long, 32, long) \ |
56 | F(Short, 33, short) \ |
57 | F(Char, 34, char) \ |
58 | F(Char16, 56, char16_t) \ |
59 | F(Char32, 57, char32_t) \ |
60 | F(ULong, 35, ulong) \ |
61 | F(UShort, 36, ushort) \ |
62 | F(UChar, 37, uchar) \ |
63 | F(Float, 38, float) \ |
64 | F(SChar, 40, signed char) \ |
65 | F(Nullptr, 51, std::nullptr_t) \ |
66 | F(QCborSimpleType, 52, QCborSimpleType) \ |
67 | |
68 | #define QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F) \ |
69 | QT_FOR_EACH_STATIC_PRIMITIVE_NON_VOID_TYPE(F) \ |
70 | F(Void, 43, void) \ |
71 | |
72 | #define QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(F) \ |
73 | F(VoidStar, 31, void*) \ |
74 | |
75 | #if QT_CONFIG(easingcurve) |
76 | #define QT_FOR_EACH_STATIC_EASINGCURVE(F)\ |
77 | F(QEasingCurve, 29, QEasingCurve) |
78 | #else |
79 | #define QT_FOR_EACH_STATIC_EASINGCURVE(F) |
80 | #endif |
81 | |
82 | #if QT_CONFIG(itemmodel) |
83 | #define QT_FOR_EACH_STATIC_ITEMMODEL_CLASS(F)\ |
84 | F(QModelIndex, 42, QModelIndex) \ |
85 | F(QPersistentModelIndex, 50, QPersistentModelIndex) |
86 | #else |
87 | #define QT_FOR_EACH_STATIC_ITEMMODEL_CLASS(F) |
88 | #endif |
89 | |
90 | #if QT_CONFIG(regularexpression) |
91 | # define QT_FOR_EACH_STATIC_REGULAR_EXPRESSION(F) \ |
92 | F(QRegularExpression, 44, QRegularExpression) |
93 | #else |
94 | # define QT_FOR_EACH_STATIC_REGULAR_EXPRESSION(F) |
95 | #endif |
96 | #ifndef QT_NO_VARIANT |
97 | # define QT_FOR_EACH_STATIC_QVARIANT(F) \ |
98 | F(QVariant, 41, QVariant) |
99 | #else |
100 | # define QT_FOR_EACH_STATIC_QVARIANT(F) |
101 | #endif |
102 | |
103 | #define QT_FOR_EACH_STATIC_CORE_CLASS(F)\ |
104 | F(QChar, 7, QChar) \ |
105 | F(QString, 10, QString) \ |
106 | F(QByteArray, 12, QByteArray) \ |
107 | F(QBitArray, 13, QBitArray) \ |
108 | F(QDate, 14, QDate) \ |
109 | F(QTime, 15, QTime) \ |
110 | F(QDateTime, 16, QDateTime) \ |
111 | F(QUrl, 17, QUrl) \ |
112 | F(QLocale, 18, QLocale) \ |
113 | F(QRect, 19, QRect) \ |
114 | F(QRectF, 20, QRectF) \ |
115 | F(QSize, 21, QSize) \ |
116 | F(QSizeF, 22, QSizeF) \ |
117 | F(QLine, 23, QLine) \ |
118 | F(QLineF, 24, QLineF) \ |
119 | F(QPoint, 25, QPoint) \ |
120 | F(QPointF, 26, QPointF) \ |
121 | QT_FOR_EACH_STATIC_EASINGCURVE(F) \ |
122 | F(QUuid, 30, QUuid) \ |
123 | QT_FOR_EACH_STATIC_QVARIANT(F) \ |
124 | QT_FOR_EACH_STATIC_REGULAR_EXPRESSION(F) \ |
125 | F(QJsonValue, 45, QJsonValue) \ |
126 | F(QJsonObject, 46, QJsonObject) \ |
127 | F(QJsonArray, 47, QJsonArray) \ |
128 | F(QJsonDocument, 48, QJsonDocument) \ |
129 | F(QCborValue, 53, QCborValue) \ |
130 | F(QCborArray, 54, QCborArray) \ |
131 | F(QCborMap, 55, QCborMap) \ |
132 | F(Float16, 63, qfloat16) \ |
133 | QT_FOR_EACH_STATIC_ITEMMODEL_CLASS(F) |
134 | |
135 | #define QT_FOR_EACH_STATIC_CORE_POINTER(F)\ |
136 | F(QObjectStar, 39, QObject*) |
137 | |
138 | #ifndef QT_NO_VARIANT |
139 | # define QT_FOR_EACH_STATIC_CORE_QVARIANT_TEMPLATE(F) \ |
140 | F(QVariantMap, 8, QVariantMap) \ |
141 | F(QVariantList, 9, QVariantList) \ |
142 | F(QVariantHash, 28, QVariantHash) \ |
143 | F(QVariantPair, 58, QVariantPair) \ |
144 | /**/ |
145 | #else |
146 | # define QT_FOR_EACH_STATIC_CORE_QVARIANT_TEMPLATE(F) |
147 | #endif // QT_NO_VARIANT |
148 | |
149 | #define QT_FOR_EACH_STATIC_CORE_TEMPLATE(F) \ |
150 | QT_FOR_EACH_STATIC_CORE_QVARIANT_TEMPLATE(F) \ |
151 | F(QByteArrayList, 49, QByteArrayList) \ |
152 | F(QStringList, 11, QStringList) |
153 | |
154 | #if QT_CONFIG(shortcut) |
155 | #define QT_FOR_EACH_STATIC_KEYSEQUENCE_CLASS(F)\ |
156 | F(QKeySequence, 0x100b, QKeySequence) |
157 | #else |
158 | #define QT_FOR_EACH_STATIC_KEYSEQUENCE_CLASS(F) |
159 | #endif |
160 | |
161 | #define QT_FOR_EACH_STATIC_GUI_CLASS(F)\ |
162 | F(QFont, 0x1000, QFont) \ |
163 | F(QPixmap, 0x1001, QPixmap) \ |
164 | F(QBrush, 0x1002, QBrush) \ |
165 | F(QColor, 0x1003, QColor) \ |
166 | F(QPalette, 0x1004, QPalette) \ |
167 | F(QIcon, 0x1005, QIcon) \ |
168 | F(QImage, 0x1006, QImage) \ |
169 | F(QPolygon, 0x1007, QPolygon) \ |
170 | F(QRegion, 0x1008, QRegion) \ |
171 | F(QBitmap, 0x1009, QBitmap) \ |
172 | F(QCursor, 0x100a, QCursor) \ |
173 | QT_FOR_EACH_STATIC_KEYSEQUENCE_CLASS(F) \ |
174 | F(QPen, 0x100c, QPen) \ |
175 | F(QTextLength, 0x100d, QTextLength) \ |
176 | F(QTextFormat, 0x100e, QTextFormat) \ |
177 | F(QTransform, 0x1010, QTransform) \ |
178 | F(QMatrix4x4, 0x1011, QMatrix4x4) \ |
179 | F(QVector2D, 0x1012, QVector2D) \ |
180 | F(QVector3D, 0x1013, QVector3D) \ |
181 | F(QVector4D, 0x1014, QVector4D) \ |
182 | F(QQuaternion, 0x1015, QQuaternion) \ |
183 | F(QPolygonF, 0x1016, QPolygonF) \ |
184 | F(QColorSpace, 0x1017, QColorSpace) \ |
185 | |
186 | |
187 | #define QT_FOR_EACH_STATIC_WIDGETS_CLASS(F)\ |
188 | F(QSizePolicy, 0x2000, QSizePolicy) \ |
189 | |
190 | // F is a tuple: (QMetaType::TypeName, QMetaType::TypeNameID, AliasingType, "RealType") |
191 | #define QT_FOR_EACH_STATIC_ALIAS_TYPE(F)\ |
192 | F(ULong, -1, ulong, "unsigned long") \ |
193 | F(UInt, -1, uint, "unsigned int") \ |
194 | F(UShort, -1, ushort, "unsigned short") \ |
195 | F(UChar, -1, uchar, "unsigned char") \ |
196 | F(LongLong, -1, qlonglong, "long long") \ |
197 | F(ULongLong, -1, qulonglong, "unsigned long long") \ |
198 | F(SChar, -1, signed char, "qint8") \ |
199 | F(UChar, -1, uchar, "quint8") \ |
200 | F(Short, -1, short, "qint16") \ |
201 | F(UShort, -1, ushort, "quint16") \ |
202 | F(Int, -1, int, "qint32") \ |
203 | F(UInt, -1, uint, "quint32") \ |
204 | F(LongLong, -1, qlonglong, "qint64") \ |
205 | F(ULongLong, -1, qulonglong, "quint64") \ |
206 | F(QByteArrayList, -1, QByteArrayList, "QList<QByteArray>") \ |
207 | F(QStringList, -1, QStringList, "QList<QString>") \ |
208 | QT_FOR_EACH_STATIC_VARIANT_ALIAS_TYPE(F) |
209 | |
210 | #ifndef QT_NO_VARIANT |
211 | #define QT_FOR_EACH_STATIC_VARIANT_ALIAS_TYPE(F) \ |
212 | F(QVariantList, -1, QVariantList, "QList<QVariant>") \ |
213 | F(QVariantMap, -1, QVariantMap, "QMap<QString,QVariant>") \ |
214 | F(QVariantHash, -1, QVariantHash, "QHash<QString,QVariant>") \ |
215 | F(QVariantPair, -1, QVariantPair, "QPair<QVariant,QVariant>") \ |
216 | /**/ |
217 | #else |
218 | #define QT_FOR_EACH_STATIC_VARIANT_ALIAS_TYPE(F) |
219 | #endif |
220 | |
221 | #define QT_FOR_EACH_STATIC_TYPE(F)\ |
222 | QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F)\ |
223 | QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(F)\ |
224 | QT_FOR_EACH_STATIC_CORE_CLASS(F)\ |
225 | QT_FOR_EACH_STATIC_CORE_POINTER(F)\ |
226 | QT_FOR_EACH_STATIC_CORE_TEMPLATE(F)\ |
227 | QT_FOR_EACH_STATIC_GUI_CLASS(F)\ |
228 | QT_FOR_EACH_STATIC_WIDGETS_CLASS(F)\ |
229 | |
230 | #define QT_DEFINE_METATYPE_ID(TypeName, Id, Name) \ |
231 | TypeName = Id, |
232 | |
233 | #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(F) \ |
234 | F(QList) \ |
235 | F(QQueue) \ |
236 | F(QStack) \ |
237 | F(QSet) \ |
238 | /*end*/ |
239 | |
240 | #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_2ARG(F) \ |
241 | F(QHash, class) \ |
242 | F(QMap, class) |
243 | |
244 | #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(F) \ |
245 | F(QSharedPointer) \ |
246 | F(QWeakPointer) \ |
247 | F(QPointer) |
248 | |
249 | class QDataStream; |
250 | struct QMetaObject; |
251 | |
252 | namespace QtPrivate |
253 | { |
254 | |
255 | class QMetaTypeInterface; |
256 | |
257 | // MSVC is the only supported compiler that includes the type of a variable in |
258 | // its mangled form, so it's not binary-compatible to drop the const in |
259 | // QMetaTypeInterfaceWrapper::metaType for it, which means we must keep the |
260 | // mutable field until Qt 7. |
261 | #if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0) || defined(QT_BOOTSTRAPPED) || !defined(Q_CC_MSVC) |
262 | # define QMTI_MUTABLE |
263 | using NonConstMetaTypeInterface = QMetaTypeInterface; |
264 | #else |
265 | # define QMTI_MUTABLE mutable |
266 | using NonConstMetaTypeInterface = const QMetaTypeInterface; |
267 | #endif |
268 | |
269 | class QMetaTypeInterface |
270 | { |
271 | public: |
272 | |
273 | /* Revision: Can increase if new field are added, or if semantics changes |
274 | 0: Initial Revision |
275 | 1: the meaning of the NeedsDestruction flag changed |
276 | */ |
277 | static inline constexpr ushort CurrentRevision = 1; |
278 | |
279 | ushort revision; |
280 | ushort alignment; |
281 | uint size; |
282 | uint flags; |
283 | QMTI_MUTABLE QBasicAtomicInt typeId; |
284 | |
285 | using MetaObjectFn = const QMetaObject *(*)(const QMetaTypeInterface *); |
286 | MetaObjectFn metaObjectFn; |
287 | |
288 | const char *name; |
289 | |
290 | using DefaultCtrFn = void (*)(const QMetaTypeInterface *, void *); |
291 | DefaultCtrFn defaultCtr; |
292 | using CopyCtrFn = void (*)(const QMetaTypeInterface *, void *, const void *); |
293 | CopyCtrFn copyCtr; |
294 | using MoveCtrFn = void (*)(const QMetaTypeInterface *, void *, void *); |
295 | MoveCtrFn moveCtr; |
296 | using DtorFn = void (*)(const QMetaTypeInterface *, void *); |
297 | DtorFn dtor; |
298 | using EqualsFn = bool (*)(const QMetaTypeInterface *, const void *, const void *); |
299 | EqualsFn equals; |
300 | using LessThanFn = bool (*)(const QMetaTypeInterface *, const void *, const void *); |
301 | LessThanFn lessThan; |
302 | using DebugStreamFn = void (*)(const QMetaTypeInterface *, QDebug &, const void *); |
303 | DebugStreamFn debugStream; |
304 | using DataStreamOutFn = void (*)(const QMetaTypeInterface *, QDataStream &, const void *); |
305 | DataStreamOutFn dataStreamOut; |
306 | using DataStreamInFn = void (*)(const QMetaTypeInterface *, QDataStream &, void *); |
307 | DataStreamInFn dataStreamIn; |
308 | |
309 | using LegacyRegisterOp = void (*)(); |
310 | LegacyRegisterOp legacyRegisterOp; |
311 | }; |
312 | #undef QMTI_MUTABLE |
313 | |
314 | /*! |
315 | This template is used for implicit conversion from type From to type To. |
316 | \internal |
317 | */ |
318 | template<typename From, typename To> |
319 | To convertImplicit(const From& from) |
320 | { |
321 | return from; |
322 | } |
323 | |
324 | template<typename T, bool> |
325 | struct SequentialValueTypeIsMetaType; |
326 | template<typename T, bool> |
327 | struct AssociativeValueTypeIsMetaType; |
328 | template<typename T, bool> |
329 | struct IsMetaTypePair; |
330 | template<typename, typename> |
331 | struct MetaTypeSmartPointerHelper; |
332 | |
333 | template<typename T> |
334 | struct IsQFlags : std::false_type {}; |
335 | |
336 | template<typename Enum> |
337 | struct IsQFlags<QFlags<Enum>> : std::true_type {}; |
338 | |
339 | template<typename T> |
340 | struct IsEnumOrFlags : std::disjunction<std::is_enum<T>, IsQFlags<T>> {}; |
341 | } // namespace QtPrivate |
342 | |
343 | class Q_CORE_EXPORT QMetaType { |
344 | public: |
345 | #ifndef Q_QDOC |
346 | // The code that actually gets compiled. |
347 | enum Type { |
348 | // these are merged with QVariant |
349 | QT_FOR_EACH_STATIC_TYPE(QT_DEFINE_METATYPE_ID) |
350 | |
351 | FirstCoreType = Bool, |
352 | LastCoreType = Float16, |
353 | FirstGuiType = QFont, |
354 | LastGuiType = QColorSpace, |
355 | FirstWidgetsType = QSizePolicy, |
356 | LastWidgetsType = QSizePolicy, |
357 | HighestInternalId = LastWidgetsType, |
358 | |
359 | QReal = sizeof(qreal) == sizeof(double) ? Double : Float, |
360 | |
361 | UnknownType = 0, |
362 | User = 65536 |
363 | }; |
364 | #else |
365 | // If we are using QDoc it fakes the Type enum looks like this. |
366 | enum Type { |
367 | UnknownType = 0, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, |
368 | Double = 6, Long = 32, Short = 33, Char = 34, ULong = 35, UShort = 36, |
369 | UChar = 37, Float = 38, |
370 | VoidStar = 31, |
371 | QChar = 7, QString = 10, QStringList = 11, QByteArray = 12, |
372 | QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17, |
373 | QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22, |
374 | QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, |
375 | QEasingCurve = 29, QUuid = 30, QVariant = 41, QModelIndex = 42, |
376 | QPersistentModelIndex = 50, QRegularExpression = 44, |
377 | QJsonValue = 45, QJsonObject = 46, QJsonArray = 47, QJsonDocument = 48, |
378 | QByteArrayList = 49, QObjectStar = 39, SChar = 40, |
379 | Void = 43, |
380 | Nullptr = 51, |
381 | QVariantMap = 8, QVariantList = 9, QVariantHash = 28, QVariantPair = 58, |
382 | QCborSimpleType = 52, QCborValue = 53, QCborArray = 54, QCborMap = 55, |
383 | Char16 = 56, Char32 = 57, |
384 | Int128 = 59, UInt128 = 60, Float128 = 61, BFloat16 = 62, Float16 = 63, |
385 | |
386 | // Gui types |
387 | QFont = 0x1000, QPixmap = 0x1001, QBrush = 0x1002, QColor = 0x1003, QPalette = 0x1004, |
388 | QIcon = 0x1005, QImage = 0x1006, QPolygon = 0x1007, QRegion = 0x1008, QBitmap = 0x1009, |
389 | QCursor = 0x100a, QKeySequence = 0x100b, QPen = 0x100c, QTextLength = 0x100d, QTextFormat = 0x100e, |
390 | QTransform = 0x1010, QMatrix4x4 = 0x1011, QVector2D = 0x1012, |
391 | QVector3D = 0x1013, QVector4D = 0x1014, QQuaternion = 0x1015, QPolygonF = 0x1016, QColorSpace = 0x1017, |
392 | |
393 | // Widget types |
394 | QSizePolicy = 0x2000, |
395 | |
396 | // Start-point for client-code types: |
397 | User = 65536 |
398 | }; |
399 | #endif |
400 | |
401 | enum TypeFlag { |
402 | NeedsConstruction = 0x1, |
403 | NeedsDestruction = 0x2, |
404 | RelocatableType = 0x4, |
405 | #if QT_DEPRECATED_SINCE(6, 0) |
406 | MovableType Q_DECL_ENUMERATOR_DEPRECATED_X("Use RelocatableType instead.") = RelocatableType, |
407 | #endif |
408 | PointerToQObject = 0x8, |
409 | IsEnumeration = 0x10, |
410 | SharedPointerToQObject = 0x20, |
411 | WeakPointerToQObject = 0x40, |
412 | TrackingPointerToQObject = 0x80, |
413 | IsUnsignedEnumeration = 0x100, |
414 | IsGadget = 0x200, |
415 | PointerToGadget = 0x400, |
416 | IsPointer = 0x800, |
417 | IsQmlList =0x1000, // used in the QML engine to recognize QQmlListProperty<T> and list<T> |
418 | IsConst = 0x2000, |
419 | // since 6.5: |
420 | NeedsCopyConstruction = 0x4000, |
421 | NeedsMoveConstruction = 0x8000, |
422 | }; |
423 | Q_DECLARE_FLAGS(TypeFlags, TypeFlag) |
424 | |
425 | static void registerNormalizedTypedef(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName, QMetaType type); |
426 | |
427 | #if QT_DEPRECATED_SINCE(6, 0) |
428 | QT_DEPRECATED_VERSION_6_0 |
429 | static int type(const char *typeName) |
430 | { return QMetaType::fromName(name: typeName).id(); } |
431 | QT_DEPRECATED_VERSION_6_0 |
432 | static int type(const QT_PREPEND_NAMESPACE(QByteArray) &typeName) |
433 | { return QMetaType::fromName(name: typeName).id(); } |
434 | QT_DEPRECATED_VERSION_6_0 |
435 | static const char *typeName(int type) |
436 | { return QMetaType(type).name(); } |
437 | QT_DEPRECATED_VERSION_6_0 |
438 | static int sizeOf(int type) |
439 | { return int(QMetaType(type).sizeOf()); } |
440 | QT_DEPRECATED_VERSION_6_0 |
441 | static TypeFlags typeFlags(int type) |
442 | { return QMetaType(type).flags(); } |
443 | QT_DEPRECATED_VERSION_6_0 |
444 | static const QMetaObject *metaObjectForType(int type) |
445 | { return QMetaType(type).metaObject(); } |
446 | QT_DEPRECATED_VERSION_6_0 |
447 | static void *create(int type, const void *copy = nullptr) |
448 | { return QMetaType(type).create(copy); } |
449 | QT_DEPRECATED_VERSION_6_0 |
450 | static void destroy(int type, void *data) |
451 | { return QMetaType(type).destroy(data); } |
452 | QT_DEPRECATED_VERSION_6_0 |
453 | static void *construct(int type, void *where, const void *copy) |
454 | { return QMetaType(type).construct(where, copy); } |
455 | QT_DEPRECATED_VERSION_6_0 |
456 | static void destruct(int type, void *where) |
457 | { return QMetaType(type).destruct(data: where); } |
458 | #endif |
459 | static bool isRegistered(int type); |
460 | |
461 | explicit QMetaType(int type); |
462 | explicit constexpr QMetaType(const QtPrivate::QMetaTypeInterface *d) : d_ptr(d) {} |
463 | constexpr QMetaType() = default; |
464 | |
465 | bool isValid() const; |
466 | bool isRegistered() const; |
467 | void registerType() const |
468 | { |
469 | // "register" is a reserved keyword |
470 | registerHelper(); |
471 | } |
472 | #if QT_CORE_REMOVED_SINCE(6, 1) || defined(Q_QDOC) |
473 | int id() const; |
474 | #else |
475 | // ### Qt 7: Remove traces of out of line version |
476 | // unused int parameter is used to avoid ODR violation |
477 | int id(int = 0) const |
478 | { |
479 | // keep in sync with the version in removed_api.cpp |
480 | return registerHelper(); |
481 | } |
482 | #endif |
483 | constexpr qsizetype sizeOf() const; |
484 | constexpr qsizetype alignOf() const; |
485 | constexpr TypeFlags flags() const; |
486 | constexpr const QMetaObject *metaObject() const; |
487 | constexpr const char *name() const; |
488 | |
489 | void *create(const void *copy = nullptr) const; |
490 | void destroy(void *data) const; |
491 | void *construct(void *where, const void *copy = nullptr) const; |
492 | void destruct(void *data) const; |
493 | QPartialOrdering compare(const void *lhs, const void *rhs) const; |
494 | bool equals(const void *lhs, const void *rhs) const; |
495 | |
496 | bool isDefaultConstructible() const noexcept { return d_ptr && isDefaultConstructible(d_ptr); } |
497 | bool isCopyConstructible() const noexcept { return d_ptr && isCopyConstructible(d_ptr); } |
498 | bool isMoveConstructible() const noexcept { return d_ptr && isMoveConstructible(d_ptr); } |
499 | bool isDestructible() const noexcept { return d_ptr && isDestructible(d_ptr); } |
500 | bool isEqualityComparable() const; |
501 | bool isOrdered() const; |
502 | |
503 | #ifndef QT_NO_DATASTREAM |
504 | bool save(QDataStream &stream, const void *data) const; |
505 | bool load(QDataStream &stream, void *data) const; |
506 | bool hasRegisteredDataStreamOperators() const; |
507 | |
508 | #if QT_DEPRECATED_SINCE(6, 0) |
509 | QT_DEPRECATED_VERSION_6_0 |
510 | static bool save(QDataStream &stream, int type, const void *data) |
511 | { return QMetaType(type).save(stream, data); } |
512 | QT_DEPRECATED_VERSION_6_0 |
513 | static bool load(QDataStream &stream, int type, void *data) |
514 | { return QMetaType(type).load(stream, data); } |
515 | #endif |
516 | #endif |
517 | |
518 | QMetaType underlyingType() const; |
519 | |
520 | template<typename T> |
521 | constexpr static QMetaType fromType(); |
522 | static QMetaType fromName(QByteArrayView name); |
523 | private: |
524 | friend bool comparesEqual(const QMetaType &lhs, |
525 | const QMetaType &rhs) |
526 | { |
527 | if (lhs.d_ptr == rhs.d_ptr) |
528 | return true; |
529 | if (!lhs.d_ptr || !rhs.d_ptr) |
530 | return false; // one type is undefined, the other is defined |
531 | // avoid id call if we already have the id |
532 | const int aId = lhs.id(); |
533 | const int bId = rhs.id(); |
534 | return aId == bId; |
535 | } |
536 | Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(QMetaType) |
537 | #ifndef QT_NO_DEBUG_STREAM |
538 | private: |
539 | friend Q_CORE_EXPORT QDebug operator<<(QDebug d, QMetaType m); |
540 | public: |
541 | bool debugStream(QDebug& dbg, const void *rhs); |
542 | bool hasRegisteredDebugStreamOperator() const; |
543 | |
544 | #if QT_DEPRECATED_SINCE(6, 0) |
545 | QT_DEPRECATED_VERSION_6_0 |
546 | static bool debugStream(QDebug& dbg, const void *rhs, int typeId) |
547 | { return QMetaType(typeId).debugStream(dbg, rhs); } |
548 | template<typename T> |
549 | QT_DEPRECATED_VERSION_6_0 |
550 | static bool hasRegisteredDebugStreamOperator() |
551 | { return QMetaType::fromType<T>().hasRegisteredDebugStreamOperator(); } |
552 | QT_DEPRECATED_VERSION_6_0 |
553 | static bool hasRegisteredDebugStreamOperator(int typeId) |
554 | { return QMetaType(typeId).hasRegisteredDebugStreamOperator(); } |
555 | #endif |
556 | #endif |
557 | |
558 | // type erased converter function |
559 | using ConverterFunction = std::function<bool(const void *src, void *target)>; |
560 | |
561 | // type erased mutable view, primarily for containers |
562 | using MutableViewFunction = std::function<bool(void *src, void *target)>; |
563 | |
564 | // implicit conversion supported like double -> float |
565 | template<typename From, typename To> |
566 | static bool registerConverter() |
567 | { |
568 | return registerConverter<From, To>(QtPrivate::convertImplicit<From, To>); |
569 | } |
570 | |
571 | // member function as in "QString QFont::toString() const" |
572 | template<typename From, typename To> |
573 | static bool registerConverter(To(From::*function)() const) |
574 | { |
575 | static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn), |
576 | "QMetaType::registerConverter: At least one of the types must be a custom type."); |
577 | |
578 | const QMetaType fromType = QMetaType::fromType<From>(); |
579 | const QMetaType toType = QMetaType::fromType<To>(); |
580 | auto converter = [function](const void *from, void *to) -> bool { |
581 | const From *f = static_cast<const From *>(from); |
582 | To *t = static_cast<To *>(to); |
583 | *t = (f->*function)(); |
584 | return true; |
585 | }; |
586 | return registerConverterImpl<From, To>(converter, fromType, toType); |
587 | } |
588 | |
589 | // member function |
590 | template<typename From, typename To> |
591 | static bool registerMutableView(To(From::*function)()) |
592 | { |
593 | static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn), |
594 | "QMetaType::registerMutableView: At least one of the types must be a custom type."); |
595 | |
596 | const QMetaType fromType = QMetaType::fromType<From>(); |
597 | const QMetaType toType = QMetaType::fromType<To>(); |
598 | auto view = [function](void *from, void *to) -> bool { |
599 | From *f = static_cast<From *>(from); |
600 | To *t = static_cast<To *>(to); |
601 | *t = (f->*function)(); |
602 | return true; |
603 | }; |
604 | return registerMutableViewImpl<From, To>(view, fromType, toType); |
605 | } |
606 | |
607 | // member function as in "double QString::toDouble(bool *ok = nullptr) const" |
608 | template<typename From, typename To> |
609 | static bool registerConverter(To(From::*function)(bool*) const) |
610 | { |
611 | static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn), |
612 | "QMetaType::registerConverter: At least one of the types must be a custom type."); |
613 | |
614 | const QMetaType fromType = QMetaType::fromType<From>(); |
615 | const QMetaType toType = QMetaType::fromType<To>(); |
616 | auto converter = [function](const void *from, void *to) -> bool { |
617 | const From *f = static_cast<const From *>(from); |
618 | To *t = static_cast<To *>(to); |
619 | bool result = true; |
620 | *t = (f->*function)(&result); |
621 | if (!result) |
622 | *t = To(); |
623 | return result; |
624 | }; |
625 | return registerConverterImpl<From, To>(converter, fromType, toType); |
626 | } |
627 | |
628 | // functor or function pointer |
629 | template<typename From, typename To, typename UnaryFunction> |
630 | static bool registerConverter(UnaryFunction function) |
631 | { |
632 | static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn), |
633 | "QMetaType::registerConverter: At least one of the types must be a custom type."); |
634 | |
635 | const QMetaType fromType = QMetaType::fromType<From>(); |
636 | const QMetaType toType = QMetaType::fromType<To>(); |
637 | auto converter = [function = std::move(function)](const void *from, void *to) -> bool { |
638 | const From *f = static_cast<const From *>(from); |
639 | To *t = static_cast<To *>(to); |
640 | auto &&r = function(*f); |
641 | if constexpr (std::is_same_v<q20::remove_cvref_t<decltype(r)>, std::optional<To>>) { |
642 | if (!r) |
643 | return false; |
644 | *t = *std::forward<decltype(r)>(r); |
645 | } else { |
646 | *t = std::forward<decltype(r)>(r); |
647 | } |
648 | return true; |
649 | }; |
650 | return registerConverterImpl<From, To>(std::move(converter), fromType, toType); |
651 | } |
652 | |
653 | // functor or function pointer |
654 | template<typename From, typename To, typename UnaryFunction> |
655 | static bool registerMutableView(UnaryFunction function) |
656 | { |
657 | static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn), |
658 | "QMetaType::registerMutableView: At least one of the types must be a custom type."); |
659 | |
660 | const QMetaType fromType = QMetaType::fromType<From>(); |
661 | const QMetaType toType = QMetaType::fromType<To>(); |
662 | auto view = [function = std::move(function)](void *from, void *to) -> bool { |
663 | From *f = static_cast<From *>(from); |
664 | To *t = static_cast<To *>(to); |
665 | *t = function(*f); |
666 | return true; |
667 | }; |
668 | return registerMutableViewImpl<From, To>(std::move(view), fromType, toType); |
669 | } |
670 | |
671 | private: |
672 | template<typename From, typename To> |
673 | static bool registerConverterImpl(ConverterFunction converter, QMetaType fromType, QMetaType toType) |
674 | { |
675 | if (registerConverterFunction(f: std::move(converter), from: fromType, to: toType)) { |
676 | static const auto unregister = qScopeGuard([=] { |
677 | unregisterConverterFunction(from: fromType, to: toType); |
678 | }); |
679 | return true; |
680 | } else { |
681 | return false; |
682 | } |
683 | } |
684 | |
685 | template<typename From, typename To> |
686 | static bool registerMutableViewImpl(MutableViewFunction view, QMetaType fromType, QMetaType toType) |
687 | { |
688 | if (registerMutableViewFunction(f: std::move(view), from: fromType, to: toType)) { |
689 | static const auto unregister = qScopeGuard([=] { |
690 | unregisterMutableViewFunction(from: fromType, to: toType); |
691 | }); |
692 | return true; |
693 | } else { |
694 | return false; |
695 | } |
696 | } |
697 | public: |
698 | |
699 | static bool convert(QMetaType fromType, const void *from, QMetaType toType, void *to); |
700 | static bool canConvert(QMetaType fromType, QMetaType toType); |
701 | |
702 | static bool view(QMetaType fromType, void *from, QMetaType toType, void *to); |
703 | static bool canView(QMetaType fromType, QMetaType toType); |
704 | #if QT_DEPRECATED_SINCE(6, 0) |
705 | QT_DEPRECATED_VERSION_6_0 |
706 | static bool convert(const void *from, int fromTypeId, void *to, int toTypeId) |
707 | { return convert(fromType: QMetaType(fromTypeId), from, toType: QMetaType(toTypeId), to); } |
708 | QT_DEPRECATED_VERSION_6_0 |
709 | static bool compare(const void *lhs, const void *rhs, int typeId, int *result) |
710 | { |
711 | QMetaType t(typeId); |
712 | auto c = t.compare(lhs, rhs); |
713 | if (c == QPartialOrdering::Unordered) { |
714 | *result = 0; |
715 | return false; |
716 | } else if (c == QPartialOrdering::Less) { |
717 | *result = -1; |
718 | return true; |
719 | } else if (c == QPartialOrdering::Equivalent) { |
720 | *result = 0; |
721 | return true; |
722 | } else { |
723 | *result = 1; |
724 | return true; |
725 | } |
726 | } |
727 | QT_DEPRECATED_VERSION_6_0 |
728 | static bool equals(const void *lhs, const void *rhs, int typeId, int *result) |
729 | { |
730 | QMetaType t(typeId); |
731 | if (!t.isEqualityComparable()) |
732 | return false; |
733 | *result = t.equals(lhs, rhs) ? 0 : -1; |
734 | return true; |
735 | } |
736 | #endif |
737 | |
738 | template<typename From, typename To> |
739 | static bool hasRegisteredConverterFunction() |
740 | { |
741 | return hasRegisteredConverterFunction( |
742 | QMetaType::fromType<From>(), QMetaType::fromType<To>()); |
743 | } |
744 | |
745 | static bool hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType); |
746 | |
747 | template<typename From, typename To> |
748 | static bool hasRegisteredMutableViewFunction() |
749 | { |
750 | return hasRegisteredMutableViewFunction( |
751 | QMetaType::fromType<From>(), QMetaType::fromType<To>()); |
752 | } |
753 | |
754 | static bool hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType); |
755 | |
756 | #ifndef Q_QDOC |
757 | template<typename, bool> friend struct QtPrivate::SequentialValueTypeIsMetaType; |
758 | template<typename, bool> friend struct QtPrivate::AssociativeValueTypeIsMetaType; |
759 | template<typename, bool> friend struct QtPrivate::IsMetaTypePair; |
760 | template<typename, typename> friend struct QtPrivate::MetaTypeSmartPointerHelper; |
761 | #endif |
762 | static bool registerConverterFunction(const ConverterFunction &f, QMetaType from, QMetaType to); |
763 | static void unregisterConverterFunction(QMetaType from, QMetaType to); |
764 | |
765 | static bool registerMutableViewFunction(const MutableViewFunction &f, QMetaType from, QMetaType to); |
766 | static void unregisterMutableViewFunction(QMetaType from, QMetaType to); |
767 | |
768 | static void unregisterMetaType(QMetaType type); |
769 | |
770 | #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) |
771 | const QtPrivate::QMetaTypeInterface *iface() { return d_ptr; } |
772 | #endif |
773 | const QtPrivate::QMetaTypeInterface *iface() const { return d_ptr; } |
774 | |
775 | private: |
776 | static bool isDefaultConstructible(const QtPrivate::QMetaTypeInterface *) noexcept Q_DECL_PURE_FUNCTION; |
777 | static bool isCopyConstructible(const QtPrivate::QMetaTypeInterface *) noexcept Q_DECL_PURE_FUNCTION; |
778 | static bool isMoveConstructible(const QtPrivate::QMetaTypeInterface *) noexcept Q_DECL_PURE_FUNCTION; |
779 | static bool isDestructible(const QtPrivate::QMetaTypeInterface *) noexcept Q_DECL_PURE_FUNCTION; |
780 | |
781 | #if QT_CORE_REMOVED_SINCE(6, 5) |
782 | int idHelper() const; |
783 | #endif |
784 | static int registerHelper(const QtPrivate::QMetaTypeInterface *iface); |
785 | int registerHelper() const |
786 | { |
787 | // keep in sync with the QMetaType::id() version in removed_api.cpp |
788 | if (d_ptr) { |
789 | if (int id = d_ptr->typeId.loadRelaxed()) |
790 | return id; |
791 | return registerHelper(iface: d_ptr); |
792 | } |
793 | return 0; |
794 | } |
795 | |
796 | friend int qRegisterMetaType(QMetaType meta); |
797 | |
798 | friend class QVariant; |
799 | const QtPrivate::QMetaTypeInterface *d_ptr = nullptr; |
800 | }; |
801 | |
802 | #undef QT_DEFINE_METATYPE_ID |
803 | |
804 | Q_DECLARE_OPERATORS_FOR_FLAGS(QMetaType::TypeFlags) |
805 | |
806 | #define QT_METATYPE_PRIVATE_DECLARE_TYPEINFO(C, F) \ |
807 | } \ |
808 | Q_DECLARE_TYPEINFO(QtMetaTypePrivate:: C, (F)); \ |
809 | namespace QtMetaTypePrivate { |
810 | |
811 | |
812 | namespace QtMetaTypePrivate { |
813 | |
814 | class QPairVariantInterfaceImpl |
815 | { |
816 | public: |
817 | const void *_pair; |
818 | QMetaType _metaType_first; |
819 | QMetaType _metaType_second; |
820 | |
821 | typedef void (*getFunc)(const void * const *p, void *); |
822 | |
823 | getFunc _getFirst; |
824 | getFunc _getSecond; |
825 | |
826 | template<class T> |
827 | static void getFirstImpl(const void * const *pair, void *dataPtr) |
828 | { *static_cast<typename T::first_type *>(dataPtr) = static_cast<const T*>(*pair)->first; } |
829 | template<class T> |
830 | static void getSecondImpl(const void * const *pair, void *dataPtr) |
831 | { *static_cast<typename T::second_type *>(dataPtr) = static_cast<const T*>(*pair)->second; } |
832 | |
833 | public: |
834 | template<class T> QPairVariantInterfaceImpl(const T*p) |
835 | : _pair(p) |
836 | , _metaType_first(QMetaType::fromType<typename T::first_type>()) |
837 | , _metaType_second(QMetaType::fromType<typename T::second_type>()) |
838 | , _getFirst(getFirstImpl<T>) |
839 | , _getSecond(getSecondImpl<T>) |
840 | { |
841 | } |
842 | |
843 | constexpr QPairVariantInterfaceImpl() |
844 | : _pair(nullptr) |
845 | , _getFirst(nullptr) |
846 | , _getSecond(nullptr) |
847 | { |
848 | } |
849 | |
850 | inline void first(void *dataPtr) const { _getFirst(&_pair, dataPtr); } |
851 | inline void second(void *dataPtr) const { _getSecond(&_pair, dataPtr); } |
852 | }; |
853 | QT_METATYPE_PRIVATE_DECLARE_TYPEINFO(QPairVariantInterfaceImpl, Q_RELOCATABLE_TYPE) |
854 | |
855 | template<typename From> |
856 | struct QPairVariantInterfaceConvertFunctor; |
857 | |
858 | template<typename T, typename U> |
859 | struct QPairVariantInterfaceConvertFunctor<std::pair<T, U> > |
860 | { |
861 | QPairVariantInterfaceImpl operator()(const std::pair<T, U>& f) const |
862 | { |
863 | return QPairVariantInterfaceImpl(&f); |
864 | } |
865 | }; |
866 | |
867 | } |
868 | |
869 | class QObject; |
870 | |
871 | #define QT_FORWARD_DECLARE_SHARED_POINTER_TYPES_ITER(Name) \ |
872 | template <class T> class Name; \ |
873 | |
874 | QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(QT_FORWARD_DECLARE_SHARED_POINTER_TYPES_ITER) |
875 | |
876 | namespace QtPrivate |
877 | { |
878 | namespace detail { |
879 | template<typename T, typename ODR_VIOLATION_PREVENTER> |
880 | struct is_complete_helper |
881 | { |
882 | template<typename U> |
883 | static auto check(U *) -> std::integral_constant<bool, sizeof(U) != 0>; |
884 | static auto check(...) -> std::false_type; |
885 | using type = decltype(check(static_cast<T *>(nullptr))); |
886 | }; |
887 | } // namespace detail |
888 | |
889 | template <typename T, typename ODR_VIOLATION_PREVENTER> |
890 | struct is_complete : detail::is_complete_helper<std::remove_reference_t<T>, ODR_VIOLATION_PREVENTER>::type {}; |
891 | |
892 | template <typename T> struct MetatypeDecay { using type = T; }; |
893 | template <typename T> struct MetatypeDecay<const T> { using type = T; }; |
894 | template <typename T> struct MetatypeDecay<const T &> { using type = T; }; |
895 | |
896 | template <typename T> struct IsPointerDeclaredOpaque : |
897 | std::disjunction<std::is_member_pointer<T>, |
898 | std::is_function<std::remove_pointer_t<T>>> |
899 | {}; |
900 | template <> struct IsPointerDeclaredOpaque<void *> : std::true_type {}; |
901 | template <> struct IsPointerDeclaredOpaque<const void *> : std::true_type {}; |
902 | |
903 | // Note: this does not check that T = U* isn't pointing to a |
904 | // forward-declared type. You may want to combine with |
905 | // checkTypeIsSuitableForMetaType(). |
906 | template<typename T> |
907 | struct IsPointerToTypeDerivedFromQObject |
908 | { |
909 | enum { Value = false }; |
910 | }; |
911 | |
912 | // Specialize to avoid sizeof(void) warning |
913 | template<> |
914 | struct IsPointerToTypeDerivedFromQObject<void*> |
915 | { |
916 | enum { Value = false }; |
917 | }; |
918 | template<> |
919 | struct IsPointerToTypeDerivedFromQObject<const void*> |
920 | { |
921 | enum { Value = false }; |
922 | }; |
923 | template<> |
924 | struct IsPointerToTypeDerivedFromQObject<QObject*> |
925 | { |
926 | enum { Value = true }; |
927 | }; |
928 | |
929 | template<typename T> |
930 | struct IsPointerToTypeDerivedFromQObject<T*> |
931 | { |
932 | typedef qint8 yes_type; |
933 | typedef qint64 no_type; |
934 | |
935 | #ifndef QT_NO_QOBJECT |
936 | static yes_type checkType(QObject* ); |
937 | static yes_type checkType(const QObject* ); |
938 | #endif |
939 | static no_type checkType(...); |
940 | enum { Value = sizeof(checkType(static_cast<T*>(nullptr))) == sizeof(yes_type) }; |
941 | }; |
942 | |
943 | template<typename T, typename Enable = void> |
944 | struct IsGadgetHelper { enum { IsRealGadget = false, IsGadgetOrDerivedFrom = false }; }; |
945 | |
946 | template<typename T> |
947 | struct IsGadgetHelper<T, typename T::QtGadgetHelper> |
948 | { |
949 | template <typename X> |
950 | static char checkType(void (X::*)()); |
951 | static void *checkType(void (T::*)()); |
952 | enum { |
953 | IsRealGadget = sizeof(checkType(&T::qt_check_for_QGADGET_macro)) == sizeof(void *), |
954 | IsGadgetOrDerivedFrom = true |
955 | }; |
956 | }; |
957 | |
958 | template <typename T> |
959 | using IsRealGadget = std::bool_constant<IsGadgetHelper<T>::IsRealGadget>; |
960 | |
961 | template<typename T, typename Enable = void> |
962 | struct IsPointerToGadgetHelper { enum { IsRealGadget = false, IsGadgetOrDerivedFrom = false }; }; |
963 | |
964 | template<typename T> |
965 | struct IsPointerToGadgetHelper<T*, typename T::QtGadgetHelper> |
966 | { |
967 | using BaseType = T; |
968 | template <typename X> |
969 | static char checkType(void (X::*)()); |
970 | static void *checkType(void (T::*)()); |
971 | enum { |
972 | IsRealGadget = !IsPointerToTypeDerivedFromQObject<T*>::Value && sizeof(checkType(&T::qt_check_for_QGADGET_macro)) == sizeof(void *), |
973 | IsGadgetOrDerivedFrom = !IsPointerToTypeDerivedFromQObject<T*>::Value |
974 | }; |
975 | }; |
976 | |
977 | |
978 | template<typename T> char qt_getEnumMetaObject(const T&); |
979 | |
980 | template<typename T> |
981 | struct IsQEnumHelper { |
982 | static const T &declval(); |
983 | // If the type was declared with Q_ENUM, the friend qt_getEnumMetaObject() declared in the |
984 | // Q_ENUM macro will be chosen by ADL, and the return type will be QMetaObject*. |
985 | // Otherwise the chosen overload will be the catch all template function |
986 | // qt_getEnumMetaObject(T) which returns 'char' |
987 | enum { Value = sizeof(qt_getEnumMetaObject(declval())) == sizeof(QMetaObject*) }; |
988 | }; |
989 | template<> struct IsQEnumHelper<void> { enum { Value = false }; }; |
990 | |
991 | template<typename T, typename Enable = void> |
992 | struct MetaObjectForType |
993 | { |
994 | static constexpr const QMetaObject *value() { return nullptr; } |
995 | using MetaObjectFn = const QMetaObject *(*)(const QMetaTypeInterface *); |
996 | static constexpr MetaObjectFn metaObjectFunction = nullptr; |
997 | }; |
998 | #ifndef QT_NO_QOBJECT |
999 | template<typename T> |
1000 | struct MetaObjectForType<T*, typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value>::type> |
1001 | { |
1002 | static constexpr const QMetaObject *value() { return &T::staticMetaObject; } |
1003 | static constexpr const QMetaObject *metaObjectFunction(const QMetaTypeInterface *) { return &T::staticMetaObject; } |
1004 | }; |
1005 | template<typename T> |
1006 | struct MetaObjectForType<T, std::enable_if_t< |
1007 | std::disjunction_v< |
1008 | std::bool_constant<IsGadgetHelper<T>::IsGadgetOrDerivedFrom>, |
1009 | std::is_base_of<QObject, T> |
1010 | > |
1011 | >> |
1012 | { |
1013 | static constexpr const QMetaObject *value() { return &T::staticMetaObject; } |
1014 | static constexpr const QMetaObject *metaObjectFunction(const QMetaTypeInterface *) { return &T::staticMetaObject; } |
1015 | }; |
1016 | template<typename T> |
1017 | struct MetaObjectForType<T, typename std::enable_if<IsPointerToGadgetHelper<T>::IsGadgetOrDerivedFrom>::type> |
1018 | { |
1019 | static constexpr const QMetaObject *value() |
1020 | { |
1021 | return &IsPointerToGadgetHelper<T>::BaseType::staticMetaObject; |
1022 | } |
1023 | static constexpr const QMetaObject *metaObjectFunction(const QMetaTypeInterface *) { return value(); } |
1024 | }; |
1025 | template<typename T> |
1026 | struct MetaObjectForType<T, typename std::enable_if<IsQEnumHelper<T>::Value>::type > |
1027 | { |
1028 | static constexpr const QMetaObject *value() { return qt_getEnumMetaObject(T()); } |
1029 | static constexpr const QMetaObject *metaObjectFunction(const QMetaTypeInterface *) { return value(); } |
1030 | }; |
1031 | #endif |
1032 | |
1033 | template<typename T> |
1034 | struct IsSharedPointerToTypeDerivedFromQObject |
1035 | { |
1036 | enum { Value = false }; |
1037 | }; |
1038 | |
1039 | template<typename T> |
1040 | struct IsSharedPointerToTypeDerivedFromQObject<QSharedPointer<T> > : IsPointerToTypeDerivedFromQObject<T*> |
1041 | { |
1042 | }; |
1043 | |
1044 | template<typename T> |
1045 | struct IsWeakPointerToTypeDerivedFromQObject |
1046 | { |
1047 | enum { Value = false }; |
1048 | }; |
1049 | |
1050 | template<typename T> |
1051 | struct IsWeakPointerToTypeDerivedFromQObject<QWeakPointer<T> > : IsPointerToTypeDerivedFromQObject<T*> |
1052 | { |
1053 | }; |
1054 | |
1055 | template<typename T> |
1056 | struct IsTrackingPointerToTypeDerivedFromQObject |
1057 | { |
1058 | enum { Value = false }; |
1059 | }; |
1060 | |
1061 | template<typename T> |
1062 | struct IsTrackingPointerToTypeDerivedFromQObject<QPointer<T> > |
1063 | { |
1064 | enum { Value = true }; |
1065 | }; |
1066 | |
1067 | template<typename T> |
1068 | struct IsSequentialContainer |
1069 | { |
1070 | enum { Value = false }; |
1071 | }; |
1072 | |
1073 | template<typename T> |
1074 | struct IsAssociativeContainer |
1075 | { |
1076 | enum { Value = false }; |
1077 | }; |
1078 | |
1079 | template<typename T, bool = QtPrivate::IsSequentialContainer<T>::Value> |
1080 | struct SequentialContainerTransformationHelper |
1081 | { |
1082 | static bool registerConverter() |
1083 | { |
1084 | return false; |
1085 | } |
1086 | |
1087 | static bool registerMutableView() |
1088 | { |
1089 | return false; |
1090 | } |
1091 | }; |
1092 | |
1093 | template<typename T, bool = QMetaTypeId2<typename T::value_type>::Defined> |
1094 | struct SequentialValueTypeIsMetaType |
1095 | { |
1096 | static bool registerConverter() |
1097 | { |
1098 | return false; |
1099 | } |
1100 | |
1101 | static bool registerMutableView() |
1102 | { |
1103 | return false; |
1104 | } |
1105 | }; |
1106 | |
1107 | template<typename T> |
1108 | struct SequentialContainerTransformationHelper<T, true> : SequentialValueTypeIsMetaType<T> |
1109 | { |
1110 | }; |
1111 | |
1112 | template<typename T, bool = QtPrivate::IsAssociativeContainer<T>::Value> |
1113 | struct AssociativeContainerTransformationHelper |
1114 | { |
1115 | static bool registerConverter() |
1116 | { |
1117 | return false; |
1118 | } |
1119 | |
1120 | static bool registerMutableView() |
1121 | { |
1122 | return false; |
1123 | } |
1124 | }; |
1125 | |
1126 | template<typename T, bool = QMetaTypeId2<typename T::key_type>::Defined> |
1127 | struct AssociativeKeyTypeIsMetaType |
1128 | { |
1129 | static bool registerConverter() |
1130 | { |
1131 | return false; |
1132 | } |
1133 | |
1134 | static bool registerMutableView() |
1135 | { |
1136 | return false; |
1137 | } |
1138 | }; |
1139 | |
1140 | template<typename T, bool = QMetaTypeId2<typename T::mapped_type>::Defined> |
1141 | struct AssociativeMappedTypeIsMetaType |
1142 | { |
1143 | static bool registerConverter() |
1144 | { |
1145 | return false; |
1146 | } |
1147 | |
1148 | static bool registerMutableView() |
1149 | { |
1150 | return false; |
1151 | } |
1152 | }; |
1153 | |
1154 | template<typename T> |
1155 | struct AssociativeContainerTransformationHelper<T, true> : AssociativeKeyTypeIsMetaType<T> |
1156 | { |
1157 | }; |
1158 | |
1159 | template<typename T, bool = QMetaTypeId2<typename T::first_type>::Defined |
1160 | && QMetaTypeId2<typename T::second_type>::Defined> |
1161 | struct IsMetaTypePair |
1162 | { |
1163 | static bool registerConverter() |
1164 | { |
1165 | return false; |
1166 | } |
1167 | }; |
1168 | |
1169 | template<typename T> |
1170 | struct IsMetaTypePair<T, true> |
1171 | { |
1172 | inline static bool registerConverter(); |
1173 | }; |
1174 | |
1175 | template<typename T> |
1176 | struct IsPair |
1177 | { |
1178 | static bool registerConverter() |
1179 | { |
1180 | return false; |
1181 | } |
1182 | }; |
1183 | template<typename T, typename U> |
1184 | struct IsPair<std::pair<T, U> > : IsMetaTypePair<std::pair<T, U> > {}; |
1185 | |
1186 | template<typename T> |
1187 | struct MetaTypePairHelper : IsPair<T> {}; |
1188 | |
1189 | template<typename T, typename = void> |
1190 | struct MetaTypeSmartPointerHelper |
1191 | { |
1192 | static bool registerConverter() { return false; } |
1193 | }; |
1194 | |
1195 | #if QT_CONFIG(future) |
1196 | template<typename T> |
1197 | struct MetaTypeQFutureHelper |
1198 | { |
1199 | static bool registerConverter() { return false; } |
1200 | }; |
1201 | #endif |
1202 | |
1203 | template <typename X> static constexpr bool checkTypeIsSuitableForMetaType() |
1204 | { |
1205 | using T = typename MetatypeDecay<X>::type; |
1206 | static_assert(is_complete<T, void>::value || std::is_void_v<T>, |
1207 | "Meta Types must be fully defined"); |
1208 | static_assert(!std::is_reference_v<T>, |
1209 | "Meta Types cannot be non-const references or rvalue references."); |
1210 | if constexpr (std::is_pointer_v<T> && !IsPointerDeclaredOpaque<T>::value) { |
1211 | using Pointed = std::remove_pointer_t<T>; |
1212 | static_assert(is_complete<Pointed, void>::value, |
1213 | "Pointer Meta Types must either point to fully-defined types " |
1214 | "or be declared with Q_DECLARE_OPAQUE_POINTER(T *)"); |
1215 | } |
1216 | return true; |
1217 | } |
1218 | |
1219 | Q_CORE_EXPORT bool isBuiltinType(const QByteArray &type); |
1220 | } // namespace QtPrivate |
1221 | |
1222 | template <typename T, int = |
1223 | QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : |
1224 | QtPrivate::IsRealGadget<T>::value ? QMetaType::IsGadget : |
1225 | QtPrivate::IsPointerToGadgetHelper<T>::IsRealGadget ? QMetaType::PointerToGadget : |
1226 | QtPrivate::IsQEnumHelper<T>::Value ? QMetaType::IsEnumeration : 0> |
1227 | struct QMetaTypeIdQObject |
1228 | { |
1229 | enum { |
1230 | Defined = 0 |
1231 | }; |
1232 | }; |
1233 | |
1234 | template <typename T> |
1235 | struct QMetaTypeId : public QMetaTypeIdQObject<T> |
1236 | { |
1237 | }; |
1238 | |
1239 | template <typename T> |
1240 | struct QMetaTypeId2 |
1241 | { |
1242 | using NameAsArrayType = void; |
1243 | enum { Defined = QMetaTypeId<T>::Defined, IsBuiltIn=false }; |
1244 | static inline constexpr int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); } |
1245 | }; |
1246 | |
1247 | template <typename T> |
1248 | struct QMetaTypeId2<const T&> : QMetaTypeId2<T> {}; |
1249 | |
1250 | template <typename T> |
1251 | struct QMetaTypeId2<T&> |
1252 | { |
1253 | using NameAsArrayType = void; |
1254 | enum { Defined = false, IsBuiltIn = false }; |
1255 | static inline constexpr int qt_metatype_id() { return 0; } |
1256 | }; |
1257 | |
1258 | namespace QtPrivate { |
1259 | template <typename T, bool Defined = QMetaTypeId2<T>::Defined> |
1260 | struct QMetaTypeIdHelper { |
1261 | static inline constexpr int qt_metatype_id() |
1262 | { return QMetaTypeId2<T>::qt_metatype_id(); } |
1263 | }; |
1264 | template <typename T> struct QMetaTypeIdHelper<T, false> { |
1265 | static inline constexpr int qt_metatype_id() |
1266 | { return -1; } |
1267 | }; |
1268 | |
1269 | // Function pointers don't derive from QObject |
1270 | template <typename Result, typename... Args> |
1271 | struct IsPointerToTypeDerivedFromQObject<Result(*)(Args...)> { enum { Value = false }; }; |
1272 | |
1273 | template<typename T> |
1274 | inline constexpr bool IsQmlListType = false; |
1275 | |
1276 | template<typename T, bool = std::is_enum<T>::value> |
1277 | constexpr bool IsUnsignedEnum = false; |
1278 | template<typename T> |
1279 | constexpr bool IsUnsignedEnum<T, true> = !std::is_signed_v<std::underlying_type_t<T>>; |
1280 | |
1281 | template<typename T> |
1282 | struct QMetaTypeTypeFlags |
1283 | { |
1284 | enum { Flags = (QTypeInfo<T>::isRelocatable ? QMetaType::RelocatableType : 0) |
1285 | | ((!std::is_default_constructible_v<T> || !QTypeInfo<T>::isValueInitializationBitwiseZero) ? QMetaType::NeedsConstruction : 0) |
1286 | | (!std::is_trivially_destructible_v<T> ? QMetaType::NeedsDestruction : 0) |
1287 | | (!std::is_trivially_copy_constructible_v<T> ? QMetaType::NeedsCopyConstruction : 0) |
1288 | | (!std::is_trivially_move_constructible_v<T> ? QMetaType::NeedsMoveConstruction : 0) |
1289 | | (IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : 0) |
1290 | | (IsSharedPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::SharedPointerToQObject : 0) |
1291 | | (IsWeakPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::WeakPointerToQObject : 0) |
1292 | | (IsTrackingPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::TrackingPointerToQObject : 0) |
1293 | | (IsEnumOrFlags<T>::value ? QMetaType::IsEnumeration : 0) |
1294 | | (IsGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::IsGadget : 0) |
1295 | | (IsPointerToGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::PointerToGadget : 0) |
1296 | | (std::is_pointer_v<T> ? QMetaType::IsPointer : 0) |
1297 | | (IsUnsignedEnum<T> ? QMetaType::IsUnsignedEnumeration : 0) |
1298 | | (IsQmlListType<T> ? QMetaType::IsQmlList : 0) |
1299 | | (std::is_const_v<std::remove_pointer_t<T>> ? QMetaType::IsConst : 0) |
1300 | }; |
1301 | }; |
1302 | |
1303 | template<typename T, bool defined> |
1304 | struct MetaTypeDefinedHelper |
1305 | { |
1306 | enum DefinedType { Defined = defined }; |
1307 | }; |
1308 | |
1309 | template<typename SmartPointer> |
1310 | struct QSmartPointerConvertFunctor |
1311 | { |
1312 | QObject* operator()(const SmartPointer &p) const |
1313 | { |
1314 | return p.operator->(); |
1315 | } |
1316 | }; |
1317 | |
1318 | // hack to delay name lookup to instantiation time by making |
1319 | // EnableInternalData a dependent name: |
1320 | template <typename T> |
1321 | struct EnableInternalDataWrap; |
1322 | |
1323 | template<typename T> |
1324 | struct QSmartPointerConvertFunctor<QWeakPointer<T> > |
1325 | { |
1326 | QObject* operator()(const QWeakPointer<T> &p) const |
1327 | { |
1328 | return QtPrivate::EnableInternalDataWrap<T>::internalData(p); |
1329 | } |
1330 | }; |
1331 | } |
1332 | |
1333 | template <typename T> |
1334 | int qRegisterNormalizedMetaTypeImplementation(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName) |
1335 | { |
1336 | #ifndef QT_NO_QOBJECT |
1337 | Q_ASSERT_X(normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData()), |
1338 | "qRegisterNormalizedMetaType", |
1339 | "qRegisterNormalizedMetaType was called with a not normalized type name, " |
1340 | "please call qRegisterMetaType instead."); |
1341 | #endif |
1342 | |
1343 | const QMetaType metaType = QMetaType::fromType<T>(); |
1344 | const int id = metaType.id(); |
1345 | |
1346 | QtPrivate::SequentialContainerTransformationHelper<T>::registerConverter(); |
1347 | QtPrivate::SequentialContainerTransformationHelper<T>::registerMutableView(); |
1348 | QtPrivate::AssociativeContainerTransformationHelper<T>::registerConverter(); |
1349 | QtPrivate::AssociativeContainerTransformationHelper<T>::registerMutableView(); |
1350 | QtPrivate::MetaTypePairHelper<T>::registerConverter(); |
1351 | QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter(); |
1352 | #if QT_CONFIG(future) |
1353 | QtPrivate::MetaTypeQFutureHelper<T>::registerConverter(); |
1354 | #endif |
1355 | |
1356 | if (normalizedTypeName != metaType.name()) |
1357 | QMetaType::registerNormalizedTypedef(normalizedTypeName, type: metaType); |
1358 | |
1359 | return id; |
1360 | } |
1361 | |
1362 | // This primary template calls the -Implementation, like all other specialisations should. |
1363 | // But the split allows to |
1364 | // - in a header: |
1365 | // - define a specialization of this template calling an out-of-line function |
1366 | // (QT_DECL_METATYPE_EXTERN{,_TAGGED}) |
1367 | // - in the .cpp file: |
1368 | // - define the out-of-line wrapper to call the -Implementation |
1369 | // (QT_IMPL_METATYPE_EXTERN{,_TAGGED}) |
1370 | // The _TAGGED variants let you choose a tag (must be a C identifier) to disambiguate |
1371 | // the out-of-line function; the non-_TAGGED variants use the passed class name as tag. |
1372 | template <typename T> |
1373 | int qRegisterNormalizedMetaType(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName) |
1374 | { |
1375 | return qRegisterNormalizedMetaTypeImplementation<T>(normalizedTypeName); |
1376 | } |
1377 | |
1378 | #define QT_DECL_METATYPE_EXTERN_TAGGED(TYPE, TAG, EXPORT) \ |
1379 | QT_BEGIN_NAMESPACE \ |
1380 | EXPORT int qRegisterNormalizedMetaType_ ## TAG (const QByteArray &); \ |
1381 | template <> inline int qRegisterNormalizedMetaType< TYPE >(const QByteArray &name) \ |
1382 | { return qRegisterNormalizedMetaType_ ## TAG (name); } \ |
1383 | QT_END_NAMESPACE \ |
1384 | Q_DECLARE_METATYPE(TYPE) \ |
1385 | /* end */ |
1386 | #define QT_IMPL_METATYPE_EXTERN_TAGGED(TYPE, TAG) \ |
1387 | int qRegisterNormalizedMetaType_ ## TAG (const QByteArray &name) \ |
1388 | { return qRegisterNormalizedMetaTypeImplementation< TYPE >(name); } \ |
1389 | /* end */ |
1390 | #define QT_DECL_METATYPE_EXTERN(TYPE, EXPORT) \ |
1391 | QT_DECL_METATYPE_EXTERN_TAGGED(TYPE, TYPE, EXPORT) |
1392 | #define QT_IMPL_METATYPE_EXTERN(TYPE) \ |
1393 | QT_IMPL_METATYPE_EXTERN_TAGGED(TYPE, TYPE) |
1394 | |
1395 | template <typename T> |
1396 | int qRegisterMetaType(const char *typeName) |
1397 | { |
1398 | #ifdef QT_NO_QOBJECT |
1399 | QT_PREPEND_NAMESPACE(QByteArray) normalizedTypeName = typeName; |
1400 | #else |
1401 | QT_PREPEND_NAMESPACE(QByteArray) normalizedTypeName = QMetaObject::normalizedType(type: typeName); |
1402 | #endif |
1403 | return qRegisterNormalizedMetaType<T>(normalizedTypeName); |
1404 | } |
1405 | |
1406 | template <typename T> |
1407 | inline constexpr int qMetaTypeId() |
1408 | { |
1409 | if constexpr (bool(QMetaTypeId2<T>::IsBuiltIn)) { |
1410 | // this has the same result as the below code, but avoids asking the |
1411 | // compiler to load a global variable whose value we know at compile |
1412 | // time |
1413 | return QMetaTypeId2<T>::MetaType; |
1414 | } else { |
1415 | return QMetaType::fromType<T>().id(); |
1416 | } |
1417 | } |
1418 | |
1419 | template <typename T> |
1420 | inline constexpr int qRegisterMetaType() |
1421 | { |
1422 | int id = qMetaTypeId<T>(); |
1423 | return id; |
1424 | } |
1425 | |
1426 | inline int qRegisterMetaType(QMetaType meta) |
1427 | { |
1428 | return meta.registerHelper(); |
1429 | } |
1430 | |
1431 | #ifndef QT_NO_QOBJECT |
1432 | template <typename T> |
1433 | struct QMetaTypeIdQObject<T*, QMetaType::PointerToQObject> |
1434 | { |
1435 | enum { |
1436 | Defined = 1 |
1437 | }; |
1438 | |
1439 | static int qt_metatype_id() |
1440 | { |
1441 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); |
1442 | if (const int id = metatype_id.loadAcquire()) |
1443 | return id; |
1444 | const char *const cName = T::staticMetaObject.className(); |
1445 | QByteArray typeName; |
1446 | typeName.reserve(asize: strlen(s: cName) + 1); |
1447 | typeName.append(s: cName).append(c: '*'); |
1448 | const int newId = qRegisterNormalizedMetaType<T *>(typeName); |
1449 | metatype_id.storeRelease(newValue: newId); |
1450 | return newId; |
1451 | } |
1452 | }; |
1453 | |
1454 | template <typename T> |
1455 | struct QMetaTypeIdQObject<T, QMetaType::IsGadget> |
1456 | { |
1457 | enum { |
1458 | Defined = std::is_default_constructible<T>::value |
1459 | }; |
1460 | |
1461 | static int qt_metatype_id() |
1462 | { |
1463 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); |
1464 | if (const int id = metatype_id.loadAcquire()) |
1465 | return id; |
1466 | const char *const cName = T::staticMetaObject.className(); |
1467 | const int newId = qRegisterNormalizedMetaType<T>(cName); |
1468 | metatype_id.storeRelease(newValue: newId); |
1469 | return newId; |
1470 | } |
1471 | }; |
1472 | |
1473 | template <typename T> |
1474 | struct QMetaTypeIdQObject<T*, QMetaType::PointerToGadget> |
1475 | { |
1476 | enum { |
1477 | Defined = 1 |
1478 | }; |
1479 | |
1480 | static int qt_metatype_id() |
1481 | { |
1482 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); |
1483 | if (const int id = metatype_id.loadAcquire()) |
1484 | return id; |
1485 | const char *const cName = T::staticMetaObject.className(); |
1486 | QByteArray typeName; |
1487 | typeName.reserve(asize: strlen(s: cName) + 1); |
1488 | typeName.append(s: cName).append(c: '*'); |
1489 | const int newId = qRegisterNormalizedMetaType<T *>(typeName); |
1490 | metatype_id.storeRelease(newValue: newId); |
1491 | return newId; |
1492 | } |
1493 | }; |
1494 | |
1495 | template <typename T> |
1496 | struct QMetaTypeIdQObject<T, QMetaType::IsEnumeration> |
1497 | { |
1498 | enum { |
1499 | Defined = 1 |
1500 | }; |
1501 | |
1502 | static int qt_metatype_id() |
1503 | { |
1504 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); |
1505 | if (const int id = metatype_id.loadAcquire()) |
1506 | return id; |
1507 | const char *eName = qt_getEnumName(T()); |
1508 | const char *cName = qt_getEnumMetaObject(T())->className(); |
1509 | QByteArray typeName; |
1510 | typeName.reserve(asize: strlen(s: cName) + 2 + strlen(s: eName)); |
1511 | typeName.append(s: cName).append(s: "::").append(s: eName); |
1512 | const int newId = qRegisterNormalizedMetaType<T>(typeName); |
1513 | metatype_id.storeRelease(newValue: newId); |
1514 | return newId; |
1515 | } |
1516 | }; |
1517 | #endif |
1518 | |
1519 | #define Q_DECLARE_OPAQUE_POINTER(POINTER) \ |
1520 | QT_BEGIN_NAMESPACE namespace QtPrivate { \ |
1521 | template <> struct IsPointerDeclaredOpaque<POINTER> \ |
1522 | : std::true_type {}; \ |
1523 | } QT_END_NAMESPACE \ |
1524 | /**/ |
1525 | |
1526 | #ifndef Q_MOC_RUN |
1527 | #define Q_DECLARE_METATYPE(TYPE) Q_DECLARE_METATYPE_IMPL(TYPE) |
1528 | #define Q_DECLARE_METATYPE_IMPL(TYPE) \ |
1529 | QT_BEGIN_NAMESPACE \ |
1530 | template <> \ |
1531 | struct QMetaTypeId< TYPE > \ |
1532 | { \ |
1533 | enum { Defined = 1 }; \ |
1534 | static_assert(QtPrivate::checkTypeIsSuitableForMetaType<TYPE>()); \ |
1535 | static int qt_metatype_id() \ |
1536 | { \ |
1537 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); \ |
1538 | if (const int id = metatype_id.loadAcquire()) \ |
1539 | return id; \ |
1540 | constexpr auto arr = QtPrivate::typenameHelper<TYPE>(); \ |
1541 | auto name = arr.data(); \ |
1542 | if (QByteArrayView(name) == (#TYPE)) { \ |
1543 | const int id = qRegisterNormalizedMetaType<TYPE>(name); \ |
1544 | metatype_id.storeRelease(id); \ |
1545 | return id; \ |
1546 | } \ |
1547 | const int newId = qRegisterMetaType< TYPE >(#TYPE); \ |
1548 | metatype_id.storeRelease(newId); \ |
1549 | return newId; \ |
1550 | } \ |
1551 | }; \ |
1552 | QT_END_NAMESPACE |
1553 | #endif // Q_MOC_RUN |
1554 | |
1555 | #define Q_DECLARE_BUILTIN_METATYPE(TYPE, METATYPEID, NAME) \ |
1556 | QT_BEGIN_NAMESPACE \ |
1557 | template<> struct QMetaTypeId2<NAME> \ |
1558 | { \ |
1559 | using NameAsArrayType = std::array<char, sizeof(#NAME)>; \ |
1560 | enum { Defined = 1, IsBuiltIn = true, MetaType = METATYPEID }; \ |
1561 | static inline constexpr int qt_metatype_id() { return METATYPEID; } \ |
1562 | static constexpr NameAsArrayType nameAsArray = { #NAME }; \ |
1563 | }; \ |
1564 | QT_END_NAMESPACE |
1565 | |
1566 | #define QT_FORWARD_DECLARE_STATIC_TYPES_ITER(TypeName, TypeId, Name) \ |
1567 | class Name; |
1568 | |
1569 | QT_FOR_EACH_STATIC_CORE_CLASS(QT_FORWARD_DECLARE_STATIC_TYPES_ITER) |
1570 | QT_FOR_EACH_STATIC_GUI_CLASS(QT_FORWARD_DECLARE_STATIC_TYPES_ITER) |
1571 | QT_FOR_EACH_STATIC_WIDGETS_CLASS(QT_FORWARD_DECLARE_STATIC_TYPES_ITER) |
1572 | |
1573 | #undef QT_FORWARD_DECLARE_STATIC_TYPES_ITER |
1574 | |
1575 | #define Q_DECLARE_METATYPE_TEMPLATE_1ARG(SINGLE_ARG_TEMPLATE) \ |
1576 | QT_BEGIN_NAMESPACE \ |
1577 | template <typename T> \ |
1578 | struct QMetaTypeId< SINGLE_ARG_TEMPLATE<T> > \ |
1579 | { \ |
1580 | enum { \ |
1581 | Defined = QMetaTypeId2<T>::Defined \ |
1582 | }; \ |
1583 | static int qt_metatype_id() \ |
1584 | { \ |
1585 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); \ |
1586 | if (const int id = metatype_id.loadRelaxed()) \ |
1587 | return id; \ |
1588 | const char *tName = QMetaType::fromType<T>().name(); \ |
1589 | Q_ASSERT(tName); \ |
1590 | const size_t tNameLen = qstrlen(tName); \ |
1591 | QByteArray typeName; \ |
1592 | typeName.reserve(sizeof(#SINGLE_ARG_TEMPLATE) + 1 + tNameLen + 1 + 1); \ |
1593 | typeName.append(#SINGLE_ARG_TEMPLATE, int(sizeof(#SINGLE_ARG_TEMPLATE)) - 1) \ |
1594 | .append('<').append(tName, tNameLen); \ |
1595 | typeName.append('>'); \ |
1596 | const int newId = qRegisterNormalizedMetaType< SINGLE_ARG_TEMPLATE<T> >(typeName); \ |
1597 | metatype_id.storeRelease(newId); \ |
1598 | return newId; \ |
1599 | } \ |
1600 | }; \ |
1601 | QT_END_NAMESPACE |
1602 | |
1603 | #define Q_DECLARE_METATYPE_TEMPLATE_2ARG(DOUBLE_ARG_TEMPLATE) \ |
1604 | QT_BEGIN_NAMESPACE \ |
1605 | template<typename T, typename U> \ |
1606 | struct QMetaTypeId< DOUBLE_ARG_TEMPLATE<T, U> > \ |
1607 | { \ |
1608 | enum { \ |
1609 | Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined \ |
1610 | }; \ |
1611 | static int qt_metatype_id() \ |
1612 | { \ |
1613 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); \ |
1614 | if (const int id = metatype_id.loadAcquire()) \ |
1615 | return id; \ |
1616 | const char *tName = QMetaType::fromType<T>().name(); \ |
1617 | const char *uName = QMetaType::fromType<U>().name(); \ |
1618 | Q_ASSERT(tName); \ |
1619 | Q_ASSERT(uName); \ |
1620 | const size_t tNameLen = qstrlen(tName); \ |
1621 | const size_t uNameLen = qstrlen(uName); \ |
1622 | QByteArray typeName; \ |
1623 | typeName.reserve(sizeof(#DOUBLE_ARG_TEMPLATE) + 1 + tNameLen + 1 + uNameLen + 1 + 1); \ |
1624 | typeName.append(#DOUBLE_ARG_TEMPLATE, int(sizeof(#DOUBLE_ARG_TEMPLATE)) - 1) \ |
1625 | .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); \ |
1626 | typeName.append('>'); \ |
1627 | const int newId = qRegisterNormalizedMetaType< DOUBLE_ARG_TEMPLATE<T, U> >(typeName); \ |
1628 | metatype_id.storeRelease(newId); \ |
1629 | return newId; \ |
1630 | } \ |
1631 | }; \ |
1632 | QT_END_NAMESPACE |
1633 | |
1634 | namespace QtPrivate { |
1635 | |
1636 | template<typename T, bool /* isSharedPointerToQObjectDerived */ = false> |
1637 | struct SharedPointerMetaTypeIdHelper |
1638 | { |
1639 | enum { |
1640 | Defined = 0 |
1641 | }; |
1642 | static int qt_metatype_id() |
1643 | { |
1644 | return -1; |
1645 | } |
1646 | }; |
1647 | |
1648 | } |
1649 | |
1650 | #define Q_DECLARE_SMART_POINTER_METATYPE(SMART_POINTER) \ |
1651 | QT_BEGIN_NAMESPACE \ |
1652 | namespace QtPrivate { \ |
1653 | template<typename T> \ |
1654 | struct SharedPointerMetaTypeIdHelper<SMART_POINTER<T>, true> \ |
1655 | { \ |
1656 | enum { \ |
1657 | Defined = 1 \ |
1658 | }; \ |
1659 | static int qt_metatype_id() \ |
1660 | { \ |
1661 | Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); \ |
1662 | if (const int id = metatype_id.loadAcquire()) \ |
1663 | return id; \ |
1664 | const char * const cName = T::staticMetaObject.className(); \ |
1665 | QByteArray typeName; \ |
1666 | typeName.reserve(sizeof(#SMART_POINTER) + 1 + strlen(cName) + 1); \ |
1667 | typeName.append(#SMART_POINTER, int(sizeof(#SMART_POINTER)) - 1) \ |
1668 | .append('<').append(cName).append('>'); \ |
1669 | const int newId = qRegisterNormalizedMetaType< SMART_POINTER<T> >(typeName); \ |
1670 | metatype_id.storeRelease(newId); \ |
1671 | return newId; \ |
1672 | } \ |
1673 | }; \ |
1674 | template<typename T> \ |
1675 | struct MetaTypeSmartPointerHelper<SMART_POINTER<T> , \ |
1676 | typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value && !std::is_const_v<T>>::type> \ |
1677 | { \ |
1678 | static bool registerConverter() \ |
1679 | { \ |
1680 | const QMetaType to = QMetaType(QMetaType::QObjectStar); \ |
1681 | if (!QMetaType::hasRegisteredConverterFunction(QMetaType::fromType<SMART_POINTER<T>>(), to)) { \ |
1682 | QtPrivate::QSmartPointerConvertFunctor<SMART_POINTER<T> > o; \ |
1683 | return QMetaType::registerConverter<SMART_POINTER<T>, QObject*>(o); \ |
1684 | } \ |
1685 | return true; \ |
1686 | } \ |
1687 | }; \ |
1688 | } \ |
1689 | template <typename T> \ |
1690 | struct QMetaTypeId< SMART_POINTER<T> > \ |
1691 | : QtPrivate::SharedPointerMetaTypeIdHelper< SMART_POINTER<T>, \ |
1692 | QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> \ |
1693 | { \ |
1694 | };\ |
1695 | QT_END_NAMESPACE |
1696 | |
1697 | #define Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(SINGLE_ARG_TEMPLATE) \ |
1698 | QT_BEGIN_NAMESPACE \ |
1699 | namespace QtPrivate { \ |
1700 | template<typename T> \ |
1701 | struct IsSequentialContainer<SINGLE_ARG_TEMPLATE<T> > \ |
1702 | { \ |
1703 | enum { Value = true }; \ |
1704 | }; \ |
1705 | } \ |
1706 | QT_END_NAMESPACE \ |
1707 | Q_DECLARE_METATYPE_TEMPLATE_1ARG(SINGLE_ARG_TEMPLATE) |
1708 | |
1709 | #define Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE_ITER(TEMPLATENAME) \ |
1710 | Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(TEMPLATENAME) |
1711 | |
1712 | QT_END_NAMESPACE |
1713 | |
1714 | QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE_ITER) |
1715 | |
1716 | #undef Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE_ITER |
1717 | |
1718 | Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(std::vector) |
1719 | Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(std::list) |
1720 | |
1721 | #define Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(TEMPLATENAME) \ |
1722 | QT_BEGIN_NAMESPACE \ |
1723 | namespace QtPrivate { \ |
1724 | template<typename T, typename U> \ |
1725 | struct IsAssociativeContainer<TEMPLATENAME<T, U> > \ |
1726 | { \ |
1727 | enum { Value = true }; \ |
1728 | }; \ |
1729 | } \ |
1730 | QT_END_NAMESPACE \ |
1731 | Q_DECLARE_METATYPE_TEMPLATE_2ARG(TEMPLATENAME) |
1732 | |
1733 | Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(QHash) |
1734 | Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(QMap) |
1735 | Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(std::map) |
1736 | |
1737 | Q_DECLARE_METATYPE_TEMPLATE_2ARG(std::pair) |
1738 | |
1739 | #define Q_DECLARE_METATYPE_TEMPLATE_SMART_POINTER_ITER(TEMPLATENAME) \ |
1740 | Q_DECLARE_SMART_POINTER_METATYPE(TEMPLATENAME) |
1741 | |
1742 | QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(Q_DECLARE_METATYPE_TEMPLATE_SMART_POINTER_ITER) |
1743 | |
1744 | QT_BEGIN_NAMESPACE |
1745 | |
1746 | #undef Q_DECLARE_METATYPE_TEMPLATE_SMART_POINTER_ITER |
1747 | |
1748 | QT_END_NAMESPACE |
1749 | |
1750 | QT_FOR_EACH_STATIC_TYPE(Q_DECLARE_BUILTIN_METATYPE) |
1751 | |
1752 | |
1753 | QT_BEGIN_NAMESPACE |
1754 | |
1755 | namespace QtPrivate { |
1756 | // out-of-line helpers to reduce template code bloat ("SCARY") and improve compile times: |
1757 | Q_CORE_EXPORT bool hasRegisteredConverterFunctionToPairVariantInterface(QMetaType m); |
1758 | Q_CORE_EXPORT bool hasRegisteredConverterFunctionToIterableMetaSequence(QMetaType m); |
1759 | Q_CORE_EXPORT bool hasRegisteredMutableViewFunctionToIterableMetaSequence(QMetaType m); |
1760 | Q_CORE_EXPORT bool hasRegisteredConverterFunctionToIterableMetaAssociation(QMetaType m); |
1761 | Q_CORE_EXPORT bool hasRegisteredMutableViewFunctionToIterableMetaAssociation(QMetaType m); |
1762 | } |
1763 | |
1764 | template <typename T> |
1765 | inline bool QtPrivate::IsMetaTypePair<T, true>::registerConverter() |
1766 | { |
1767 | if (!QtPrivate::hasRegisteredConverterFunctionToPairVariantInterface(m: QMetaType::fromType<T>())) { |
1768 | QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> o; |
1769 | return QMetaType::registerConverter<T, QtMetaTypePrivate::QPairVariantInterfaceImpl>(o); |
1770 | } |
1771 | return true; |
1772 | } |
1773 | |
1774 | namespace QtPrivate { |
1775 | |
1776 | template<typename From> |
1777 | struct QSequentialIterableConvertFunctor |
1778 | { |
1779 | QIterable<QMetaSequence> operator()(const From &f) const |
1780 | { |
1781 | return QIterable<QMetaSequence>(QMetaSequence::fromContainer<From>(), &f); |
1782 | } |
1783 | }; |
1784 | |
1785 | template<typename From> |
1786 | struct QSequentialIterableMutableViewFunctor |
1787 | { |
1788 | QIterable<QMetaSequence> operator()(From &f) const |
1789 | { |
1790 | return QIterable<QMetaSequence>(QMetaSequence::fromContainer<From>(), &f); |
1791 | } |
1792 | }; |
1793 | |
1794 | template<typename T> |
1795 | struct SequentialValueTypeIsMetaType<T, true> |
1796 | { |
1797 | static bool registerConverter() |
1798 | { |
1799 | if (!QtPrivate::hasRegisteredConverterFunctionToIterableMetaSequence(m: QMetaType::fromType<T>())) { |
1800 | QSequentialIterableConvertFunctor<T> o; |
1801 | return QMetaType::registerConverter<T, QIterable<QMetaSequence>>(o); |
1802 | } |
1803 | return true; |
1804 | } |
1805 | |
1806 | static bool registerMutableView() |
1807 | { |
1808 | if (!QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaSequence(m: QMetaType::fromType<T>())) { |
1809 | QSequentialIterableMutableViewFunctor<T> o; |
1810 | return QMetaType::registerMutableView<T, QIterable<QMetaSequence>>(o); |
1811 | } |
1812 | return true; |
1813 | } |
1814 | }; |
1815 | |
1816 | template<typename From> |
1817 | struct QAssociativeIterableConvertFunctor |
1818 | { |
1819 | QIterable<QMetaAssociation> operator()(const From &f) const |
1820 | { |
1821 | return QIterable<QMetaAssociation>(QMetaAssociation::fromContainer<From>(), &f); |
1822 | } |
1823 | }; |
1824 | |
1825 | template<typename From> |
1826 | struct QAssociativeIterableMutableViewFunctor |
1827 | { |
1828 | QIterable<QMetaAssociation> operator()(From &f) const |
1829 | { |
1830 | return QIterable<QMetaAssociation>(QMetaAssociation::fromContainer<From>(), &f); |
1831 | } |
1832 | }; |
1833 | |
1834 | // Mapped type can be omitted, for example in case of a set. |
1835 | // However, if it is available, we want to instantiate the metatype here. |
1836 | template<typename T> |
1837 | struct AssociativeKeyTypeIsMetaType<T, true> : AssociativeMappedTypeIsMetaType<T> |
1838 | { |
1839 | static bool registerConverter() |
1840 | { |
1841 | if (!QtPrivate::hasRegisteredConverterFunctionToIterableMetaAssociation(m: QMetaType::fromType<T>())) { |
1842 | QAssociativeIterableConvertFunctor<T> o; |
1843 | return QMetaType::registerConverter<T, QIterable<QMetaAssociation>>(o); |
1844 | } |
1845 | return true; |
1846 | } |
1847 | |
1848 | static bool registerMutableView() |
1849 | { |
1850 | if (!QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaAssociation(m: QMetaType::fromType<T>())) { |
1851 | QAssociativeIterableMutableViewFunctor<T> o; |
1852 | return QMetaType::registerMutableView<T, QIterable<QMetaAssociation>>(o); |
1853 | } |
1854 | return true; |
1855 | } |
1856 | }; |
1857 | |
1858 | struct QTypeNormalizer |
1859 | { |
1860 | char *output; |
1861 | int len = 0; |
1862 | char last = 0; |
1863 | |
1864 | private: |
1865 | static constexpr bool is_ident_char(char s) |
1866 | { |
1867 | return ((s >= 'a' && s <= 'z') || (s >= 'A' && s <= 'Z') || (s >= '0' && s <= '9') |
1868 | || s == '_'); |
1869 | } |
1870 | static constexpr bool is_space(char s) { return (s == ' ' || s == '\t' || s == '\n'); } |
1871 | static constexpr bool is_number(char s) { return s >= '0' && s <= '9'; } |
1872 | static constexpr bool starts_with_token(const char *b, const char *e, const char *token, |
1873 | bool msvcKw = false) |
1874 | { |
1875 | while (b != e && *token && *b == *token) { |
1876 | b++; |
1877 | token++; |
1878 | } |
1879 | if (*token) |
1880 | return false; |
1881 | #ifdef Q_CC_MSVC |
1882 | /// On MSVC, keywords like class or struct are not separated with spaces in constexpr |
1883 | /// context |
1884 | if (msvcKw && !is_ident_char(*b)) |
1885 | return true; |
1886 | #endif |
1887 | Q_UNUSED(msvcKw); |
1888 | return b == e || !is_ident_char(s: *b); |
1889 | } |
1890 | static constexpr bool skipToken(const char *&x, const char *e, const char *token, |
1891 | bool msvcKw = false) |
1892 | { |
1893 | if (!starts_with_token(b: x, e, token, msvcKw)) |
1894 | return false; |
1895 | while (*token++) |
1896 | x++; |
1897 | while (x != e && is_space(s: *x)) |
1898 | x++; |
1899 | return true; |
1900 | } |
1901 | static constexpr const char *skipString(const char *x, const char *e) |
1902 | { |
1903 | char delim = *x; |
1904 | x++; |
1905 | while (x != e && *x != delim) { |
1906 | if (*x == '\\') { |
1907 | x++; |
1908 | if (x == e) |
1909 | return e; |
1910 | } |
1911 | x++; |
1912 | } |
1913 | if (x != e) |
1914 | x++; |
1915 | return x; |
1916 | } |
1917 | static constexpr const char *skipTemplate(const char *x, const char *e, bool stopAtComa = false) |
1918 | { |
1919 | int scopeDepth = 0; |
1920 | int templateDepth = 0; |
1921 | while (x != e) { |
1922 | switch (*x) { |
1923 | case '<': |
1924 | if (!scopeDepth) |
1925 | templateDepth++; |
1926 | break; |
1927 | case ',': |
1928 | if (stopAtComa && !scopeDepth && !templateDepth) |
1929 | return x; |
1930 | break; |
1931 | case '>': |
1932 | if (!scopeDepth) |
1933 | if (--templateDepth < 0) |
1934 | return x; |
1935 | break; |
1936 | case '(': |
1937 | case '[': |
1938 | case '{': |
1939 | scopeDepth++; |
1940 | break; |
1941 | case '}': |
1942 | case ']': |
1943 | case ')': |
1944 | scopeDepth--; |
1945 | break; |
1946 | case '\'': |
1947 | if (is_number(s: x[-1])) |
1948 | break; |
1949 | Q_FALLTHROUGH(); |
1950 | case '\"': |
1951 | x = skipString(x, e); |
1952 | continue; |
1953 | } |
1954 | x++; |
1955 | } |
1956 | return x; |
1957 | } |
1958 | |
1959 | constexpr void append(char x) |
1960 | { |
1961 | last = x; |
1962 | len++; |
1963 | if (output) |
1964 | *output++ = x; |
1965 | } |
1966 | |
1967 | constexpr void replaceLast(char x) |
1968 | { |
1969 | last = x; |
1970 | if (output) |
1971 | *(output - 1) = x; |
1972 | } |
1973 | |
1974 | constexpr void appendStr(const char *x) |
1975 | { |
1976 | while (*x) |
1977 | append(x: *x++); |
1978 | } |
1979 | |
1980 | constexpr void normalizeIntegerTypes(const char *&begin, const char *end) |
1981 | { |
1982 | int numLong = 0; |
1983 | int numSigned = 0; |
1984 | int numUnsigned = 0; |
1985 | int numInt = 0; |
1986 | int numShort = 0; |
1987 | int numChar = 0; |
1988 | while (begin < end) { |
1989 | if (skipToken(x&: begin, e: end, token: "long")) { |
1990 | numLong++; |
1991 | continue; |
1992 | } |
1993 | if (skipToken(x&: begin, e: end, token: "int")) { |
1994 | numInt++; |
1995 | continue; |
1996 | } |
1997 | if (skipToken(x&: begin, e: end, token: "short")) { |
1998 | numShort++; |
1999 | continue; |
2000 | } |
2001 | if (skipToken(x&: begin, e: end, token: "unsigned")) { |
2002 | numUnsigned++; |
2003 | continue; |
2004 | } |
2005 | if (skipToken(x&: begin, e: end, token: "signed")) { |
2006 | numSigned++; |
2007 | continue; |
2008 | } |
2009 | if (skipToken(x&: begin, e: end, token: "char")) { |
2010 | numChar++; |
2011 | continue; |
2012 | } |
2013 | #ifdef Q_CC_MSVC |
2014 | if (skipToken(begin, end, "__int64")) { |
2015 | numLong = 2; |
2016 | continue; |
2017 | } |
2018 | #endif |
2019 | break; |
2020 | } |
2021 | if (numLong == 2) |
2022 | append(x: 'q'); // q(u)longlong |
2023 | if (numSigned && numChar) |
2024 | appendStr(x: "signed "); |
2025 | else if (numUnsigned) |
2026 | appendStr(x: "u"); |
2027 | if (numChar) |
2028 | appendStr(x: "char"); |
2029 | else if (numShort) |
2030 | appendStr(x: "short"); |
2031 | else if (numLong == 1) |
2032 | appendStr(x: "long"); |
2033 | else if (numLong == 2) |
2034 | appendStr(x: "longlong"); |
2035 | else if (numUnsigned || numSigned || numInt) |
2036 | appendStr(x: "int"); |
2037 | } |
2038 | |
2039 | constexpr void skipStructClassOrEnum(const char *&begin, const char *end) |
2040 | { |
2041 | // discard 'struct', 'class', and 'enum'; they are optional |
2042 | // and we don't want them in the normalized signature |
2043 | skipToken(x&: begin, e: end, token: "struct", msvcKw: true) || skipToken(x&: begin, e: end, token: "class", msvcKw: true) |
2044 | || skipToken(x&: begin, e: end, token: "enum", msvcKw: true); |
2045 | } |
2046 | |
2047 | constexpr void skipQtNamespace(const char *&begin, const char *end) |
2048 | { |
2049 | #ifdef QT_NAMESPACE |
2050 | const char *nsbeg = begin; |
2051 | if (skipToken(nsbeg, end, QT_STRINGIFY(QT_NAMESPACE)) && nsbeg + 2 < end && nsbeg[0] == ':' |
2052 | && nsbeg[1] == ':') { |
2053 | begin = nsbeg + 2; |
2054 | while (begin != end && is_space(*begin)) |
2055 | begin++; |
2056 | } |
2057 | #else |
2058 | Q_UNUSED(begin); |
2059 | Q_UNUSED(end); |
2060 | #endif |
2061 | } |
2062 | |
2063 | public: |
2064 | #if defined(Q_CC_CLANG) || defined (Q_CC_GNU) |
2065 | // this is much simpler than the full type normalization below |
2066 | // the reason is that the signature returned by Q_FUNC_INFO is already |
2067 | // normalized to the largest degree, and we need to do only small adjustments |
2068 | constexpr int normalizeTypeFromSignature(const char *begin, const char *end) |
2069 | { |
2070 | // bail out if there is an anonymous struct |
2071 | std::string_view name(begin, end-begin); |
2072 | #if defined (Q_CC_CLANG) |
2073 | if (name.find(str: "anonymous ") != std::string_view::npos) |
2074 | return normalizeType(begin, end); |
2075 | #endif |
2076 | if (name.find(str: "unnamed ") != std::string_view::npos) |
2077 | return normalizeType(begin, end); |
2078 | while (begin < end) { |
2079 | if (*begin == ' ') { |
2080 | if (last == ',' || last == '>' || last == '<' || last == '*' || last == '&') { |
2081 | ++begin; |
2082 | continue; |
2083 | } |
2084 | } |
2085 | if (last == ' ') { |
2086 | if (*begin == '*' || *begin == '&' || *begin == '(') { |
2087 | replaceLast(x: *begin); |
2088 | ++begin; |
2089 | continue; |
2090 | } |
2091 | } |
2092 | if (!is_ident_char(s: last)) { |
2093 | skipStructClassOrEnum(begin, end); |
2094 | if (begin == end) |
2095 | break; |
2096 | |
2097 | skipQtNamespace(begin, end); |
2098 | if (begin == end) |
2099 | break; |
2100 | |
2101 | normalizeIntegerTypes(begin, end); |
2102 | if (begin == end) |
2103 | break; |
2104 | } |
2105 | append(x: *begin); |
2106 | ++begin; |
2107 | } |
2108 | return len; |
2109 | } |
2110 | #else |
2111 | // MSVC needs the full normalization, as it puts the const in a different |
2112 | // place than we expect |
2113 | constexpr int normalizeTypeFromSignature(const char *begin, const char *end) |
2114 | { return normalizeType(begin, end); } |
2115 | #endif |
2116 | |
2117 | constexpr int normalizeType(const char *begin, const char *end, bool adjustConst = true) |
2118 | { |
2119 | // Trim spaces |
2120 | while (begin != end && is_space(s: *begin)) |
2121 | begin++; |
2122 | while (begin != end && is_space(s: *(end - 1))) |
2123 | end--; |
2124 | |
2125 | // Convert 'char const *' into 'const char *'. Start at index 1, |
2126 | // not 0, because 'const char *' is already OK. |
2127 | const char *cst = begin + 1; |
2128 | if (*begin == '\'' || *begin == '"') |
2129 | cst = skipString(x: begin, e: end); |
2130 | bool seenStar = false; |
2131 | bool hasMiddleConst = false; |
2132 | while (cst < end) { |
2133 | if (*cst == '\"' || (*cst == '\'' && !is_number(s: cst[-1]))) { |
2134 | cst = skipString(x: cst, e: end); |
2135 | if (cst == end) |
2136 | break; |
2137 | } |
2138 | |
2139 | // We mustn't convert 'char * const *' into 'const char **' |
2140 | // and we must beware of 'Bar<const Bla>'. |
2141 | if (*cst == '&' || *cst == '*' || *cst == '[') { |
2142 | seenStar = *cst != '&' || cst != (end - 1); |
2143 | break; |
2144 | } |
2145 | if (*cst == '<') { |
2146 | cst = skipTemplate(x: cst + 1, e: end); |
2147 | if (cst == end) |
2148 | break; |
2149 | } |
2150 | cst++; |
2151 | const char *skipedCst = cst; |
2152 | if (!is_ident_char(s: *(cst - 1)) && skipToken(x&: skipedCst, e: end, token: "const")) { |
2153 | const char *testEnd = end; |
2154 | while (skipedCst < testEnd--) { |
2155 | if (*testEnd == '*' || *testEnd == '[' |
2156 | || (*testEnd == '&' && testEnd != (end - 1))) { |
2157 | seenStar = true; |
2158 | break; |
2159 | } |
2160 | if (*testEnd == '>') |
2161 | break; |
2162 | } |
2163 | if (adjustConst && !seenStar) { |
2164 | if (*(end - 1) == '&') |
2165 | end--; |
2166 | } else { |
2167 | appendStr(x: "const "); |
2168 | } |
2169 | normalizeType(begin, end: cst, adjustConst: false); |
2170 | begin = skipedCst; |
2171 | hasMiddleConst = true; |
2172 | break; |
2173 | } |
2174 | } |
2175 | if (skipToken(x&: begin, e: end, token: "const")) { |
2176 | if (adjustConst && !seenStar) { |
2177 | if (*(end - 1) == '&') |
2178 | end--; |
2179 | } else { |
2180 | appendStr(x: "const "); |
2181 | } |
2182 | } |
2183 | if (seenStar && adjustConst) { |
2184 | const char *e = end; |
2185 | if (*(end - 1) == '&' && *(end - 2) != '&') |
2186 | e--; |
2187 | while (begin != e && is_space(s: *(e - 1))) |
2188 | e--; |
2189 | const char *token = "tsnoc"; // 'const' reverse, to check if it ends with const |
2190 | while (*token && begin != e && *(--e) == *token++) |
2191 | ; |
2192 | if (!*token && begin != e && !is_ident_char(s: *(e - 1))) { |
2193 | while (begin != e && is_space(s: *(e - 1))) |
2194 | e--; |
2195 | end = e; |
2196 | } |
2197 | } |
2198 | |
2199 | skipStructClassOrEnum(begin, end); |
2200 | skipQtNamespace(begin, end); |
2201 | |
2202 | if (skipToken(x&: begin, e: end, token: "QVector")) { |
2203 | // Replace QVector by QList |
2204 | appendStr(x: "QList"); |
2205 | } |
2206 | |
2207 | if (skipToken(x&: begin, e: end, token: "QPair")) { |
2208 | // replace QPair by std::pair |
2209 | appendStr(x: "std::pair"); |
2210 | } |
2211 | |
2212 | if (!hasMiddleConst) |
2213 | // Normalize the integer types |
2214 | normalizeIntegerTypes(begin, end); |
2215 | |
2216 | bool spaceSkiped = true; |
2217 | while (begin != end) { |
2218 | char c = *begin++; |
2219 | if (is_space(s: c)) { |
2220 | spaceSkiped = true; |
2221 | } else if ((c == '\'' && !is_number(s: last)) || c == '\"') { |
2222 | begin--; |
2223 | auto x = skipString(x: begin, e: end); |
2224 | while (begin < x) |
2225 | append(x: *begin++); |
2226 | } else { |
2227 | if (spaceSkiped && is_ident_char(s: last) && is_ident_char(s: c)) |
2228 | append(x: ' '); |
2229 | append(x: c); |
2230 | spaceSkiped = false; |
2231 | if (c == '<') { |
2232 | do { |
2233 | // template recursion |
2234 | const char *tpl = skipTemplate(x: begin, e: end, stopAtComa: true); |
2235 | normalizeType(begin, end: tpl, adjustConst: false); |
2236 | if (tpl == end) |
2237 | return len; |
2238 | append(x: *tpl); |
2239 | begin = tpl; |
2240 | } while (*begin++ == ','); |
2241 | } |
2242 | } |
2243 | } |
2244 | return len; |
2245 | } |
2246 | }; |
2247 | |
2248 | // Normalize the type between begin and end, and store the data in the output. Returns the length. |
2249 | // The idea is to first run this function with nullptr as output to allocate the output with the |
2250 | // size |
2251 | constexpr int qNormalizeType(const char *begin, const char *end, char *output) |
2252 | { |
2253 | return QTypeNormalizer { .output: output }.normalizeType(begin, end); |
2254 | } |
2255 | |
2256 | template<typename T> |
2257 | struct is_std_pair : std::false_type {}; |
2258 | |
2259 | template <typename T1_, typename T2_> |
2260 | struct is_std_pair<std::pair<T1_, T2_>> : std::true_type { |
2261 | using T1 = T1_; |
2262 | using T2 = T2_; |
2263 | }; |
2264 | |
2265 | namespace TypeNameHelper { |
2266 | template<typename T> |
2267 | constexpr auto typenameHelper() |
2268 | { |
2269 | if constexpr (is_std_pair<T>::value) { |
2270 | using T1 = typename is_std_pair<T>::T1; |
2271 | using T2 = typename is_std_pair<T>::T2; |
2272 | std::remove_const_t<std::conditional_t<bool (QMetaTypeId2<T1>::IsBuiltIn), typename QMetaTypeId2<T1>::NameAsArrayType, decltype(typenameHelper<T1>())>> t1Name {}; |
2273 | std::remove_const_t<std::conditional_t<bool (QMetaTypeId2<T2>::IsBuiltIn), typename QMetaTypeId2<T2>::NameAsArrayType, decltype(typenameHelper<T2>())>> t2Name {}; |
2274 | if constexpr (bool (QMetaTypeId2<T1>::IsBuiltIn) ) { |
2275 | t1Name = QMetaTypeId2<T1>::nameAsArray; |
2276 | } else { |
2277 | t1Name = typenameHelper<T1>(); |
2278 | } |
2279 | if constexpr (bool(QMetaTypeId2<T2>::IsBuiltIn)) { |
2280 | t2Name = QMetaTypeId2<T2>::nameAsArray; |
2281 | } else { |
2282 | t2Name = typenameHelper<T2>(); |
2283 | } |
2284 | constexpr auto nonTypeDependentLen = sizeof("std::pair<,>"); |
2285 | constexpr auto t1Len = t1Name.size() - 1; |
2286 | constexpr auto t2Len = t2Name.size() - 1; |
2287 | constexpr auto length = nonTypeDependentLen + t1Len + t2Len; |
2288 | std::array<char, length + 1> result {}; |
2289 | constexpr auto prefix = "std::pair<"; |
2290 | int currentLength = 0; |
2291 | for (; currentLength < int(sizeof("std::pair<") - 1); ++currentLength) |
2292 | result[currentLength] = prefix[currentLength]; |
2293 | for (int i = 0; i < int(t1Len); ++currentLength, ++i) |
2294 | result[currentLength] = t1Name[i]; |
2295 | result[currentLength++] = ','; |
2296 | for (int i = 0; i < int(t2Len); ++currentLength, ++i) |
2297 | result[currentLength] = t2Name[i]; |
2298 | result[currentLength++] = '>'; |
2299 | result[currentLength++] = '\0'; |
2300 | return result; |
2301 | } else { |
2302 | constexpr auto prefix = sizeof( |
2303 | #ifdef QT_NAMESPACE |
2304 | QT_STRINGIFY(QT_NAMESPACE) "::" |
2305 | #endif |
2306 | #if defined(Q_CC_MSVC) && defined(Q_CC_CLANG) |
2307 | "auto __cdecl QtPrivate::TypeNameHelper::typenameHelper(void) [T = " |
2308 | #elif defined(Q_CC_MSVC) |
2309 | "auto __cdecl QtPrivate::TypeNameHelper::typenameHelper<" |
2310 | #elif defined(Q_CC_CLANG) |
2311 | "auto QtPrivate::TypeNameHelper::typenameHelper() [T = " |
2312 | #elif defined(Q_CC_GHS) |
2313 | "auto QtPrivate::TypeNameHelper::typenameHelper<T>()[with T=" |
2314 | #else |
2315 | "constexpr auto QtPrivate::TypeNameHelper::typenameHelper() [with T = " |
2316 | #endif |
2317 | ) - 1; |
2318 | #if defined(Q_CC_MSVC) && !defined(Q_CC_CLANG) |
2319 | constexpr int suffix = sizeof(">(void)"); |
2320 | #else |
2321 | constexpr int suffix = sizeof("]"); |
2322 | #endif |
2323 | |
2324 | #if defined(Q_CC_GNU_ONLY) && Q_CC_GNU_ONLY < 804 |
2325 | auto func = Q_FUNC_INFO; |
2326 | const char *begin = func + prefix; |
2327 | const char *end = func + sizeof(Q_FUNC_INFO) - suffix; |
2328 | // This is an upper bound of the size since the normalized signature should always be smaller |
2329 | constexpr int len = sizeof(Q_FUNC_INFO) - suffix - prefix; |
2330 | #else |
2331 | constexpr auto func = Q_FUNC_INFO; |
2332 | constexpr const char *begin = func + prefix; |
2333 | constexpr const char *end = func + sizeof(Q_FUNC_INFO) - suffix; |
2334 | constexpr int len = QTypeNormalizer{ .output: nullptr }.normalizeTypeFromSignature(begin, end); |
2335 | #endif |
2336 | std::array<char, len + 1> result {}; |
2337 | QTypeNormalizer{ result.data() }.normalizeTypeFromSignature(begin, end); |
2338 | return result; |
2339 | } |
2340 | } |
2341 | } // namespace TypeNameHelper |
2342 | using TypeNameHelper::typenameHelper; |
2343 | |
2344 | template<typename T, typename = void> |
2345 | struct BuiltinMetaType : std::integral_constant<int, 0> |
2346 | { |
2347 | }; |
2348 | template<typename T> |
2349 | struct BuiltinMetaType<T, std::enable_if_t<QMetaTypeId2<T>::IsBuiltIn>> |
2350 | : std::integral_constant<int, QMetaTypeId2<T>::MetaType> |
2351 | { |
2352 | }; |
2353 | |
2354 | template<typename T, bool = (QTypeTraits::has_operator_equal_v<T> && !std::is_pointer_v<T>)> |
2355 | struct QEqualityOperatorForType |
2356 | { |
2357 | QT_WARNING_PUSH |
2358 | QT_WARNING_DISABLE_FLOAT_COMPARE |
2359 | static bool equals(const QMetaTypeInterface *, const void *a, const void *b) |
2360 | { return *reinterpret_cast<const T *>(a) == *reinterpret_cast<const T *>(b); } |
2361 | QT_WARNING_POP |
2362 | }; |
2363 | |
2364 | template<typename T> |
2365 | struct QEqualityOperatorForType <T, false> |
2366 | { |
2367 | static constexpr QMetaTypeInterface::EqualsFn equals = nullptr; |
2368 | }; |
2369 | |
2370 | template<typename T, bool = (QTypeTraits::has_operator_less_than_v<T> && !std::is_pointer_v<T>)> |
2371 | struct QLessThanOperatorForType |
2372 | { |
2373 | static bool lessThan(const QMetaTypeInterface *, const void *a, const void *b) |
2374 | { return *reinterpret_cast<const T *>(a) < *reinterpret_cast<const T *>(b); } |
2375 | }; |
2376 | |
2377 | template<typename T> |
2378 | struct QLessThanOperatorForType <T, false> |
2379 | { |
2380 | static constexpr QMetaTypeInterface::LessThanFn lessThan = nullptr; |
2381 | }; |
2382 | |
2383 | template<typename T, bool = (QTypeTraits::has_ostream_operator_v<QDebug, T> && !std::is_pointer_v<T>)> |
2384 | struct QDebugStreamOperatorForType |
2385 | { |
2386 | static void debugStream(const QMetaTypeInterface *, QDebug &dbg, const void *a) |
2387 | { dbg << *reinterpret_cast<const T *>(a); } |
2388 | }; |
2389 | |
2390 | template<typename T> |
2391 | struct QDebugStreamOperatorForType <T, false> |
2392 | { |
2393 | static constexpr QMetaTypeInterface::DebugStreamFn debugStream = nullptr; |
2394 | }; |
2395 | |
2396 | template<typename T, bool = QTypeTraits::has_stream_operator_v<QDataStream, T>> |
2397 | struct QDataStreamOperatorForType |
2398 | { |
2399 | static constexpr QMetaTypeInterface::DataStreamOutFn dataStreamOut = nullptr; |
2400 | static constexpr QMetaTypeInterface::DataStreamInFn dataStreamIn = nullptr; |
2401 | }; |
2402 | |
2403 | #ifndef QT_NO_DATASTREAM |
2404 | template<typename T> |
2405 | struct QDataStreamOperatorForType <T, true> |
2406 | { |
2407 | static void dataStreamOut(const QMetaTypeInterface *, QDataStream &ds, const void *a) |
2408 | { ds << *reinterpret_cast<const T *>(a); } |
2409 | static void dataStreamIn(const QMetaTypeInterface *, QDataStream &ds, void *a) |
2410 | { ds >> *reinterpret_cast<T *>(a); } |
2411 | }; |
2412 | #endif |
2413 | |
2414 | // Performance optimization: |
2415 | // |
2416 | // Don't add all these symbols to the dynamic symbol tables on ELF systems and |
2417 | // on Darwin. Each library is going to have a copy anyway and QMetaType already |
2418 | // copes with some of these being "hidden" (see QMetaType::idHelper()). We may |
2419 | // as well let the linker know it can always use the local copy. |
2420 | // |
2421 | // This is currently not enabled for GCC due to |
2422 | // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106023 |
2423 | |
2424 | #if !defined(Q_OS_WIN) && defined(Q_CC_CLANG) |
2425 | # pragma GCC visibility push(hidden) |
2426 | #endif |
2427 | |
2428 | template<typename S> |
2429 | class QMetaTypeForType |
2430 | { |
2431 | public: |
2432 | static constexpr decltype(typenameHelper<S>()) name = typenameHelper<S>(); |
2433 | static constexpr unsigned Flags = QMetaTypeTypeFlags<S>::Flags; |
2434 | |
2435 | static constexpr QMetaTypeInterface::DefaultCtrFn getDefaultCtr() |
2436 | { |
2437 | if constexpr (std::is_default_constructible_v<S> && !QTypeInfo<S>::isValueInitializationBitwiseZero) { |
2438 | return [](const QMetaTypeInterface *, void *addr) { new (addr) S(); }; |
2439 | } else { |
2440 | return nullptr; |
2441 | } |
2442 | } |
2443 | |
2444 | static constexpr QMetaTypeInterface::CopyCtrFn getCopyCtr() |
2445 | { |
2446 | if constexpr (std::is_copy_constructible_v<S> && !std::is_trivially_copy_constructible_v<S>) { |
2447 | return [](const QMetaTypeInterface *, void *addr, const void *other) { |
2448 | new (addr) S(*reinterpret_cast<const S *>(other)); |
2449 | }; |
2450 | } else { |
2451 | return nullptr; |
2452 | } |
2453 | } |
2454 | |
2455 | static constexpr QMetaTypeInterface::MoveCtrFn getMoveCtr() |
2456 | { |
2457 | if constexpr (std::is_move_constructible_v<S> && !std::is_trivially_move_constructible_v<S>) { |
2458 | return [](const QMetaTypeInterface *, void *addr, void *other) { |
2459 | new (addr) S(std::move(*reinterpret_cast<S *>(other))); |
2460 | }; |
2461 | } else { |
2462 | return nullptr; |
2463 | } |
2464 | } |
2465 | |
2466 | static constexpr QMetaTypeInterface::DtorFn getDtor() |
2467 | { |
2468 | if constexpr (std::is_destructible_v<S> && !std::is_trivially_destructible_v<S>) |
2469 | return [](const QMetaTypeInterface *, void *addr) { |
2470 | reinterpret_cast<S *>(addr)->~S(); |
2471 | }; |
2472 | else |
2473 | return nullptr; |
2474 | } |
2475 | |
2476 | static constexpr QMetaTypeInterface::LegacyRegisterOp getLegacyRegister() |
2477 | { |
2478 | if constexpr (QMetaTypeId2<S>::Defined && !QMetaTypeId2<S>::IsBuiltIn) { |
2479 | return []() { QMetaTypeId2<S>::qt_metatype_id(); }; |
2480 | } else { |
2481 | return nullptr; |
2482 | } |
2483 | } |
2484 | |
2485 | static constexpr const char *getName() |
2486 | { |
2487 | if constexpr (bool(QMetaTypeId2<S>::IsBuiltIn)) { |
2488 | return QMetaTypeId2<S>::nameAsArray.data(); |
2489 | } else { |
2490 | return name.data(); |
2491 | } |
2492 | } |
2493 | }; |
2494 | |
2495 | template<typename T> |
2496 | struct QMetaTypeInterfaceWrapper |
2497 | { |
2498 | // if the type ID for T is known at compile-time, then we can declare |
2499 | // the QMetaTypeInterface object const; otherwise, we declare it as |
2500 | // non-const and the .typeId is updated by QMetaType::idHelper(). |
2501 | static constexpr bool IsConstMetaTypeInterface = !!BuiltinMetaType<T>::value; |
2502 | using InterfaceType = std::conditional_t<IsConstMetaTypeInterface, const QMetaTypeInterface, NonConstMetaTypeInterface>; |
2503 | |
2504 | static inline InterfaceType metaType = { |
2505 | /*.revision=*/ QMetaTypeInterface::CurrentRevision, |
2506 | /*.alignment=*/ alignof(T), |
2507 | /*.size=*/ sizeof(T), |
2508 | /*.flags=*/ QMetaTypeForType<T>::Flags, |
2509 | /*.typeId=*/ BuiltinMetaType<T>::value, |
2510 | /*.metaObjectFn=*/ MetaObjectForType<T>::metaObjectFunction, |
2511 | /*.name=*/ QMetaTypeForType<T>::getName(), |
2512 | /*.defaultCtr=*/ QMetaTypeForType<T>::getDefaultCtr(), |
2513 | /*.copyCtr=*/ QMetaTypeForType<T>::getCopyCtr(), |
2514 | /*.moveCtr=*/ QMetaTypeForType<T>::getMoveCtr(), |
2515 | /*.dtor=*/ QMetaTypeForType<T>::getDtor(), |
2516 | /*.equals=*/ QEqualityOperatorForType<T>::equals, |
2517 | /*.lessThan=*/ QLessThanOperatorForType<T>::lessThan, |
2518 | /*.debugStream=*/ QDebugStreamOperatorForType<T>::debugStream, |
2519 | /*.dataStreamOut=*/ QDataStreamOperatorForType<T>::dataStreamOut, |
2520 | /*.dataStreamIn=*/ QDataStreamOperatorForType<T>::dataStreamIn, |
2521 | /*.legacyRegisterOp=*/ QMetaTypeForType<T>::getLegacyRegister() |
2522 | }; |
2523 | }; |
2524 | |
2525 | #if !defined(Q_OS_WIN) && defined(Q_CC_CLANG) |
2526 | # pragma GCC visibility pop |
2527 | #endif |
2528 | |
2529 | template<> |
2530 | class QMetaTypeInterfaceWrapper<void> |
2531 | { |
2532 | public: |
2533 | static constexpr QMetaTypeInterface metaType = |
2534 | { |
2535 | /*.revision=*/ .revision: 0, |
2536 | /*.alignment=*/ .alignment: 0, |
2537 | /*.size=*/ .size: 0, |
2538 | /*.flags=*/ .flags: 0, |
2539 | /*.typeId=*/ .typeId: BuiltinMetaType<void>::value, |
2540 | /*.metaObjectFn=*/ .metaObjectFn: nullptr, |
2541 | /*.name=*/ .name: "void", |
2542 | /*.defaultCtr=*/ .defaultCtr: nullptr, |
2543 | /*.copyCtr=*/ .copyCtr: nullptr, |
2544 | /*.moveCtr=*/ .moveCtr: nullptr, |
2545 | /*.dtor=*/ .dtor: nullptr, |
2546 | /*.equals=*/ .equals: nullptr, |
2547 | /*.lessThan=*/ .lessThan: nullptr, |
2548 | /*.debugStream=*/ .debugStream: nullptr, |
2549 | /*.dataStreamOut=*/ .dataStreamOut: nullptr, |
2550 | /*.dataStreamIn=*/ .dataStreamIn: nullptr, |
2551 | /*.legacyRegisterOp=*/ .legacyRegisterOp: nullptr |
2552 | }; |
2553 | }; |
2554 | |
2555 | /* |
2556 | MSVC instantiates extern templates |
2557 | (https://developercommunity.visualstudio.com/t/c11-extern-templates-doesnt-work-for-class-templat/157868) |
2558 | |
2559 | The INTEGRITY compiler apparently does too. |
2560 | |
2561 | On Windows (with other compilers or whenever MSVC is fixed), we can't declare |
2562 | QMetaTypeInterfaceWrapper with __declspec(dllimport) because taking its |
2563 | address is not a core constant expression. |
2564 | */ |
2565 | #if !defined(QT_BOOTSTRAPPED) && !defined(Q_CC_MSVC) && !defined(Q_OS_INTEGRITY) |
2566 | |
2567 | #ifdef QT_NO_DATA_RELOCATION |
2568 | # define QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER(TypeName, Id, Name) \ |
2569 | extern template class Q_CORE_EXPORT QMetaTypeForType<Name>; |
2570 | #else |
2571 | # define QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER(TypeName, Id, Name) \ |
2572 | extern template class Q_CORE_EXPORT QMetaTypeForType<Name>; \ |
2573 | extern template struct Q_CORE_EXPORT QMetaTypeInterfaceWrapper<Name>; |
2574 | #endif |
2575 | |
2576 | QT_FOR_EACH_STATIC_PRIMITIVE_NON_VOID_TYPE(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER) |
2577 | QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER) |
2578 | QT_FOR_EACH_STATIC_CORE_CLASS(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER) |
2579 | QT_FOR_EACH_STATIC_CORE_POINTER(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER) |
2580 | QT_FOR_EACH_STATIC_CORE_TEMPLATE(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER) |
2581 | #undef QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER |
2582 | #endif |
2583 | |
2584 | template<typename T> |
2585 | struct qRemovePointerLike |
2586 | { |
2587 | using type = std::remove_pointer_t<T>; |
2588 | }; |
2589 | |
2590 | #define Q_REMOVE_POINTER_LIKE_IMPL(Pointer) \ |
2591 | template <typename T> \ |
2592 | struct qRemovePointerLike<Pointer<T>> \ |
2593 | { \ |
2594 | using type = T; \ |
2595 | }; |
2596 | |
2597 | QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(Q_REMOVE_POINTER_LIKE_IMPL) |
2598 | template<typename T> |
2599 | using qRemovePointerLike_t = typename qRemovePointerLike<T>::type; |
2600 | #undef Q_REMOVE_POINTER_LIKE_IMPL |
2601 | |
2602 | template<typename T, typename ForceComplete_> |
2603 | struct TypeAndForceComplete |
2604 | { |
2605 | using type = T; |
2606 | using ForceComplete = ForceComplete_; |
2607 | }; |
2608 | |
2609 | template<typename T> |
2610 | constexpr const QMetaTypeInterface *qMetaTypeInterfaceForType() |
2611 | { |
2612 | // don't check the type is suitable here |
2613 | using Ty = typename MetatypeDecay<T>::type; |
2614 | return &QMetaTypeInterfaceWrapper<Ty>::metaType; |
2615 | } |
2616 | |
2617 | template<typename Unique, typename TypeCompletePair> |
2618 | constexpr const QMetaTypeInterface *qTryMetaTypeInterfaceForType() |
2619 | { |
2620 | using T = typename TypeCompletePair::type; |
2621 | using ForceComplete = typename TypeCompletePair::ForceComplete; |
2622 | using Ty = typename MetatypeDecay<T>::type; |
2623 | using Tz = qRemovePointerLike_t<Ty>; |
2624 | |
2625 | if constexpr (std::is_void_v<Tz>) { |
2626 | // early out to avoid expanding the rest of the templates |
2627 | return &QMetaTypeInterfaceWrapper<Ty>::metaType; |
2628 | } else if constexpr (ForceComplete::value) { |
2629 | checkTypeIsSuitableForMetaType<Ty>(); |
2630 | return &QMetaTypeInterfaceWrapper<Ty>::metaType; |
2631 | } else if constexpr (std::is_reference_v<Tz>) { |
2632 | return nullptr; |
2633 | } else if constexpr (!is_complete<Tz, Unique>::value) { |
2634 | return nullptr; |
2635 | } else { |
2636 | // don't check the type is suitable here |
2637 | return &QMetaTypeInterfaceWrapper<Ty>::metaType; |
2638 | } |
2639 | } |
2640 | |
2641 | } // namespace QtPrivate |
2642 | |
2643 | template<typename T> |
2644 | constexpr QMetaType QMetaType::fromType() |
2645 | { |
2646 | QtPrivate::checkTypeIsSuitableForMetaType<T>(); |
2647 | return QMetaType(QtPrivate::qMetaTypeInterfaceForType<T>()); |
2648 | } |
2649 | |
2650 | constexpr qsizetype QMetaType::sizeOf() const |
2651 | { |
2652 | return d_ptr ? d_ptr->size : 0; |
2653 | } |
2654 | |
2655 | constexpr qsizetype QMetaType::alignOf() const |
2656 | { |
2657 | return d_ptr ? d_ptr->alignment : 0; |
2658 | } |
2659 | |
2660 | constexpr QMetaType::TypeFlags QMetaType::flags() const |
2661 | { |
2662 | return d_ptr ? TypeFlags(d_ptr->flags) : TypeFlags{}; |
2663 | } |
2664 | |
2665 | constexpr const QMetaObject *QMetaType::metaObject() const |
2666 | { |
2667 | return d_ptr && d_ptr->metaObjectFn ? d_ptr->metaObjectFn(d_ptr) : nullptr; |
2668 | } |
2669 | |
2670 | template<typename... T> |
2671 | constexpr const QtPrivate::QMetaTypeInterface *const qt_metaTypeArray[] = { |
2672 | /* |
2673 | Unique in qTryMetaTypeInterfaceForType does not have to be unique here |
2674 | as we require _all_ types here to be actually complete. |
2675 | We just want to have the additional type processing that exist in |
2676 | QtPrivate::qTryMetaTypeInterfaceForType as opposed to the normal |
2677 | QtPrivate::qMetaTypeInterfaceForType used in QMetaType::fromType |
2678 | */ |
2679 | QtPrivate::qTryMetaTypeInterfaceForType<void, QtPrivate::TypeAndForceComplete<T, std::true_type>>()... |
2680 | }; |
2681 | |
2682 | constexpr const char *QMetaType::name() const |
2683 | { |
2684 | return d_ptr ? d_ptr->name : nullptr; |
2685 | } |
2686 | |
2687 | template<typename Unique,typename... T> |
2688 | constexpr const QtPrivate::QMetaTypeInterface *const qt_incomplete_metaTypeArray[] = { |
2689 | QtPrivate::qTryMetaTypeInterfaceForType<Unique, T>()... |
2690 | }; |
2691 | |
2692 | inline size_t qHash(QMetaType type, size_t seed = 0) |
2693 | { |
2694 | // We cannot use d_ptr here since the same type in different DLLs |
2695 | // might result in different pointers! |
2696 | return qHash(key: type.id(), seed); |
2697 | } |
2698 | |
2699 | QT_END_NAMESPACE |
2700 | |
2701 | QT_DECL_METATYPE_EXTERN_TAGGED(QtMetaTypePrivate::QPairVariantInterfaceImpl, |
2702 | QPairVariantInterfaceImpl, Q_CORE_EXPORT) |
2703 | |
2704 | #endif // QMETATYPE_H |
2705 |
Definitions
- QMetaTypeInterface
- CurrentRevision
- convertImplicit
- IsQFlags
- IsQFlags
- IsEnumOrFlags
- QMetaType
- Type
- TypeFlag
- type
- type
- typeName
- sizeOf
- typeFlags
- metaObjectForType
- create
- destroy
- construct
- destruct
- QMetaType
- QMetaType
- registerType
- id
- isDefaultConstructible
- isCopyConstructible
- isMoveConstructible
- isDestructible
- save
- load
- comparesEqual
- debugStream
- hasRegisteredDebugStreamOperator
- hasRegisteredDebugStreamOperator
- registerConverter
- registerConverter
- registerMutableView
- registerConverter
- registerConverter
- registerMutableView
- registerConverterImpl
- registerMutableViewImpl
- convert
- compare
- equals
- hasRegisteredConverterFunction
- hasRegisteredMutableViewFunction
- iface
- iface
- registerHelper
- QPairVariantInterfaceImpl
- getFirstImpl
- getSecondImpl
- QPairVariantInterfaceImpl
- QPairVariantInterfaceImpl
- first
- second
- QPairVariantInterfaceConvertFunctor
- operator()
- is_complete_helper
- is_complete
- MetatypeDecay
- MetatypeDecay
- MetatypeDecay
- IsPointerDeclaredOpaque
- IsPointerDeclaredOpaque
- IsPointerDeclaredOpaque
- IsPointerToTypeDerivedFromQObject
- IsPointerToTypeDerivedFromQObject
- IsPointerToTypeDerivedFromQObject
- IsPointerToTypeDerivedFromQObject
- IsPointerToTypeDerivedFromQObject
- IsGadgetHelper
- IsGadgetHelper
- IsPointerToGadgetHelper
- IsPointerToGadgetHelper
- IsQEnumHelper
- IsQEnumHelper
- MetaObjectForType
- value
- metaObjectFunction
- MetaObjectForType
- value
- metaObjectFunction
- MetaObjectForType
- value
- metaObjectFunction
- MetaObjectForType
- value
- metaObjectFunction
- MetaObjectForType
- value
- metaObjectFunction
- IsSharedPointerToTypeDerivedFromQObject
- IsSharedPointerToTypeDerivedFromQObject
- IsWeakPointerToTypeDerivedFromQObject
- IsWeakPointerToTypeDerivedFromQObject
- IsTrackingPointerToTypeDerivedFromQObject
- IsTrackingPointerToTypeDerivedFromQObject
- IsSequentialContainer
- IsAssociativeContainer
- SequentialContainerTransformationHelper
- registerConverter
- registerMutableView
- SequentialValueTypeIsMetaType
- registerConverter
- registerMutableView
- SequentialContainerTransformationHelper
- AssociativeContainerTransformationHelper
- registerConverter
- registerMutableView
- AssociativeKeyTypeIsMetaType
- registerConverter
- registerMutableView
- AssociativeMappedTypeIsMetaType
- registerConverter
- registerMutableView
- AssociativeContainerTransformationHelper
- IsMetaTypePair
- registerConverter
- IsMetaTypePair
- IsPair
- registerConverter
- IsPair
- MetaTypePairHelper
- MetaTypeSmartPointerHelper
- registerConverter
- MetaTypeQFutureHelper
- registerConverter
- checkTypeIsSuitableForMetaType
- QMetaTypeIdQObject
- QMetaTypeId
- QMetaTypeId2
- qt_metatype_id
- QMetaTypeId2
- QMetaTypeId2
- qt_metatype_id
- QMetaTypeIdHelper
- qt_metatype_id
- QMetaTypeIdHelper
- qt_metatype_id
- IsPointerToTypeDerivedFromQObject
- IsQmlListType
- IsUnsignedEnum
- IsUnsignedEnum
- QMetaTypeTypeFlags
- MetaTypeDefinedHelper
- DefinedType
- QSmartPointerConvertFunctor
- operator()
- QSmartPointerConvertFunctor
- operator()
- qRegisterNormalizedMetaTypeImplementation
- qRegisterNormalizedMetaType
- qRegisterNormalizedMetaType
- qRegisterMetaType
- qMetaTypeId
- qRegisterMetaType
- qRegisterMetaType
- QMetaTypeIdQObject
- qt_metatype_id
- QMetaTypeIdQObject
- qt_metatype_id
- QMetaTypeIdQObject
- qt_metatype_id
- QMetaTypeIdQObject
- qt_metatype_id
- QMetaTypeId
- qt_metatype_id
- QMetaTypeId2
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- nameAsArray
- QMetaTypeId
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- QMetaTypeId
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- SharedPointerMetaTypeIdHelper
- qt_metatype_id
- SharedPointerMetaTypeIdHelper
- qt_metatype_id
- qt_metatype_id
- qt_metatype_id
- MetaTypeSmartPointerHelper
- registerConverter
- registerConverter
- registerConverter
- QMetaTypeId
- IsSequentialContainer
- IsAssociativeContainer
- registerConverter
- QSequentialIterableConvertFunctor
- operator()
- QSequentialIterableMutableViewFunctor
- operator()
- SequentialValueTypeIsMetaType
- registerConverter
- registerMutableView
- QAssociativeIterableConvertFunctor
- operator()
- QAssociativeIterableMutableViewFunctor
- operator()
- AssociativeKeyTypeIsMetaType
- registerConverter
- registerMutableView
- QTypeNormalizer
- is_ident_char
- is_space
- is_number
- starts_with_token
- skipToken
- skipString
- skipTemplate
- append
- replaceLast
- appendStr
- normalizeIntegerTypes
- skipStructClassOrEnum
- skipQtNamespace
- normalizeTypeFromSignature
- normalizeType
- qNormalizeType
- is_std_pair
- is_std_pair
- typenameHelper
- BuiltinMetaType
- BuiltinMetaType
- QEqualityOperatorForType
- equals
- QEqualityOperatorForType
- equals
- QLessThanOperatorForType
- lessThan
- QLessThanOperatorForType
- lessThan
- QDebugStreamOperatorForType
- debugStream
- QDebugStreamOperatorForType
- debugStream
- QDataStreamOperatorForType
- dataStreamOut
- dataStreamIn
- QDataStreamOperatorForType
- dataStreamOut
- dataStreamIn
- QMetaTypeForType
- name
- Flags
- getDefaultCtr
- getCopyCtr
- getMoveCtr
- getDtor
- getLegacyRegister
- getName
- QMetaTypeInterfaceWrapper
- IsConstMetaTypeInterface
- metaType
- QMetaTypeInterfaceWrapper
- metaType
- QMetaTypeForType
- QMetaTypeInterfaceWrapper
- qRemovePointerLike
- qRemovePointerLike
- TypeAndForceComplete
- qMetaTypeInterfaceForType
- qTryMetaTypeInterfaceForType
- fromType
- sizeOf
- alignOf
- flags
- metaObject
- qt_metaTypeArray
- name
- qt_incomplete_metaTypeArray
Learn Advanced QML with KDAB
Find out more