Do not load plugin from the $PWD
[mirror/qt/qtbase.git] / src / corelib / kernel / qvariant.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com>
5 ** Contact: http://www.qt.io/licensing/
6 **
7 ** This file is part of the QtCore module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL21$
10 ** Commercial License Usage
11 ** Licensees holding valid commercial Qt licenses may use this file in
12 ** accordance with the commercial license agreement provided with the
13 ** Software or, alternatively, in accordance with the terms contained in
14 ** a written agreement between you and The Qt Company. For licensing terms
15 ** and conditions see http://www.qt.io/terms-conditions. For further
16 ** information use the contact form at http://www.qt.io/contact-us.
17 **
18 ** GNU Lesser General Public License Usage
19 ** Alternatively, this file may be used under the terms of the GNU Lesser
20 ** General Public License version 2.1 or version 3 as published by the Free
21 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
22 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
23 ** following information to ensure the GNU Lesser General Public License
24 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
25 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
26 **
27 ** As a special exception, The Qt Company gives you certain additional
28 ** rights. These rights are described in The Qt Company LGPL Exception
29 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
30 **
31 ** $QT_END_LICENSE$
32 **
33 ****************************************************************************/
34
35 #include "qvariant.h"
36 #include "qbitarray.h"
37 #include "qbytearray.h"
38 #include "qdatastream.h"
39 #include "qdebug.h"
40 #include "qmap.h"
41 #include "qdatetime.h"
42 #include "qeasingcurve.h"
43 #include "qlist.h"
44 #include "qregularexpression.h"
45 #include "qstring.h"
46 #include "qstringlist.h"
47 #include "qurl.h"
48 #include "qlocale.h"
49 #include "quuid.h"
50 #ifndef QT_BOOTSTRAPPED
51 #include "qabstractitemmodel.h"
52 #include "qjsonvalue.h"
53 #include "qjsonobject.h"
54 #include "qjsonarray.h"
55 #include "qjsondocument.h"
56 #include "qbytearraylist.h"
57 #endif
58 #include "private/qvariant_p.h"
59 #include "qmetatype_p.h"
60 #include <qmetaobject.h>
61
62 #ifndef QT_NO_GEOM_VARIANT
63 #include "qsize.h"
64 #include "qpoint.h"
65 #include "qrect.h"
66 #include "qline.h"
67 #endif
68
69 #include <float.h>
70 #include <cstring>
71
72 QT_BEGIN_NAMESPACE
73
74 #ifndef DBL_MANT_DIG
75 #  define DBL_MANT_DIG  53
76 #endif
77 #ifndef FLT_MANT_DIG
78 #  define FLT_MANT_DIG  24
79 #endif
80
81 const int log10_2_10000 = 30103;    // log10(2) * 100000
82 // same as C++11 std::numeric_limits<T>::max_digits10
83 const int max_digits10_double = (DBL_MANT_DIG * log10_2_10000) / 100000 + 2;
84 const int max_digits10_float = (FLT_MANT_DIG * log10_2_10000) / 100000 + 2;
85
86 namespace {
87 class HandlersManager
88 {
89     static const QVariant::Handler *Handlers[QModulesPrivate::ModulesCount];
90 public:
91     const QVariant::Handler *operator[] (const uint typeId) const
92     {
93         return Handlers[QModulesPrivate::moduleForType(typeId)];
94     }
95
96     void registerHandler(const QModulesPrivate::Names name, const QVariant::Handler *handler)
97     {
98         Handlers[name] = handler;
99     }
100 };
101 }  // namespace
102
103 namespace {
104 struct CoreTypesFilter {
105     template<typename T>
106     struct Acceptor {
107         static const bool IsAccepted = QModulesPrivate::QTypeModuleInfo<T>::IsCore && QtMetaTypePrivate::TypeDefinition<T>::IsAvailable;
108     };
109 };
110 } // annonymous
111
112 namespace { // annonymous used to hide QVariant handlers
113
114 static void construct(QVariant::Private *x, const void *copy)
115 {
116     QVariantConstructor<CoreTypesFilter> constructor(x, copy);
117     QMetaTypeSwitcher::switcher<void>(constructor, x->type, 0);
118 }
119
120 static void clear(QVariant::Private *d)
121 {
122     QVariantDestructor<CoreTypesFilter> cleaner(d);
123     QMetaTypeSwitcher::switcher<void>(cleaner, d->type, 0);
124 }
125
126 static bool isNull(const QVariant::Private *d)
127 {
128     QVariantIsNull<CoreTypesFilter> isNull(d);
129     return QMetaTypeSwitcher::switcher<bool>(isNull, d->type, 0);
130 }
131
132 /*!
133   \internal
134
135   Compares \a a to \a b. The caller guarantees that \a a and \a b
136   are of the same type.
137  */
138 static bool compare(const QVariant::Private *a, const QVariant::Private *b)
139 {
140     QVariantComparator<CoreTypesFilter> comparator(a, b);
141     return QMetaTypeSwitcher::switcher<bool>(comparator, a->type, 0);
142 }
143
144 /*!
145   \internal
146  */
147 static qlonglong qMetaTypeNumber(const QVariant::Private *d)
148 {
149     switch (d->type) {
150     case QMetaType::Int:
151         return d->data.i;
152     case QMetaType::LongLong:
153         return d->data.ll;
154     case QMetaType::Char:
155         return qlonglong(d->data.c);
156     case QMetaType::SChar:
157         return qlonglong(d->data.sc);
158     case QMetaType::Short:
159         return qlonglong(d->data.s);
160     case QMetaType::Long:
161         return qlonglong(d->data.l);
162     case QMetaType::Float:
163         return qRound64(d->data.f);
164     case QVariant::Double:
165         return qRound64(d->data.d);
166 #ifndef QT_BOOTSTRAPPED
167     case QMetaType::QJsonValue:
168         return v_cast<QJsonValue>(d)->toDouble();
169 #endif
170     }
171     Q_ASSERT(false);
172     return 0;
173 }
174
175 static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
176 {
177     switch (d->type) {
178     case QVariant::UInt:
179         return d->data.u;
180     case QVariant::ULongLong:
181         return d->data.ull;
182     case QMetaType::UChar:
183         return d->data.uc;
184     case QMetaType::UShort:
185         return d->data.us;
186     case QMetaType::ULong:
187         return d->data.ul;
188     }
189     Q_ASSERT(false);
190     return 0;
191 }
192
193 static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)
194 {
195     *ok = true;
196
197     switch (uint(d->type)) {
198     case QVariant::String:
199         return v_cast<QString>(d)->toLongLong(ok);
200     case QVariant::Char:
201         return v_cast<QChar>(d)->unicode();
202     case QVariant::ByteArray:
203         return v_cast<QByteArray>(d)->toLongLong(ok);
204     case QVariant::Bool:
205         return qlonglong(d->data.b);
206 #ifndef QT_BOOTSTRAPPED
207     case QMetaType::QJsonValue:
208         if (!v_cast<QJsonValue>(d)->isDouble())
209             break;
210         // no break
211 #endif
212     case QVariant::Double:
213     case QVariant::Int:
214     case QMetaType::Char:
215     case QMetaType::SChar:
216     case QMetaType::Short:
217     case QMetaType::Long:
218     case QMetaType::Float:
219     case QMetaType::LongLong:
220         return qMetaTypeNumber(d);
221     case QVariant::ULongLong:
222     case QVariant::UInt:
223     case QMetaType::UChar:
224     case QMetaType::UShort:
225     case QMetaType::ULong:
226
227         return qlonglong(qMetaTypeUNumber(d));
228     }
229
230     QMetaType typeInfo(d->type);
231     if (typeInfo.flags() & QMetaType::IsEnumeration) {
232         switch (typeInfo.sizeOf()) {
233         case 1:
234             return d->is_shared ? *reinterpret_cast<signed char *>(d->data.shared->ptr) : d->data.sc;
235         case 2:
236             return d->is_shared ? *reinterpret_cast<qint16 *>(d->data.shared->ptr) : d->data.s;
237         case 4:
238             return d->is_shared ? *reinterpret_cast<qint32 *>(d->data.shared->ptr) : d->data.i;
239         case 8:
240             return d->is_shared ? *reinterpret_cast<qint64 *>(d->data.shared->ptr) : d->data.ll;
241         }
242     }
243
244     *ok = false;
245     return Q_INT64_C(0);
246 }
247
248 static qreal qConvertToRealNumber(const QVariant::Private *d, bool *ok)
249 {
250     *ok = true;
251     switch (uint(d->type)) {
252     case QVariant::Double:
253         return qreal(d->data.d);
254     case QMetaType::Float:
255         return qreal(d->data.f);
256     case QVariant::ULongLong:
257     case QVariant::UInt:
258     case QMetaType::UChar:
259     case QMetaType::UShort:
260     case QMetaType::ULong:
261         return qreal(qMetaTypeUNumber(d));
262     default:
263         // includes enum conversion as well as invalid types
264         return qreal(qConvertToNumber(d, ok));
265     }
266 }
267
268 static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)
269 {
270     *ok = true;
271
272     switch (uint(d->type)) {
273     case QVariant::String:
274         return v_cast<QString>(d)->toULongLong(ok);
275     case QVariant::Char:
276         return v_cast<QChar>(d)->unicode();
277     case QVariant::ByteArray:
278         return v_cast<QByteArray>(d)->toULongLong(ok);
279     case QVariant::Bool:
280         return qulonglong(d->data.b);
281 #ifndef QT_BOOTSTRAPPED
282     case QMetaType::QJsonValue:
283         if (!v_cast<QJsonValue>(d)->isDouble())
284             break;
285         // no break
286 #endif
287     case QVariant::Double:
288     case QVariant::Int:
289     case QMetaType::Char:
290     case QMetaType::SChar:
291     case QMetaType::Short:
292     case QMetaType::Long:
293     case QMetaType::Float:
294     case QMetaType::LongLong:
295         return qulonglong(qMetaTypeNumber(d));
296     case QVariant::ULongLong:
297     case QVariant::UInt:
298     case QMetaType::UChar:
299     case QMetaType::UShort:
300     case QMetaType::ULong:
301         return qMetaTypeUNumber(d);
302     }
303
304     QMetaType typeInfo(d->type);
305     if (typeInfo.flags() & QMetaType::IsEnumeration) {
306         switch (typeInfo.sizeOf()) {
307         case 1:
308             return d->is_shared ? *reinterpret_cast<uchar *>(d->data.shared->ptr) : d->data.uc;
309         case 2:
310             return d->is_shared ? *reinterpret_cast<quint16 *>(d->data.shared->ptr) : d->data.us;
311         case 4:
312             return d->is_shared ? *reinterpret_cast<quint32 *>(d->data.shared->ptr) : d->data.u;
313         case 8:
314             return d->is_shared ? *reinterpret_cast<qint64 *>(d->data.shared->ptr) : d->data.ull;
315         }
316     }
317
318     *ok = false;
319     return Q_UINT64_C(0);
320 }
321
322 template<typename TInput, typename LiteralWrapper>
323 inline bool qt_convertToBool(const QVariant::Private *const d)
324 {
325     TInput str = v_cast<TInput>(d)->toLower();
326     return !(str == LiteralWrapper("0") || str == LiteralWrapper("false") || str.isEmpty());
327 }
328
329 /*!
330  \internal
331  Returns the internal data pointer from \a d.
332  */
333
334 static const void *constData(const QVariant::Private &d)
335 {
336     return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.c);
337 }
338
339 #ifndef QT_NO_QOBJECT
340 /*!
341   \internal
342   returns a QMetaEnum for a given meta tape type id if possible
343 */
344 static QMetaEnum metaEnumFromType(int type)
345 {
346     QMetaType t(type);
347     if (t.flags() & QMetaType::IsEnumeration) {
348         if (const QMetaObject *metaObject = t.metaObject()) {
349             const char *enumName = QMetaType::typeName(type);
350             const char *lastColon = std::strrchr(enumName, ':');
351             if (lastColon)
352                 enumName = lastColon + 1;
353             return metaObject->enumerator(metaObject->indexOfEnumerator(enumName));
354         }
355     }
356     return QMetaEnum();
357 }
358 #endif
359
360 /*!
361  \internal
362
363  Converts \a d to type \a t, which is placed in \a result.
364  */
365 static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
366 {
367     Q_ASSERT(d->type != uint(t));
368     Q_ASSERT(result);
369
370     if (d->type >= QMetaType::User || t >= QMetaType::User) {
371         const bool isOk = QMetaType::convert(constData(*d), d->type, result, t);
372         if (ok)
373             *ok = isOk;
374         if (isOk)
375             return true;
376     }
377
378     bool dummy;
379     if (!ok)
380         ok = &dummy;
381
382     switch (uint(t)) {
383 #ifndef QT_BOOTSTRAPPED
384     case QVariant::Url:
385         switch (d->type) {
386         case QVariant::String:
387             *static_cast<QUrl *>(result) = QUrl(*v_cast<QString>(d));
388             break;
389         default:
390             return false;
391         }
392         break;
393     case QVariant::ModelIndex:
394         switch (d->type) {
395         case QVariant::PersistentModelIndex:
396             *static_cast<QModelIndex *>(result) = QModelIndex(*v_cast<QPersistentModelIndex>(d));
397             break;
398         default:
399             return false;
400         }
401         break;
402     case QVariant::PersistentModelIndex:
403         switch (d->type) {
404         case QVariant::ModelIndex:
405             *static_cast<QPersistentModelIndex *>(result) = QPersistentModelIndex(*v_cast<QModelIndex>(d));
406             break;
407         default:
408             return false;
409         }
410         break;
411 #endif // QT_BOOTSTRAPPED
412     case QVariant::String: {
413         QString *str = static_cast<QString *>(result);
414         switch (d->type) {
415         case QVariant::Char:
416             *str = QString(*v_cast<QChar>(d));
417             break;
418         case QMetaType::Char:
419         case QMetaType::SChar:
420         case QMetaType::UChar:
421             *str = QChar::fromLatin1(d->data.c);
422             break;
423         case QMetaType::Short:
424         case QMetaType::Long:
425         case QVariant::Int:
426         case QVariant::LongLong:
427             *str = QString::number(qMetaTypeNumber(d));
428             break;
429         case QVariant::UInt:
430         case QVariant::ULongLong:
431         case QMetaType::UShort:
432         case QMetaType::ULong:
433             *str = QString::number(qMetaTypeUNumber(d));
434             break;
435         case QMetaType::Float:
436             *str = QString::number(d->data.f, 'g', max_digits10_float);
437             break;
438         case QVariant::Double:
439             *str = QString::number(d->data.d, 'g', max_digits10_double);
440             break;
441 #if !defined(QT_NO_DATESTRING)
442         case QVariant::Date:
443             *str = v_cast<QDate>(d)->toString(Qt::ISODate);
444             break;
445         case QVariant::Time:
446             *str = v_cast<QTime>(d)->toString(Qt::ISODate);
447             break;
448         case QVariant::DateTime:
449             *str = v_cast<QDateTime>(d)->toString(Qt::ISODate);
450             break;
451 #endif
452         case QVariant::Bool:
453             *str = QLatin1String(d->data.b ? "true" : "false");
454             break;
455         case QVariant::ByteArray:
456             *str = QString::fromUtf8(v_cast<QByteArray>(d)->constData());
457             break;
458         case QVariant::StringList:
459             if (v_cast<QStringList>(d)->count() == 1)
460                 *str = v_cast<QStringList>(d)->at(0);
461             break;
462 #ifndef QT_BOOTSTRAPPED
463         case QVariant::Url:
464             *str = v_cast<QUrl>(d)->toString();
465             break;
466         case QMetaType::QJsonValue:
467             if (v_cast<QJsonValue>(d)->isString())
468                 *str = v_cast<QJsonValue>(d)->toString();
469             else if (!v_cast<QJsonValue>(d)->isNull())
470                 return false;
471             break;
472 #endif
473         case QVariant::Uuid:
474             *str = v_cast<QUuid>(d)->toString();
475             break;
476         default:
477 #ifndef QT_NO_QOBJECT
478             {
479                 QMetaEnum en = metaEnumFromType(d->type);
480                 if (en.isValid()) {
481                     *str = QString::fromUtf8(en.valueToKey(qConvertToNumber(d, ok)));
482                     return *ok;
483                 }
484             }
485 #endif
486             return false;
487         }
488         break;
489     }
490     case QVariant::Char: {
491         QChar *c = static_cast<QChar *>(result);
492         switch (d->type) {
493         case QVariant::Int:
494         case QVariant::LongLong:
495         case QMetaType::Char:
496         case QMetaType::SChar:
497         case QMetaType::Short:
498         case QMetaType::Long:
499         case QMetaType::Float:
500             *c = QChar(ushort(qMetaTypeNumber(d)));
501             break;
502         case QVariant::UInt:
503         case QVariant::ULongLong:
504         case QMetaType::UChar:
505         case QMetaType::UShort:
506         case QMetaType::ULong:
507             *c = QChar(ushort(qMetaTypeUNumber(d)));
508             break;
509         default:
510             return false;
511         }
512         break;
513     }
514 #ifndef QT_NO_GEOM_VARIANT
515     case QVariant::Size: {
516         QSize *s = static_cast<QSize *>(result);
517         switch (d->type) {
518         case QVariant::SizeF:
519             *s = v_cast<QSizeF>(d)->toSize();
520             break;
521         default:
522             return false;
523         }
524         break;
525     }
526
527     case QVariant::SizeF: {
528         QSizeF *s = static_cast<QSizeF *>(result);
529         switch (d->type) {
530         case QVariant::Size:
531             *s = QSizeF(*(v_cast<QSize>(d)));
532             break;
533         default:
534             return false;
535         }
536         break;
537     }
538
539     case QVariant::Line: {
540         QLine *s = static_cast<QLine *>(result);
541         switch (d->type) {
542         case QVariant::LineF:
543             *s = v_cast<QLineF>(d)->toLine();
544             break;
545         default:
546             return false;
547         }
548         break;
549     }
550
551     case QVariant::LineF: {
552         QLineF *s = static_cast<QLineF *>(result);
553         switch (d->type) {
554         case QVariant::Line:
555             *s = QLineF(*(v_cast<QLine>(d)));
556             break;
557         default:
558             return false;
559         }
560         break;
561     }
562 #endif
563     case QVariant::StringList:
564         if (d->type == QVariant::List) {
565             QStringList *slst = static_cast<QStringList *>(result);
566             const QVariantList *list = v_cast<QVariantList >(d);
567             for (int i = 0; i < list->size(); ++i)
568                 slst->append(list->at(i).toString());
569         } else if (d->type == QVariant::String) {
570             QStringList *slst = static_cast<QStringList *>(result);
571             *slst = QStringList(*v_cast<QString>(d));
572         } else {
573             return false;
574         }
575         break;
576     case QVariant::Date: {
577         QDate *dt = static_cast<QDate *>(result);
578         if (d->type == QVariant::DateTime)
579             *dt = v_cast<QDateTime>(d)->date();
580 #ifndef QT_NO_DATESTRING
581         else if (d->type == QVariant::String)
582             *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);
583 #endif
584         else
585             return false;
586
587         return dt->isValid();
588     }
589     case QVariant::Time: {
590         QTime *t = static_cast<QTime *>(result);
591         switch (d->type) {
592         case QVariant::DateTime:
593             *t = v_cast<QDateTime>(d)->time();
594             break;
595 #ifndef QT_NO_DATESTRING
596         case QVariant::String:
597             *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);
598             break;
599 #endif
600         default:
601             return false;
602         }
603         return t->isValid();
604     }
605     case QVariant::DateTime: {
606         QDateTime *dt = static_cast<QDateTime *>(result);
607         switch (d->type) {
608 #ifndef QT_NO_DATESTRING
609         case QVariant::String:
610             *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);
611             break;
612 #endif
613         case QVariant::Date:
614             *dt = QDateTime(*v_cast<QDate>(d));
615             break;
616         default:
617             return false;
618         }
619         return dt->isValid();
620     }
621     case QVariant::ByteArray: {
622         QByteArray *ba = static_cast<QByteArray *>(result);
623         switch (d->type) {
624         case QVariant::String:
625             *ba = v_cast<QString>(d)->toUtf8();
626             break;
627         case QVariant::Double:
628             *ba = QByteArray::number(d->data.d, 'g', max_digits10_double);
629             break;
630         case QMetaType::Float:
631             *ba = QByteArray::number(d->data.f, 'g', max_digits10_float);
632             break;
633         case QMetaType::Char:
634         case QMetaType::SChar:
635         case QMetaType::UChar:
636             *ba = QByteArray(1, d->data.c);
637             break;
638         case QVariant::Int:
639         case QVariant::LongLong:
640         case QMetaType::Short:
641         case QMetaType::Long:
642             *ba = QByteArray::number(qMetaTypeNumber(d));
643             break;
644         case QVariant::UInt:
645         case QVariant::ULongLong:
646         case QMetaType::UShort:
647         case QMetaType::ULong:
648             *ba = QByteArray::number(qMetaTypeUNumber(d));
649             break;
650         case QVariant::Bool:
651             *ba = QByteArray(d->data.b ? "true" : "false");
652             break;
653         default:
654 #ifndef QT_NO_QOBJECT
655             {
656                 QMetaEnum en = metaEnumFromType(d->type);
657                 if (en.isValid()) {
658                     *ba = en.valueToKey(qConvertToNumber(d, ok));
659                     return *ok;
660                 }
661             }
662 #endif
663             return false;
664         }
665     }
666     break;
667     case QMetaType::Short:
668         *static_cast<short *>(result) = short(qConvertToNumber(d, ok));
669         return *ok;
670     case QMetaType::Long:
671         *static_cast<long *>(result) = long(qConvertToNumber(d, ok));
672         return *ok;
673     case QMetaType::UShort:
674         *static_cast<ushort *>(result) = ushort(qConvertToUnsignedNumber(d, ok));
675         return *ok;
676     case QMetaType::ULong:
677         *static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok));
678         return *ok;
679     case QVariant::Int:
680         *static_cast<int *>(result) = int(qConvertToNumber(d, ok));
681         return *ok;
682     case QVariant::UInt:
683         *static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok));
684         return *ok;
685     case QVariant::LongLong:
686         *static_cast<qlonglong *>(result) = qConvertToNumber(d, ok);
687         return *ok;
688     case QVariant::ULongLong: {
689         *static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok);
690         return *ok;
691     }
692     case QMetaType::SChar: {
693         signed char s = qConvertToNumber(d, ok);
694         *static_cast<signed char*>(result) = s;
695         return *ok;
696     }
697     case QMetaType::UChar: {
698         *static_cast<uchar *>(result) = qConvertToUnsignedNumber(d, ok);
699         return *ok;
700     }
701     case QVariant::Bool: {
702         bool *b = static_cast<bool *>(result);
703         switch(d->type) {
704         case QVariant::ByteArray:
705             *b = qt_convertToBool<QByteArray, QByteArray>(d);
706             break;
707         case QVariant::String:
708             *b = qt_convertToBool<QString, QLatin1String>(d);
709             break;
710         case QVariant::Char:
711             *b = !v_cast<QChar>(d)->isNull();
712             break;
713         case QVariant::Double:
714         case QVariant::Int:
715         case QVariant::LongLong:
716         case QMetaType::Char:
717         case QMetaType::SChar:
718         case QMetaType::Short:
719         case QMetaType::Long:
720         case QMetaType::Float:
721             *b = qMetaTypeNumber(d) != Q_INT64_C(0);
722             break;
723         case QVariant::UInt:
724         case QVariant::ULongLong:
725         case QMetaType::UChar:
726         case QMetaType::UShort:
727         case QMetaType::ULong:
728             *b = qMetaTypeUNumber(d) != Q_UINT64_C(0);
729             break;
730 #ifndef QT_BOOTSTRAPPED
731         case QMetaType::QJsonValue:
732             *b = v_cast<QJsonValue>(d)->toBool(false);
733             if (!v_cast<QJsonValue>(d)->isBool())
734                 return false;
735             break;
736 #endif
737         default:
738             *b = false;
739             return false;
740         }
741         break;
742     }
743     case QVariant::Double: {
744         double *f = static_cast<double *>(result);
745         switch (d->type) {
746         case QVariant::String:
747             *f = v_cast<QString>(d)->toDouble(ok);
748             break;
749         case QVariant::ByteArray:
750             *f = v_cast<QByteArray>(d)->toDouble(ok);
751             break;
752         case QVariant::Bool:
753             *f = double(d->data.b);
754             break;
755         case QMetaType::Float:
756             *f = double(d->data.f);
757             break;
758         case QVariant::LongLong:
759         case QVariant::Int:
760         case QMetaType::Char:
761         case QMetaType::SChar:
762         case QMetaType::Short:
763         case QMetaType::Long:
764             *f = double(qMetaTypeNumber(d));
765             break;
766         case QVariant::UInt:
767         case QVariant::ULongLong:
768         case QMetaType::UChar:
769         case QMetaType::UShort:
770         case QMetaType::ULong:
771             *f = double(qMetaTypeUNumber(d));
772             break;
773 #ifndef QT_BOOTSTRAPPED
774         case QMetaType::QJsonValue:
775             *f = v_cast<QJsonValue>(d)->toDouble(0.0);
776             if (!v_cast<QJsonValue>(d)->isDouble())
777                 return false;
778             break;
779 #endif
780         default:
781             *f = 0.0;
782             return false;
783         }
784         break;
785     }
786     case QMetaType::Float: {
787         float *f = static_cast<float *>(result);
788         switch (d->type) {
789         case QVariant::String:
790             *f = v_cast<QString>(d)->toFloat(ok);
791             break;
792         case QVariant::ByteArray:
793             *f = v_cast<QByteArray>(d)->toFloat(ok);
794             break;
795         case QVariant::Bool:
796             *f = float(d->data.b);
797             break;
798         case QVariant::Double:
799             *f = float(d->data.d);
800             break;
801         case QVariant::LongLong:
802         case QVariant::Int:
803         case QMetaType::Char:
804         case QMetaType::SChar:
805         case QMetaType::Short:
806         case QMetaType::Long:
807             *f = float(qMetaTypeNumber(d));
808             break;
809         case QVariant::UInt:
810         case QVariant::ULongLong:
811         case QMetaType::UChar:
812         case QMetaType::UShort:
813         case QMetaType::ULong:
814             *f = float(qMetaTypeUNumber(d));
815             break;
816 #ifndef QT_BOOTSTRAPPED
817         case QMetaType::QJsonValue:
818             *f = v_cast<QJsonValue>(d)->toDouble(0.0);
819             if (!v_cast<QJsonValue>(d)->isDouble())
820                 return false;
821             break;
822 #endif
823         default:
824             *f = 0.0f;
825             return false;
826         }
827         break;
828     }
829     case QVariant::List:
830         if (d->type == QVariant::StringList) {
831             QVariantList *lst = static_cast<QVariantList *>(result);
832             const QStringList *slist = v_cast<QStringList>(d);
833             for (int i = 0; i < slist->size(); ++i)
834                 lst->append(QVariant(slist->at(i)));
835         } else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {
836             *static_cast<QVariantList *>(result) =
837                 *static_cast<QList<QVariant> *>(d->data.shared->ptr);
838 #ifndef QT_BOOTSTRAPPED
839         } else if (d->type == QMetaType::QJsonValue) {
840             if (!v_cast<QJsonValue>(d)->isArray())
841                 return false;
842             *static_cast<QVariantList *>(result) = v_cast<QJsonValue>(d)->toArray().toVariantList();
843         } else if (d->type == QMetaType::QJsonArray) {
844             *static_cast<QVariantList *>(result) = v_cast<QJsonArray>(d)->toVariantList();
845 #endif
846         } else {
847             return false;
848         }
849         break;
850     case QVariant::Map:
851         if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
852             *static_cast<QVariantMap *>(result) =
853                 *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);
854 #ifndef QT_BOOTSTRAPPED
855         } else if (d->type == QMetaType::QJsonValue) {
856             if (!v_cast<QJsonValue>(d)->isObject())
857                 return false;
858             *static_cast<QVariantMap *>(result) = v_cast<QJsonValue>(d)->toObject().toVariantMap();
859         } else if (d->type == QMetaType::QJsonObject) {
860             *static_cast<QVariantMap *>(result) = v_cast<QJsonObject>(d)->toVariantMap();
861 #endif
862         } else {
863             return false;
864         }
865         break;
866     case QVariant::Hash:
867         if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) {
868             *static_cast<QVariantHash *>(result) =
869                 *static_cast<QHash<QString, QVariant> *>(d->data.shared->ptr);
870 #ifndef QT_BOOTSTRAPPED
871         } else if (d->type == QMetaType::QJsonValue) {
872             if (!v_cast<QJsonValue>(d)->isObject())
873                 return false;
874             *static_cast<QVariantHash *>(result) = v_cast<QJsonValue>(d)->toObject().toVariantHash();
875         } else if (d->type == QMetaType::QJsonObject) {
876             *static_cast<QVariantHash *>(result) = v_cast<QJsonObject>(d)->toVariantHash();
877 #endif
878         } else {
879             return false;
880         }
881         break;
882 #ifndef QT_NO_GEOM_VARIANT
883     case QVariant::Rect:
884         if (d->type == QVariant::RectF)
885             *static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect();
886         else
887             return false;
888         break;
889     case QVariant::RectF:
890         if (d->type == QVariant::Rect)
891             *static_cast<QRectF *>(result) = *v_cast<QRect>(d);
892         else
893             return false;
894         break;
895     case QVariant::PointF:
896         if (d->type == QVariant::Point)
897             *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);
898         else
899             return false;
900         break;
901     case QVariant::Point:
902         if (d->type == QVariant::PointF)
903             *static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint();
904         else
905             return false;
906         break;
907     case QMetaType::Char:
908     {
909         *static_cast<qint8 *>(result) = qint8(qConvertToNumber(d, ok));
910         return *ok;
911     }
912 #endif
913     case QVariant::Uuid:
914         switch (d->type) {
915         case QVariant::String:
916             *static_cast<QUuid *>(result) = QUuid(*v_cast<QString>(d));
917             break;
918         default:
919             return false;
920         }
921         break;
922     default:
923 #ifndef QT_NO_QOBJECT
924         if (d->type == QVariant::String || d->type == QVariant::ByteArray) {
925             QMetaEnum en = metaEnumFromType(t);
926             if (en.isValid()) {
927                 QByteArray keys = (d->type == QVariant::String) ? v_cast<QString>(d)->toUtf8() : *v_cast<QByteArray>(d);
928                 int value = en.keysToValue(keys.constData(), ok);
929                 if (*ok) {
930                     switch (QMetaType::sizeOf(t)) {
931                     case 1:
932                         *static_cast<signed char *>(result) = value;
933                         return true;
934                     case 2:
935                         *static_cast<qint16 *>(result) = value;
936                         return true;
937                     case 4:
938                         *static_cast<qint32 *>(result) = value;
939                         return true;
940                     case 8:
941                         *static_cast<qint64 *>(result) = value;
942                         return true;
943                     }
944                 }
945             }
946         }
947 #endif
948         return false;
949     }
950     return true;
951 }
952
953 #if !defined(QT_NO_DEBUG_STREAM)
954 static void streamDebug(QDebug dbg, const QVariant &v)
955 {
956     QVariant::Private *d = const_cast<QVariant::Private *>(&v.data_ptr());
957     QVariantDebugStream<CoreTypesFilter> stream(dbg, d);
958     QMetaTypeSwitcher::switcher<void>(stream, d->type, 0);
959 }
960 #endif
961
962 const QVariant::Handler qt_kernel_variant_handler = {
963     construct,
964     clear,
965     isNull,
966 #ifndef QT_NO_DATASTREAM
967     0,
968     0,
969 #endif
970     compare,
971     convert,
972     0,
973 #if !defined(QT_NO_DEBUG_STREAM)
974     streamDebug
975 #else
976     0
977 #endif
978 };
979
980 static void dummyConstruct(QVariant::Private *, const void *) { Q_ASSERT_X(false, "QVariant", "Trying to construct an unknown type"); }
981 static void dummyClear(QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to clear an unknown type"); }
982 static bool dummyIsNull(const QVariant::Private *d) { Q_ASSERT_X(false, "QVariant::isNull", "Trying to call isNull on an unknown type"); return d->is_null; }
983 static bool dummyCompare(const QVariant::Private *, const QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to compare an unknown types"); return false; }
984 static bool dummyConvert(const QVariant::Private *, int, void *, bool *) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); return false; }
985 #if !defined(QT_NO_DEBUG_STREAM)
986 static void dummyStreamDebug(QDebug, const QVariant &) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); }
987 #endif
988 const QVariant::Handler qt_dummy_variant_handler = {
989     dummyConstruct,
990     dummyClear,
991     dummyIsNull,
992 #ifndef QT_NO_DATASTREAM
993     0,
994     0,
995 #endif
996     dummyCompare,
997     dummyConvert,
998     0,
999 #if !defined(QT_NO_DEBUG_STREAM)
1000     dummyStreamDebug
1001 #else
1002     0
1003 #endif
1004 };
1005
1006 static void customConstruct(QVariant::Private *d, const void *copy)
1007 {
1008     const QMetaType type(d->type);
1009     const uint size = type.sizeOf();
1010     if (!size) {
1011         qWarning("Trying to construct an instance of an invalid type, type id: %i", d->type);
1012         d->type = QVariant::Invalid;
1013         return;
1014     }
1015
1016     // this logic should match with QVariantIntegrator::CanUseInternalSpace
1017     if (size <= sizeof(QVariant::Private::Data)
1018             && (type.flags() & (QMetaType::MovableType | QMetaType::IsEnumeration))) {
1019         type.construct(&d->data.ptr, copy);
1020         d->is_shared = false;
1021     } else {
1022         void *ptr = type.create(copy);
1023         d->is_shared = true;
1024         d->data.shared = new QVariant::PrivateShared(ptr);
1025     }
1026 }
1027
1028 static void customClear(QVariant::Private *d)
1029 {
1030     if (!d->is_shared) {
1031         QMetaType::destruct(d->type, &d->data.ptr);
1032     } else {
1033         QMetaType::destroy(d->type, d->data.shared->ptr);
1034         delete d->data.shared;
1035     }
1036 }
1037
1038 static bool customIsNull(const QVariant::Private *d)
1039 {
1040     return d->is_null;
1041 }
1042
1043 static bool customCompare(const QVariant::Private *a, const QVariant::Private *b)
1044 {
1045     const char *const typeName = QMetaType::typeName(a->type);
1046     if (Q_UNLIKELY(!typeName) && Q_LIKELY(!QMetaType::isRegistered(a->type)))
1047         qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);
1048
1049     const void *a_ptr = a->is_shared ? a->data.shared->ptr : &(a->data.ptr);
1050     const void *b_ptr = b->is_shared ? b->data.shared->ptr : &(b->data.ptr);
1051
1052     uint typeNameLen = qstrlen(typeName);
1053     if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*')
1054         return *static_cast<void *const *>(a_ptr) == *static_cast<void *const *>(b_ptr);
1055
1056     if (a->is_null && b->is_null)
1057         return true;
1058
1059     return !memcmp(a_ptr, b_ptr, QMetaType::sizeOf(a->type));
1060 }
1061
1062 static bool customConvert(const QVariant::Private *d, int t, void *result, bool *ok)
1063 {
1064     if (d->type >= QMetaType::User || t >= QMetaType::User) {
1065         if (QMetaType::convert(constData(*d), d->type, result, t)) {
1066             if (ok)
1067                 *ok = true;
1068             return true;
1069         }
1070     }
1071     return convert(d, t, result, ok);
1072 }
1073
1074 #if !defined(QT_NO_DEBUG_STREAM)
1075 static void customStreamDebug(QDebug dbg, const QVariant &variant) {
1076 #ifndef QT_BOOTSTRAPPED
1077     QMetaType::TypeFlags flags = QMetaType::typeFlags(variant.userType());
1078     if (flags & QMetaType::PointerToQObject)
1079         dbg.nospace() << variant.value<QObject*>();
1080 #else
1081     Q_UNUSED(dbg);
1082     Q_UNUSED(variant);
1083 #endif
1084 }
1085 #endif
1086
1087 const QVariant::Handler qt_custom_variant_handler = {
1088     customConstruct,
1089     customClear,
1090     customIsNull,
1091 #ifndef QT_NO_DATASTREAM
1092     0,
1093     0,
1094 #endif
1095     customCompare,
1096     customConvert,
1097     0,
1098 #if !defined(QT_NO_DEBUG_STREAM)
1099     customStreamDebug
1100 #else
1101     0
1102 #endif
1103 };
1104
1105 } // annonymous used to hide QVariant handlers
1106
1107 static HandlersManager handlerManager;
1108 Q_STATIC_ASSERT_X(!QModulesPrivate::Core, "Initialization assumes that ModulesNames::Core is 0");
1109 const QVariant::Handler *HandlersManager::Handlers[QModulesPrivate::ModulesCount]
1110                                         = { &qt_kernel_variant_handler, &qt_dummy_variant_handler,
1111                                             &qt_dummy_variant_handler, &qt_custom_variant_handler };
1112
1113 Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler()
1114 {
1115     return &qt_kernel_variant_handler;
1116 }
1117
1118 Q_CORE_EXPORT void QVariantPrivate::registerHandler(const int /* Modules::Names */name, const QVariant::Handler *handler)
1119 {
1120     handlerManager.registerHandler(static_cast<QModulesPrivate::Names>(name), handler);
1121 }
1122
1123 /*!
1124     \class QVariant
1125     \inmodule QtCore
1126     \brief The QVariant class acts like a union for the most common Qt data types.
1127
1128     \ingroup objectmodel
1129     \ingroup shared
1130
1131
1132     Because C++ forbids unions from including types that have
1133     non-default constructors or destructors, most interesting Qt
1134     classes cannot be used in unions. Without QVariant, this would be
1135     a problem for QObject::property() and for database work, etc.
1136
1137     A QVariant object holds a single value of a single type() at a
1138     time. (Some type()s are multi-valued, for example a string list.)
1139     You can find out what type, T, the variant holds, convert it to a
1140     different type using convert(), get its value using one of the
1141     toT() functions (e.g., toSize()) and check whether the type can
1142     be converted to a particular type using canConvert().
1143
1144     The methods named toT() (e.g., toInt(), toString()) are const. If
1145     you ask for the stored type, they return a copy of the stored
1146     object. If you ask for a type that can be generated from the
1147     stored type, toT() copies and converts and leaves the object
1148     itself unchanged. If you ask for a type that cannot be generated
1149     from the stored type, the result depends on the type; see the
1150     function documentation for details.
1151
1152     Here is some example code to demonstrate the use of QVariant:
1153
1154     \snippet code/src_corelib_kernel_qvariant.cpp 0
1155
1156     You can even store QList<QVariant> and QMap<QString, QVariant>
1157     values in a variant, so you can easily construct arbitrarily
1158     complex data structures of arbitrary types. This is very powerful
1159     and versatile, but may prove less memory and speed efficient than
1160     storing specific types in standard data structures.
1161
1162     QVariant also supports the notion of null values, where you can
1163     have a defined type with no value set. However, note that QVariant
1164     types can only be cast when they have had a value set.
1165
1166     \snippet code/src_corelib_kernel_qvariant.cpp 1
1167
1168     QVariant can be extended to support other types than those
1169     mentioned in the \l Type enum. See the \l QMetaType documentation
1170     for details.
1171
1172     \section1 A Note on GUI Types
1173
1174     Because QVariant is part of the Qt Core module, it cannot provide
1175     conversion functions to data types defined in Qt GUI, such as
1176     QColor, QImage, and QPixmap. In other words, there is no \c
1177     toColor() function. Instead, you can use the QVariant::value() or
1178     the qvariant_cast() template function. For example:
1179
1180     \snippet code/src_corelib_kernel_qvariant.cpp 2
1181
1182     The inverse conversion (e.g., from QColor to QVariant) is
1183     automatic for all data types supported by QVariant, including
1184     GUI-related types:
1185
1186     \snippet code/src_corelib_kernel_qvariant.cpp 3
1187
1188     \section1 Using canConvert() and convert() Consecutively
1189
1190     When using canConvert() and convert() consecutively, it is possible for
1191     canConvert() to return true, but convert() to return false. This
1192     is typically because canConvert() only reports the general ability of
1193     QVariant to convert between types given suitable data; it is still
1194     possible to supply data which cannot actually be converted.
1195
1196     For example, canConvert(Int) would return true when called on a variant
1197     containing a string because, in principle, QVariant is able to convert
1198     strings of numbers to integers.
1199     However, if the string contains non-numeric characters, it cannot be
1200     converted to an integer, and any attempt to convert it will fail.
1201     Hence, it is important to have both functions return true for a
1202     successful conversion.
1203
1204     \sa QMetaType
1205 */
1206
1207 /*!
1208     \obsolete Use QMetaType::Type instead
1209     \enum QVariant::Type
1210
1211     This enum type defines the types of variable that a QVariant can
1212     contain.
1213
1214     \value Invalid  no type
1215     \value BitArray  a QBitArray
1216     \value Bitmap  a QBitmap
1217     \value Bool  a bool
1218     \value Brush  a QBrush
1219     \value ByteArray  a QByteArray
1220     \value Char  a QChar
1221     \value Color  a QColor
1222     \value Cursor  a QCursor
1223     \value Date  a QDate
1224     \value DateTime  a QDateTime
1225     \value Double  a double
1226     \value EasingCurve a QEasingCurve
1227     \value Uuid a QUuid
1228     \value ModelIndex a QModelIndex
1229     \value PersistentModelIndex a QPersistentModelIndex (since 5.5)
1230     \value Font  a QFont
1231     \value Hash a QVariantHash
1232     \value Icon  a QIcon
1233     \value Image  a QImage
1234     \value Int  an int
1235     \value KeySequence  a QKeySequence
1236     \value Line  a QLine
1237     \value LineF  a QLineF
1238     \value List  a QVariantList
1239     \value Locale  a QLocale
1240     \value LongLong a \l qlonglong
1241     \value Map  a QVariantMap
1242     \value Matrix  a QMatrix
1243     \value Transform  a QTransform
1244     \value Matrix4x4  a QMatrix4x4
1245     \value Palette  a QPalette
1246     \value Pen  a QPen
1247     \value Pixmap  a QPixmap
1248     \value Point  a QPoint
1249     \value PointF  a QPointF
1250     \value Polygon a QPolygon
1251     \value PolygonF a QPolygonF
1252     \value Quaternion  a QQuaternion
1253     \value Rect  a QRect
1254     \value RectF  a QRectF
1255     \value RegExp  a QRegExp
1256     \value RegularExpression  a QRegularExpression
1257     \value Region  a QRegion
1258     \value Size  a QSize
1259     \value SizeF  a QSizeF
1260     \value SizePolicy  a QSizePolicy
1261     \value String  a QString
1262     \value StringList  a QStringList
1263     \value TextFormat  a QTextFormat
1264     \value TextLength  a QTextLength
1265     \value Time  a QTime
1266     \value UInt  a \l uint
1267     \value ULongLong a \l qulonglong
1268     \value Url  a QUrl
1269     \value Vector2D  a QVector2D
1270     \value Vector3D  a QVector3D
1271     \value Vector4D  a QVector4D
1272
1273     \value UserType Base value for user-defined types.
1274
1275     \omitvalue LastGuiType
1276     \omitvalue LastCoreType
1277     \omitvalue LastType
1278 */
1279
1280 /*!
1281     \fn QVariant::QVariant(QVariant &&other)
1282
1283     Move-constructs a QVariant instance, making it point at the same
1284     object that \a other was pointing to.
1285
1286     \since 5.2
1287 */
1288
1289 /*!
1290     \fn QVariant &QVariant::operator=(QVariant &&other)
1291
1292     Move-assigns \a other to this QVariant instance.
1293
1294     \since 5.2
1295 */
1296
1297 /*!
1298     \fn QVariant::QVariant()
1299
1300     Constructs an invalid variant.
1301 */
1302
1303
1304 /*!
1305     \fn QVariant::QVariant(int typeId, const void *copy)
1306
1307     Constructs variant of type \a typeId, and initializes with
1308     \a copy if \a copy is not 0.
1309
1310     Note that you have to pass the address of the variable you want stored.
1311
1312     Usually, you never have to use this constructor, use QVariant::fromValue()
1313     instead to construct variants from the pointer types represented by
1314     \c QMetaType::VoidStar, and \c QMetaType::QObjectStar.
1315
1316     \sa QVariant::fromValue(), QMetaType::Type
1317 */
1318
1319 /*!
1320     \fn QVariant::QVariant(Type type)
1321
1322     Constructs a null variant of type \a type.
1323 */
1324
1325
1326
1327 /*!
1328     \fn QVariant::create(int type, const void *copy)
1329
1330     \internal
1331
1332     Constructs a variant private of type \a type, and initializes with \a copy if
1333     \a copy is not 0.
1334 */
1335
1336 void QVariant::create(int type, const void *copy)
1337 {
1338     d.type = type;
1339     handlerManager[type]->construct(&d, copy);
1340 }
1341
1342 /*!
1343     \fn QVariant::~QVariant()
1344
1345     Destroys the QVariant and the contained object.
1346
1347     Note that subclasses that reimplement clear() should reimplement
1348     the destructor to call clear(). This destructor calls clear(), but
1349     because it is the destructor, QVariant::clear() is called rather
1350     than a subclass's clear().
1351 */
1352
1353 QVariant::~QVariant()
1354 {
1355     if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char))
1356         handlerManager[d.type]->clear(&d);
1357 }
1358
1359 /*!
1360   \fn QVariant::QVariant(const QVariant &p)
1361
1362     Constructs a copy of the variant, \a p, passed as the argument to
1363     this constructor.
1364 */
1365
1366 QVariant::QVariant(const QVariant &p)
1367     : d(p.d)
1368 {
1369     if (d.is_shared) {
1370         d.data.shared->ref.ref();
1371     } else if (p.d.type > Char) {
1372         handlerManager[d.type]->construct(&d, p.constData());
1373         d.is_null = p.d.is_null;
1374     }
1375 }
1376
1377 #ifndef QT_NO_DATASTREAM
1378 /*!
1379     Reads the variant from the data stream, \a s.
1380 */
1381 QVariant::QVariant(QDataStream &s)
1382 {
1383     d.is_null = true;
1384     s >> *this;
1385 }
1386 #endif //QT_NO_DATASTREAM
1387
1388 /*!
1389   \fn QVariant::QVariant(const QString &val)
1390
1391     Constructs a new variant with a string value, \a val.
1392 */
1393
1394 /*!
1395   \fn QVariant::QVariant(QLatin1String val)
1396
1397     Constructs a new variant with a string value, \a val.
1398 */
1399
1400 /*!
1401   \fn QVariant::QVariant(const char *val)
1402
1403     Constructs a new variant with a string value of \a val.
1404     The variant creates a deep copy of \a val into a QString assuming
1405     UTF-8 encoding on the input \a val.
1406
1407     Note that \a val is converted to a QString for storing in the
1408     variant and QVariant::userType() will return QMetaType::QString for
1409     the variant.
1410
1411     You can disable this operator by defining \c
1412     QT_NO_CAST_FROM_ASCII when you compile your applications.
1413 */
1414
1415 #ifndef QT_NO_CAST_FROM_ASCII
1416 QVariant::QVariant(const char *val)
1417 {
1418     QString s = QString::fromUtf8(val);
1419     create(String, &s);
1420 }
1421 #endif
1422
1423 /*!
1424   \fn QVariant::QVariant(const QStringList &val)
1425
1426     Constructs a new variant with a string list value, \a val.
1427 */
1428
1429 /*!
1430   \fn QVariant::QVariant(const QMap<QString, QVariant> &val)
1431
1432     Constructs a new variant with a map of \l {QVariant}s, \a val.
1433 */
1434
1435 /*!
1436   \fn QVariant::QVariant(const QHash<QString, QVariant> &val)
1437
1438     Constructs a new variant with a hash of \l {QVariant}s, \a val.
1439 */
1440
1441 /*!
1442   \fn QVariant::QVariant(const QDate &val)
1443
1444     Constructs a new variant with a date value, \a val.
1445 */
1446
1447 /*!
1448   \fn QVariant::QVariant(const QTime &val)
1449
1450     Constructs a new variant with a time value, \a val.
1451 */
1452
1453 /*!
1454   \fn QVariant::QVariant(const QDateTime &val)
1455
1456     Constructs a new variant with a date/time value, \a val.
1457 */
1458
1459 /*!
1460     \since 4.7
1461   \fn QVariant::QVariant(const QEasingCurve &val)
1462
1463     Constructs a new variant with an easing curve value, \a val.
1464 */
1465
1466 /*!
1467     \since 5.0
1468     \fn QVariant::QVariant(const QUuid &val)
1469
1470     Constructs a new variant with an uuid value, \a val.
1471 */
1472
1473 /*!
1474     \since 5.0
1475     \fn QVariant::QVariant(const QModelIndex &val)
1476
1477     Constructs a new variant with a QModelIndex value, \a val.
1478 */
1479
1480 /*!
1481     \since 5.5
1482     \fn QVariant::QVariant(const QPersistentModelIndex &val)
1483
1484     Constructs a new variant with a QPersistentModelIndex value, \a val.
1485 */
1486
1487 /*!
1488     \since 5.0
1489     \fn QVariant::QVariant(const QJsonValue &val)
1490
1491     Constructs a new variant with a json value, \a val.
1492 */
1493
1494 /*!
1495     \since 5.0
1496     \fn QVariant::QVariant(const QJsonObject &val)
1497
1498     Constructs a new variant with a json object value, \a val.
1499 */
1500
1501 /*!
1502     \since 5.0
1503     \fn QVariant::QVariant(const QJsonArray &val)
1504
1505     Constructs a new variant with a json array value, \a val.
1506 */
1507
1508 /*!
1509     \since 5.0
1510     \fn QVariant::QVariant(const QJsonDocument &val)
1511
1512     Constructs a new variant with a json document value, \a val.
1513 */
1514
1515 /*!
1516   \fn QVariant::QVariant(const QByteArray &val)
1517
1518     Constructs a new variant with a bytearray value, \a val.
1519 */
1520
1521 /*!
1522   \fn QVariant::QVariant(const QBitArray &val)
1523
1524     Constructs a new variant with a bitarray value, \a val.
1525 */
1526
1527 /*!
1528   \fn QVariant::QVariant(const QPoint &val)
1529
1530   Constructs a new variant with a point value of \a val.
1531  */
1532
1533 /*!
1534   \fn QVariant::QVariant(const QPointF &val)
1535
1536   Constructs a new variant with a point value of \a val.
1537  */
1538
1539 /*!
1540   \fn QVariant::QVariant(const QRectF &val)
1541
1542   Constructs a new variant with a rect value of \a val.
1543  */
1544
1545 /*!
1546   \fn QVariant::QVariant(const QLineF &val)
1547
1548   Constructs a new variant with a line value of \a val.
1549  */
1550
1551 /*!
1552   \fn QVariant::QVariant(const QLine &val)
1553
1554   Constructs a new variant with a line value of \a val.
1555  */
1556
1557 /*!
1558   \fn QVariant::QVariant(const QRect &val)
1559
1560   Constructs a new variant with a rect value of \a val.
1561  */
1562
1563 /*!
1564   \fn QVariant::QVariant(const QSize &val)
1565
1566   Constructs a new variant with a size value of \a val.
1567  */
1568
1569 /*!
1570   \fn QVariant::QVariant(const QSizeF &val)
1571
1572   Constructs a new variant with a size value of \a val.
1573  */
1574
1575 /*!
1576   \fn QVariant::QVariant(const QUrl &val)
1577
1578   Constructs a new variant with a url value of \a val.
1579  */
1580
1581 /*!
1582   \fn QVariant::QVariant(int val)
1583
1584     Constructs a new variant with an integer value, \a val.
1585 */
1586
1587 /*!
1588   \fn QVariant::QVariant(uint val)
1589
1590     Constructs a new variant with an unsigned integer value, \a val.
1591 */
1592
1593 /*!
1594   \fn QVariant::QVariant(qlonglong val)
1595
1596     Constructs a new variant with a long long integer value, \a val.
1597 */
1598
1599 /*!
1600   \fn QVariant::QVariant(qulonglong val)
1601
1602     Constructs a new variant with an unsigned long long integer value, \a val.
1603 */
1604
1605
1606 /*!
1607   \fn QVariant::QVariant(bool val)
1608
1609     Constructs a new variant with a boolean value, \a val.
1610 */
1611
1612 /*!
1613   \fn QVariant::QVariant(double val)
1614
1615     Constructs a new variant with a floating point value, \a val.
1616 */
1617
1618 /*!
1619   \fn QVariant::QVariant(float val)
1620
1621     Constructs a new variant with a floating point value, \a val.
1622     \since 4.6
1623 */
1624
1625 /*!
1626     \fn QVariant::QVariant(const QList<QVariant> &val)
1627
1628     Constructs a new variant with a list value, \a val.
1629 */
1630
1631 /*!
1632   \fn QVariant::QVariant(QChar c)
1633
1634   Constructs a new variant with a char value, \a c.
1635 */
1636
1637 /*!
1638   \fn QVariant::QVariant(const QLocale &l)
1639
1640   Constructs a new variant with a locale value, \a l.
1641 */
1642
1643 /*!
1644   \fn QVariant::QVariant(const QRegExp &regExp)
1645
1646   Constructs a new variant with the regexp value \a regExp.
1647 */
1648
1649 /*!
1650   \fn QVariant::QVariant(const QRegularExpression &re)
1651
1652   \since 5.0
1653
1654   Constructs a new variant with the regular expression value \a re.
1655 */
1656
1657 QVariant::QVariant(Type type)
1658 { create(type, 0); }
1659 QVariant::QVariant(int typeId, const void *copy)
1660 { create(typeId, copy); d.is_null = false; }
1661
1662 /*!
1663     \internal
1664     flags is true if it is a pointer type
1665  */
1666 QVariant::QVariant(int typeId, const void *copy, uint flags)
1667 {
1668     if (flags) { //type is a pointer type
1669         d.type = typeId;
1670         d.data.ptr = *reinterpret_cast<void *const*>(copy);
1671     } else {
1672         create(typeId, copy);
1673     }
1674     d.is_null = false;
1675 }
1676
1677 QVariant::QVariant(int val)
1678     : d(Int)
1679 { d.data.i = val; }
1680 QVariant::QVariant(uint val)
1681     : d(UInt)
1682 { d.data.u = val; }
1683 QVariant::QVariant(qlonglong val)
1684     : d(LongLong)
1685 { d.data.ll = val; }
1686 QVariant::QVariant(qulonglong val)
1687     : d(ULongLong)
1688 { d.data.ull = val; }
1689 QVariant::QVariant(bool val)
1690     : d(Bool)
1691 { d.data.b = val; }
1692 QVariant::QVariant(double val)
1693     : d(Double)
1694 { d.data.d = val; }
1695 QVariant::QVariant(float val)
1696     : d(QMetaType::Float)
1697 { d.data.f = val; }
1698
1699 QVariant::QVariant(const QByteArray &val)
1700     : d(ByteArray)
1701 { v_construct<QByteArray>(&d, val); }
1702 QVariant::QVariant(const QBitArray &val)
1703     : d(BitArray)
1704 { v_construct<QBitArray>(&d, val);  }
1705 QVariant::QVariant(const QString &val)
1706     : d(String)
1707 { v_construct<QString>(&d, val);  }
1708 QVariant::QVariant(QChar val)
1709     : d(Char)
1710 { v_construct<QChar>(&d, val);  }
1711 QVariant::QVariant(QLatin1String val)
1712     : d(String)
1713 { v_construct<QString>(&d, val); }
1714 QVariant::QVariant(const QStringList &val)
1715     : d(StringList)
1716 { v_construct<QStringList>(&d, val); }
1717
1718 QVariant::QVariant(const QDate &val)
1719     : d(Date)
1720 { v_construct<QDate>(&d, val); }
1721 QVariant::QVariant(const QTime &val)
1722     : d(Time)
1723 { v_construct<QTime>(&d, val); }
1724 QVariant::QVariant(const QDateTime &val)
1725     : d(DateTime)
1726 { v_construct<QDateTime>(&d, val); }
1727 #ifndef QT_BOOTSTRAPPED
1728 QVariant::QVariant(const QEasingCurve &val)
1729     : d(EasingCurve)
1730 { v_construct<QEasingCurve>(&d, val); }
1731 #endif
1732 QVariant::QVariant(const QList<QVariant> &list)
1733     : d(List)
1734 { v_construct<QVariantList>(&d, list); }
1735 QVariant::QVariant(const QMap<QString, QVariant> &map)
1736     : d(Map)
1737 { v_construct<QVariantMap>(&d, map); }
1738 QVariant::QVariant(const QHash<QString, QVariant> &hash)
1739     : d(Hash)
1740 { v_construct<QVariantHash>(&d, hash); }
1741 #ifndef QT_NO_GEOM_VARIANT
1742 QVariant::QVariant(const QPoint &pt)
1743     : d(Point)
1744 { v_construct<QPoint>(&d, pt); }
1745 QVariant::QVariant(const QPointF &pt)
1746     : d(PointF)
1747 { v_construct<QPointF>(&d, pt); }
1748 QVariant::QVariant(const QRectF &r)
1749     : d(RectF)
1750 { v_construct<QRectF>(&d, r); }
1751 QVariant::QVariant(const QLineF &l)
1752     : d(LineF)
1753 { v_construct<QLineF>(&d, l); }
1754 QVariant::QVariant(const QLine &l)
1755     : d(Line)
1756 { v_construct<QLine>(&d, l); }
1757 QVariant::QVariant(const QRect &r)
1758     : d(Rect)
1759 { v_construct<QRect>(&d, r); }
1760 QVariant::QVariant(const QSize &s)
1761     : d(Size)
1762 { v_construct<QSize>(&d, s); }
1763 QVariant::QVariant(const QSizeF &s)
1764     : d(SizeF)
1765 { v_construct<QSizeF>(&d, s); }
1766 #endif
1767 #ifndef QT_BOOTSTRAPPED
1768 QVariant::QVariant(const QUrl &u)
1769     : d(Url)
1770 { v_construct<QUrl>(&d, u); }
1771 #endif
1772 QVariant::QVariant(const QLocale &l)
1773     : d(Locale)
1774 { v_construct<QLocale>(&d, l); }
1775 #ifndef QT_NO_REGEXP
1776 QVariant::QVariant(const QRegExp &regExp)
1777     : d(RegExp)
1778 { v_construct<QRegExp>(&d, regExp); }
1779 #endif // QT_NO_REGEXP
1780 #ifndef QT_BOOTSTRAPPED
1781 #ifndef QT_NO_REGULAREXPRESSION
1782 QVariant::QVariant(const QRegularExpression &re)
1783     : d(RegularExpression)
1784 { v_construct<QRegularExpression>(&d, re); }
1785 #endif
1786 QVariant::QVariant(const QUuid &uuid)
1787     : d(Uuid)
1788 { v_construct<QUuid>(&d, uuid); }
1789 QVariant::QVariant(const QModelIndex &modelIndex)
1790     : d(ModelIndex)
1791 { v_construct<QModelIndex>(&d, modelIndex); }
1792 QVariant::QVariant(const QPersistentModelIndex &modelIndex)
1793     : d(PersistentModelIndex)
1794 { v_construct<QPersistentModelIndex>(&d, modelIndex); }
1795 QVariant::QVariant(const QJsonValue &jsonValue)
1796     : d(QMetaType::QJsonValue)
1797 { v_construct<QJsonValue>(&d, jsonValue); }
1798 QVariant::QVariant(const QJsonObject &jsonObject)
1799     : d(QMetaType::QJsonObject)
1800 { v_construct<QJsonObject>(&d, jsonObject); }
1801 QVariant::QVariant(const QJsonArray &jsonArray)
1802     : d(QMetaType::QJsonArray)
1803 { v_construct<QJsonArray>(&d, jsonArray); }
1804 QVariant::QVariant(const QJsonDocument &jsonDocument)
1805     : d(QMetaType::QJsonDocument)
1806 { v_construct<QJsonDocument>(&d, jsonDocument); }
1807 #endif // QT_BOOTSTRAPPED
1808
1809 /*!
1810     Returns the storage type of the value stored in the variant.
1811     Although this function is declared as returning QVariant::Type,
1812     the return value should be interpreted as QMetaType::Type. In
1813     particular, QVariant::UserType is returned here only if the value
1814     is equal or greater than QMetaType::User.
1815
1816     Note that return values in the ranges QVariant::Char through
1817     QVariant::RegExp and QVariant::Font through QVariant::Transform
1818     correspond to the values in the ranges QMetaType::QChar through
1819     QMetaType::QRegExp and QMetaType::QFont through QMetaType::QQuaternion.
1820
1821     Pay particular attention when working with char and QChar
1822     variants.  Note that there is no QVariant constructor specifically
1823     for type char, but there is one for QChar. For a variant of type
1824     QChar, this function returns QVariant::Char, which is the same as
1825     QMetaType::QChar, but for a variant of type \c char, this function
1826     returns QMetaType::Char, which is \e not the same as
1827     QVariant::Char.
1828
1829     Also note that the types \c void*, \c long, \c short, \c unsigned
1830     \c long, \c unsigned \c short, \c unsigned \c char, \c float, \c
1831     QObject*, and \c QWidget* are represented in QMetaType::Type but
1832     not in QVariant::Type, and they can be returned by this function.
1833     However, they are considered to be user defined types when tested
1834     against QVariant::Type.
1835
1836     To test whether an instance of QVariant contains a data type that
1837     is compatible with the data type you are interested in, use
1838     canConvert().
1839 */
1840
1841 QVariant::Type QVariant::type() const
1842 {
1843     return d.type >= QMetaType::User ? UserType : static_cast<Type>(d.type);
1844 }
1845
1846 /*!
1847     Returns the storage type of the value stored in the variant. For
1848     non-user types, this is the same as type().
1849
1850     \sa type()
1851 */
1852
1853 int QVariant::userType() const
1854 {
1855     return d.type;
1856 }
1857
1858 /*!
1859     Assigns the value of the variant \a variant to this variant.
1860 */
1861 QVariant& QVariant::operator=(const QVariant &variant)
1862 {
1863     if (this == &variant)
1864         return *this;
1865
1866     clear();
1867     if (variant.d.is_shared) {
1868         variant.d.data.shared->ref.ref();
1869         d = variant.d;
1870     } else if (variant.d.type > Char) {
1871         d.type = variant.d.type;
1872         handlerManager[d.type]->construct(&d, variant.constData());
1873         d.is_null = variant.d.is_null;
1874     } else {
1875         d = variant.d;
1876     }
1877
1878     return *this;
1879 }
1880
1881 /*!
1882     \fn void QVariant::swap(QVariant &other)
1883     \since 4.8
1884
1885     Swaps variant \a other with this variant. This operation is very
1886     fast and never fails.
1887 */
1888
1889 /*!
1890     \fn void QVariant::detach()
1891
1892     \internal
1893 */
1894
1895 void QVariant::detach()
1896 {
1897     if (!d.is_shared || d.data.shared->ref.load() == 1)
1898         return;
1899
1900     Private dd;
1901     dd.type = d.type;
1902     handlerManager[d.type]->construct(&dd, constData());
1903     if (!d.data.shared->ref.deref())
1904         handlerManager[d.type]->clear(&d);
1905     d.data.shared = dd.data.shared;
1906 }
1907
1908 /*!
1909     \fn bool QVariant::isDetached() const
1910
1911     \internal
1912 */
1913
1914 /*!
1915     Returns the name of the type stored in the variant. The returned
1916     strings describe the C++ datatype used to store the data: for
1917     example, "QFont", "QString", or "QVariantList". An Invalid
1918     variant returns 0.
1919 */
1920 const char *QVariant::typeName() const
1921 {
1922     return QMetaType::typeName(d.type);
1923 }
1924
1925 /*!
1926     Convert this variant to type QMetaType::UnknownType and free up any resources
1927     used.
1928 */
1929 void QVariant::clear()
1930 {
1931     if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char))
1932         handlerManager[d.type]->clear(&d);
1933     d.type = Invalid;
1934     d.is_null = true;
1935     d.is_shared = false;
1936 }
1937
1938 /*!
1939     Converts the int representation of the storage type, \a typeId, to
1940     its string representation.
1941
1942     Returns a null pointer if the type is QMetaType::UnknownType or doesn't exist.
1943 */
1944 const char *QVariant::typeToName(int typeId)
1945 {
1946     return QMetaType::typeName(typeId);
1947 }
1948
1949
1950 /*!
1951     Converts the string representation of the storage type given in \a
1952     name, to its enum representation.
1953
1954     If the string representation cannot be converted to any enum
1955     representation, the variant is set to \c Invalid.
1956 */
1957 QVariant::Type QVariant::nameToType(const char *name)
1958 {
1959     int metaType = QMetaType::type(name);
1960     return metaType <= int(UserType) ? QVariant::Type(metaType) : UserType;
1961 }
1962
1963 #ifndef QT_NO_DATASTREAM
1964 enum { MapFromThreeCount = 36 };
1965 static const ushort mapIdFromQt3ToCurrent[MapFromThreeCount] =
1966 {
1967     QVariant::Invalid,
1968     QVariant::Map,
1969     QVariant::List,
1970     QVariant::String,
1971     QVariant::StringList,
1972     QVariant::Font,
1973     QVariant::Pixmap,
1974     QVariant::Brush,
1975     QVariant::Rect,
1976     QVariant::Size,
1977     QVariant::Color,
1978     QVariant::Palette,
1979     0, // ColorGroup
1980     QVariant::Icon,
1981     QVariant::Point,
1982     QVariant::Image,
1983     QVariant::Int,
1984     QVariant::UInt,
1985     QVariant::Bool,
1986     QVariant::Double,
1987     0, // Buggy ByteArray, QByteArray never had id == 20
1988     QVariant::Polygon,
1989     QVariant::Region,
1990     QVariant::Bitmap,
1991     QVariant::Cursor,
1992     QVariant::SizePolicy,
1993     QVariant::Date,
1994     QVariant::Time,
1995     QVariant::DateTime,
1996     QVariant::ByteArray,
1997     QVariant::BitArray,
1998     QVariant::KeySequence,
1999     QVariant::Pen,
2000     QVariant::LongLong,
2001     QVariant::ULongLong,
2002     QVariant::EasingCurve
2003 };
2004
2005 /*!
2006     Internal function for loading a variant from stream \a s. Use the
2007     stream operators instead.
2008
2009     \internal
2010 */
2011 void QVariant::load(QDataStream &s)
2012 {
2013     clear();
2014
2015     quint32 typeId;
2016     s >> typeId;
2017     if (s.version() < QDataStream::Qt_4_0) {
2018         if (typeId >= MapFromThreeCount)
2019             return;
2020         typeId = mapIdFromQt3ToCurrent[typeId];
2021     } else if (s.version() < QDataStream::Qt_5_0) {
2022         if (typeId == 127 /* QVariant::UserType */) {
2023             typeId = QMetaType::User;
2024         } else if (typeId >= 128 && typeId != QVariant::UserType) {
2025             // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
2026             // by moving all ids down by 97.
2027             typeId -= 97;
2028         } else if (typeId == 75 /* QSizePolicy */) {
2029             typeId = QMetaType::QSizePolicy;
2030         } else if (typeId > 75 && typeId <= 86) {
2031             // and as a result these types received lower ids too
2032             // QKeySequence QPen QTextLength QTextFormat QMatrix QTransform QMatrix4x4 QVector2D QVector3D QVector4D QQuaternion
2033             typeId -=1;
2034         }
2035     }
2036
2037     qint8 is_null = false;
2038     if (s.version() >= QDataStream::Qt_4_2)
2039         s >> is_null;
2040     if (typeId == QVariant::UserType) {
2041         QByteArray name;
2042         s >> name;
2043         typeId = QMetaType::type(name.constData());
2044         if (typeId == QMetaType::UnknownType) {
2045             s.setStatus(QDataStream::ReadCorruptData);
2046             return;
2047         }
2048     }
2049     create(typeId, 0);
2050     d.is_null = is_null;
2051
2052     if (!isValid()) {
2053         if (s.version() < QDataStream::Qt_5_0) {
2054         // Since we wrote something, we should read something
2055             QString x;
2056             s >> x;
2057         }
2058         d.is_null = true;
2059         return;
2060     }
2061
2062     // const cast is safe since we operate on a newly constructed variant
2063     if (!QMetaType::load(s, d.type, const_cast<void *>(constData()))) {
2064         s.setStatus(QDataStream::ReadCorruptData);
2065         qWarning("QVariant::load: unable to load type %d.", d.type);
2066     }
2067 }
2068
2069 /*!
2070     Internal function for saving a variant to the stream \a s. Use the
2071     stream operators instead.
2072
2073     \internal
2074 */
2075 void QVariant::save(QDataStream &s) const
2076 {
2077     quint32 typeId = type();
2078     bool fakeUserType = false;
2079     if (s.version() < QDataStream::Qt_4_0) {
2080         int i;
2081         for (i = 0; i <= MapFromThreeCount - 1; ++i) {
2082             if (mapIdFromQt3ToCurrent[i] == typeId) {
2083                 typeId = i;
2084                 break;
2085             }
2086         }
2087         if (i >= MapFromThreeCount) {
2088             s << QVariant();
2089             return;
2090         }
2091     } else if (s.version() < QDataStream::Qt_5_0) {
2092         if (typeId == QMetaType::User) {
2093             typeId = 127; // QVariant::UserType had this value in Qt4
2094         } else if (typeId >= 128 - 97 && typeId <= LastCoreType) {
2095             // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
2096             // by moving all ids down by 97.
2097             typeId += 97;
2098         } else if (typeId == QMetaType::QSizePolicy) {
2099             typeId = 75;
2100         } else if (typeId >= QMetaType::QKeySequence && typeId <= QMetaType::QQuaternion) {
2101             // and as a result these types received lower ids too
2102             typeId +=1;
2103         } else if (typeId == QMetaType::QPolygonF) {
2104             // This existed in Qt 4 only as a custom type
2105             typeId = 127;
2106             fakeUserType = true;
2107         }
2108     }
2109     s << typeId;
2110     if (s.version() >= QDataStream::Qt_4_2)
2111         s << qint8(d.is_null);
2112     if (d.type >= QVariant::UserType || fakeUserType) {
2113         s << QMetaType::typeName(userType());
2114     }
2115
2116     if (!isValid()) {
2117         if (s.version() < QDataStream::Qt_5_0)
2118             s << QString();
2119         return;
2120     }
2121
2122     if (!QMetaType::save(s, d.type, constData())) {
2123         qWarning("QVariant::save: unable to save type '%s' (type id: %d).\n", QMetaType::typeName(d.type), d.type);
2124         Q_ASSERT_X(false, "QVariant::save", "Invalid type to save");
2125     }
2126 }
2127
2128 /*!
2129     \since 4.4
2130
2131     Reads a variant \a p from the stream \a s.
2132
2133     \sa{Serializing Qt Data Types}{Format of the QDataStream operators}
2134 */
2135 QDataStream& operator>>(QDataStream &s, QVariant &p)
2136 {
2137     p.load(s);
2138     return s;
2139 }
2140
2141 /*!
2142     Writes a variant \a p to the stream \a s.
2143
2144     \sa{Serializing Qt Data Types}{Format of the QDataStream operators}
2145 */
2146 QDataStream& operator<<(QDataStream &s, const QVariant &p)
2147 {
2148     p.save(s);
2149     return s;
2150 }
2151
2152 /*!
2153     Reads a variant type \a p in enum representation from the stream \a s.
2154 */
2155 QDataStream& operator>>(QDataStream &s, QVariant::Type &p)
2156 {
2157     quint32 u;
2158     s >> u;
2159     p = (QVariant::Type)u;
2160
2161     return s;
2162 }
2163
2164 /*!
2165     Writes a variant type \a p to the stream \a s.
2166 */
2167 QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
2168 {
2169     s << static_cast<quint32>(p);
2170
2171     return s;
2172 }
2173
2174 #endif //QT_NO_DATASTREAM
2175
2176 /*!
2177     \fn bool QVariant::isValid() const
2178
2179     Returns \c true if the storage type of this variant is not
2180     QMetaType::UnknownType; otherwise returns \c false.
2181 */
2182
2183 template <typename T>
2184 inline T qVariantToHelper(const QVariant::Private &d, const HandlersManager &handlerManager)
2185 {
2186     const uint targetType = qMetaTypeId<T>();
2187     if (d.type == targetType)
2188         return *v_cast<T>(&d);
2189
2190     T ret;
2191     if (d.type >= QMetaType::User || targetType >= QMetaType::User) {
2192         const void * const from = constData(d);
2193         if (QMetaType::convert(from, d.type, &ret, targetType))
2194             return ret;
2195     }
2196
2197     handlerManager[d.type]->convert(&d, targetType, &ret, 0);
2198     return ret;
2199 }
2200
2201 /*!
2202     \fn QStringList QVariant::toStringList() const
2203
2204     Returns the variant as a QStringList if the variant has userType()
2205     \l QMetaType::QStringList, \l QMetaType::QString, or
2206     \l QMetaType::QVariantList of a type that can be converted to QString;
2207     otherwise returns an empty list.
2208
2209     \sa canConvert(), convert()
2210 */
2211 QStringList QVariant::toStringList() const
2212 {
2213     return qVariantToHelper<QStringList>(d, handlerManager);
2214 }
2215
2216 /*!
2217     Returns the variant as a QString if the variant has userType() \l
2218     QMetaType::QString, \l QMetaType::Bool, \l QMetaType::QByteArray,
2219     \l QMetaType::QChar, \l QMetaType::QDate, \l QMetaType::QDateTime,
2220     \l QMetaType::Double, \l QMetaType::Int, \l QMetaType::LongLong,
2221     \l QMetaType::QStringList, \l QMetaType::QTime, \l QMetaType::UInt, or
2222     \l QMetaType::ULongLong; otherwise returns an empty string.
2223
2224     \sa canConvert(), convert()
2225 */
2226 QString QVariant::toString() const
2227 {
2228     return qVariantToHelper<QString>(d, handlerManager);
2229 }
2230
2231 /*!
2232     Returns the variant as a QMap<QString, QVariant> if the variant
2233     has type() \l QMetaType::QVariantMap; otherwise returns an empty map.
2234
2235     \sa canConvert(), convert()
2236 */
2237 QVariantMap QVariant::toMap() const
2238 {
2239     return qVariantToHelper<QVariantMap>(d, handlerManager);
2240 }
2241
2242 /*!
2243     Returns the variant as a QHash<QString, QVariant> if the variant
2244     has type() \l QMetaType::QVariantHash; otherwise returns an empty map.
2245
2246     \sa canConvert(), convert()
2247 */
2248 QVariantHash QVariant::toHash() const
2249 {
2250     return qVariantToHelper<QVariantHash>(d, handlerManager);
2251 }
2252
2253 /*!
2254     \fn QDate QVariant::toDate() const
2255
2256     Returns the variant as a QDate if the variant has userType()
2257     \l QMetaType::QDate, \l QMetaType::QDateTime, or \l QMetaType::QString;
2258     otherwise returns an invalid date.
2259
2260     If the type() is \l QMetaType::QString, an invalid date will be returned if
2261     the string cannot be parsed as a Qt::ISODate format date.
2262
2263     \sa canConvert(), convert()
2264 */
2265 QDate QVariant::toDate() const
2266 {
2267     return qVariantToHelper<QDate>(d, handlerManager);
2268 }
2269
2270 /*!
2271     \fn QTime QVariant::toTime() const
2272
2273     Returns the variant as a QTime if the variant has userType()
2274     \l QMetaType::QTime, \l QMetaType::QDateTime, or \l QMetaType::QString;
2275     otherwise returns an invalid time.
2276
2277     If the type() is \l QMetaType::QString, an invalid time will be returned if
2278     the string cannot be parsed as a Qt::ISODate format time.
2279
2280     \sa canConvert(), convert()
2281 */
2282 QTime QVariant::toTime() const
2283 {
2284     return qVariantToHelper<QTime>(d, handlerManager);
2285 }
2286
2287 /*!
2288     \fn QDateTime QVariant::toDateTime() const
2289
2290     Returns the variant as a QDateTime if the variant has userType()
2291     \l QMetaType::QDateTime, \l QMetaType::QDate, or \l QMetaType::QString;
2292     otherwise returns an invalid date/time.
2293
2294     If the type() is \l QMetaType::QString, an invalid date/time will be
2295     returned if the string cannot be parsed as a Qt::ISODate format date/time.
2296
2297     \sa canConvert(), convert()
2298 */
2299 QDateTime QVariant::toDateTime() const
2300 {
2301     return qVariantToHelper<QDateTime>(d, handlerManager);
2302 }
2303
2304 /*!
2305     \since 4.7
2306     \fn QEasingCurve QVariant::toEasingCurve() const
2307
2308     Returns the variant as a QEasingCurve if the variant has userType()
2309     \l QMetaType::QEasingCurve; otherwise returns a default easing curve.
2310
2311     \sa canConvert(), convert()
2312 */
2313 #ifndef QT_BOOTSTRAPPED
2314 QEasingCurve QVariant::toEasingCurve() const
2315 {
2316     return qVariantToHelper<QEasingCurve>(d, handlerManager);
2317 }
2318 #endif
2319
2320 /*!
2321     \fn QByteArray QVariant::toByteArray() const
2322
2323     Returns the variant as a QByteArray if the variant has userType()
2324     \l QMetaType::QByteArray or \l QMetaType::QString (converted using
2325     QString::fromUtf8()); otherwise returns an empty byte array.
2326
2327     \sa canConvert(), convert()
2328 */
2329 QByteArray QVariant::toByteArray() const
2330 {
2331     return qVariantToHelper<QByteArray>(d, handlerManager);
2332 }
2333
2334 #ifndef QT_NO_GEOM_VARIANT
2335 /*!
2336     \fn QPoint QVariant::toPoint() const
2337
2338     Returns the variant as a QPoint if the variant has userType()
2339     \l QMetaType::QPointF or \l QMetaType::QPointF; otherwise returns a null
2340     QPoint.
2341
2342     \sa canConvert(), convert()
2343 */
2344 QPoint QVariant::toPoint() const
2345 {
2346     return qVariantToHelper<QPoint>(d, handlerManager);
2347 }
2348
2349 /*!
2350     \fn QRect QVariant::toRect() const
2351
2352     Returns the variant as a QRect if the variant has userType()
2353     \l QMetaType::QRect; otherwise returns an invalid QRect.
2354
2355     \sa canConvert(), convert()
2356 */
2357 QRect QVariant::toRect() const
2358 {
2359     return qVariantToHelper<QRect>(d, handlerManager);
2360 }
2361
2362 /*!
2363     \fn QSize QVariant::toSize() const
2364
2365     Returns the variant as a QSize if the variant has userType()
2366     \l QMetaType::QSize; otherwise returns an invalid QSize.
2367
2368     \sa canConvert(), convert()
2369 */
2370 QSize QVariant::toSize() const
2371 {
2372     return qVariantToHelper<QSize>(d, handlerManager);
2373 }
2374
2375 /*!
2376     \fn QSizeF QVariant::toSizeF() const
2377
2378     Returns the variant as a QSizeF if the variant has userType() \l
2379     QMetaType::QSizeF; otherwise returns an invalid QSizeF.
2380
2381     \sa canConvert(), convert()
2382 */
2383 QSizeF QVariant::toSizeF() const
2384 {
2385     return qVariantToHelper<QSizeF>(d, handlerManager);
2386 }
2387
2388 /*!
2389     \fn QRectF QVariant::toRectF() const
2390
2391     Returns the variant as a QRectF if the variant has userType()
2392     \l QMetaType::QRect or \l QMetaType::QRectF; otherwise returns an invalid
2393     QRectF.
2394
2395     \sa canConvert(), convert()
2396 */
2397 QRectF QVariant::toRectF() const
2398 {
2399     return qVariantToHelper<QRectF>(d, handlerManager);
2400 }
2401
2402 /*!
2403     \fn QLineF QVariant::toLineF() const
2404
2405     Returns the variant as a QLineF if the variant has userType()
2406     \l QMetaType::QLineF; otherwise returns an invalid QLineF.
2407
2408     \sa canConvert(), convert()
2409 */
2410 QLineF QVariant::toLineF() const
2411 {
2412     return qVariantToHelper<QLineF>(d, handlerManager);
2413 }
2414
2415 /*!
2416     \fn QLine QVariant::toLine() const
2417
2418     Returns the variant as a QLine if the variant has userType()
2419     \l QMetaType::QLine; otherwise returns an invalid QLine.
2420
2421     \sa canConvert(), convert()
2422 */
2423 QLine QVariant::toLine() const
2424 {
2425     return qVariantToHelper<QLine>(d, handlerManager);
2426 }
2427
2428 /*!
2429     \fn QPointF QVariant::toPointF() const
2430
2431     Returns the variant as a QPointF if the variant has userType() \l
2432     QMetaType::QPoint or \l QMetaType::QPointF; otherwise returns a null
2433     QPointF.
2434
2435     \sa canConvert(), convert()
2436 */
2437 QPointF QVariant::toPointF() const
2438 {
2439     return qVariantToHelper<QPointF>(d, handlerManager);
2440 }
2441
2442 #endif // QT_NO_GEOM_VARIANT
2443
2444 #ifndef QT_BOOTSTRAPPED
2445 /*!
2446     \fn QUrl QVariant::toUrl() const
2447
2448     Returns the variant as a QUrl if the variant has userType()
2449     \l QMetaType::QUrl; otherwise returns an invalid QUrl.
2450
2451     \sa canConvert(), convert()
2452 */
2453 QUrl QVariant::toUrl() const
2454 {
2455     return qVariantToHelper<QUrl>(d, handlerManager);
2456 }
2457 #endif
2458
2459 /*!
2460     \fn QLocale QVariant::toLocale() const
2461
2462     Returns the variant as a QLocale if the variant has userType()
2463     \l QMetaType::QLocale; otherwise returns an invalid QLocale.
2464
2465     \sa canConvert(), convert()
2466 */
2467 QLocale QVariant::toLocale() const
2468 {
2469     return qVariantToHelper<QLocale>(d, handlerManager);
2470 }
2471
2472 /*!
2473     \fn QRegExp QVariant::toRegExp() const
2474     \since 4.1
2475
2476     Returns the variant as a QRegExp if the variant has userType()
2477     \l QMetaType::QRegExp; otherwise returns an empty QRegExp.
2478
2479     \sa canConvert(), convert()
2480 */
2481 #ifndef QT_NO_REGEXP
2482 QRegExp QVariant::toRegExp() const
2483 {
2484     return qVariantToHelper<QRegExp>(d, handlerManager);
2485 }
2486 #endif
2487
2488 #ifndef QT_BOOTSTRAPPED
2489 /*!
2490     \fn QRegularExpression QVariant::toRegularExpression() const
2491     \since 5.0
2492
2493     Returns the variant as a QRegularExpression if the variant has userType() \l
2494     QRegularExpression; otherwise returns an empty QRegularExpression.
2495
2496     \sa canConvert(), convert()
2497 */
2498 #ifndef QT_NO_REGULAREXPRESSION
2499 QRegularExpression QVariant::toRegularExpression() const
2500 {
2501     return qVariantToHelper<QRegularExpression>(d, handlerManager);
2502 }
2503 #endif // QT_NO_REGULAREXPRESSION
2504
2505 /*!
2506     \since 5.0
2507
2508     Returns the variant as a QUuid if the variant has userType() \l
2509     QUuid; otherwise returns a default constructed QUuid.
2510
2511     \sa canConvert(), convert()
2512 */
2513 QUuid QVariant::toUuid() const
2514 {
2515     return qVariantToHelper<QUuid>(d, handlerManager);
2516 }
2517
2518 /*!
2519     \since 5.0
2520
2521     Returns the variant as a QModelIndex if the variant has userType() \l
2522     QModelIndex; otherwise returns a default constructed QModelIndex.
2523
2524     \sa canConvert(), convert(), toPersistentModelIndex()
2525 */
2526 QModelIndex QVariant::toModelIndex() const
2527 {
2528     return qVariantToHelper<QModelIndex>(d, handlerManager);
2529 }
2530
2531 /*!
2532     \since 5.5
2533
2534     Returns the variant as a QPersistentModelIndex if the variant has userType() \l
2535     QPersistentModelIndex; otherwise returns a default constructed QPersistentModelIndex.
2536
2537     \sa canConvert(), convert(), toModelIndex()
2538 */
2539 QPersistentModelIndex QVariant::toPersistentModelIndex() const
2540 {
2541     return qVariantToHelper<QPersistentModelIndex>(d, handlerManager);
2542 }
2543
2544 /*!
2545     \since 5.0
2546
2547     Returns the variant as a QJsonValue if the variant has userType() \l
2548     QJsonValue; otherwise returns a default constructed QJsonValue.
2549
2550     \sa canConvert(), convert()
2551 */
2552 QJsonValue QVariant::toJsonValue() const
2553 {
2554     return qVariantToHelper<QJsonValue>(d, handlerManager);
2555 }
2556
2557 /*!
2558     \since 5.0
2559
2560     Returns the variant as a QJsonObject if the variant has userType() \l
2561     QJsonObject; otherwise returns a default constructed QJsonObject.
2562
2563     \sa canConvert(), convert()
2564 */
2565 QJsonObject QVariant::toJsonObject() const
2566 {
2567     return qVariantToHelper<QJsonObject>(d, handlerManager);
2568 }
2569
2570 /*!
2571     \since 5.0
2572
2573     Returns the variant as a QJsonArray if the variant has userType() \l
2574     QJsonArray; otherwise returns a default constructed QJsonArray.
2575
2576     \sa canConvert(), convert()
2577 */
2578 QJsonArray QVariant::toJsonArray() const
2579 {
2580     return qVariantToHelper<QJsonArray>(d, handlerManager);
2581 }
2582
2583 /*!
2584     \since 5.0
2585
2586     Returns the variant as a QJsonDocument if the variant has userType() \l
2587     QJsonDocument; otherwise returns a default constructed QJsonDocument.
2588
2589     \sa canConvert(), convert()
2590 */
2591 QJsonDocument QVariant::toJsonDocument() const
2592 {
2593     return qVariantToHelper<QJsonDocument>(d, handlerManager);
2594 }
2595 #endif
2596
2597 /*!
2598     \fn QChar QVariant::toChar() const
2599
2600     Returns the variant as a QChar if the variant has userType()
2601     \l QMetaType::QChar, \l QMetaType::Int, or \l QMetaType::UInt; otherwise
2602     returns an invalid QChar.
2603
2604     \sa canConvert(), convert()
2605 */
2606 QChar QVariant::toChar() const
2607 {
2608     return qVariantToHelper<QChar>(d, handlerManager);
2609 }
2610
2611 /*!
2612     Returns the variant as a QBitArray if the variant has userType()
2613     \l QMetaType::QBitArray; otherwise returns an empty bit array.
2614
2615     \sa canConvert(), convert()
2616 */
2617 QBitArray QVariant::toBitArray() const
2618 {
2619     return qVariantToHelper<QBitArray>(d, handlerManager);
2620 }
2621
2622 template <typename T>
2623 inline T qNumVariantToHelper(const QVariant::Private &d,
2624                              const HandlersManager &handlerManager, bool *ok, const T& val)
2625 {
2626     const uint t = qMetaTypeId<T>();
2627     if (ok)
2628         *ok = true;
2629
2630     if (d.type == t)
2631         return val;
2632
2633     T ret = 0;
2634     if ((d.type >= QMetaType::User || t >= QMetaType::User)
2635         && QMetaType::convert(constData(d), d.type, &ret, t))
2636         return ret;
2637
2638     if (!handlerManager[d.type]->convert(&d, t, &ret, ok) && ok)
2639         *ok = false;
2640     return ret;
2641 }
2642
2643 /*!
2644     Returns the variant as an int if the variant has userType()
2645     \l QMetaType::Int, \l QMetaType::Bool, \l QMetaType::QByteArray,
2646     \l QMetaType::QChar, \l QMetaType::Double, \l QMetaType::LongLong,
2647     \l QMetaType::QString, \l QMetaType::UInt, or \l QMetaType::ULongLong;
2648     otherwise returns 0.
2649
2650     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2651     converted to an int; otherwise \c{*}\a{ok} is set to false.
2652
2653     \b{Warning:} If the value is convertible to a \l QMetaType::LongLong but is
2654     too large to be represented in an int, the resulting arithmetic overflow
2655     will not be reflected in \a ok. A simple workaround is to use
2656     QString::toInt().
2657
2658     \sa canConvert(), convert()
2659 */
2660 int QVariant::toInt(bool *ok) const
2661 {
2662     return qNumVariantToHelper<int>(d, handlerManager, ok, d.data.i);
2663 }
2664
2665 /*!
2666     Returns the variant as an unsigned int if the variant has userType()
2667     \l QMetaType::UInt, \l QMetaType::Bool, \l QMetaType::QByteArray,
2668     \l QMetaType::QChar, \l QMetaType::Double, \l QMetaType::Int,
2669     \l QMetaType::LongLong, \l QMetaType::QString, or \l QMetaType::ULongLong;
2670     otherwise returns 0.
2671
2672     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2673     converted to an unsigned int; otherwise \c{*}\a{ok} is set to false.
2674
2675     \b{Warning:} If the value is convertible to a \l QMetaType::ULongLong but is
2676     too large to be represented in an unsigned int, the resulting arithmetic
2677     overflow will not be reflected in \a ok. A simple workaround is to use
2678     QString::toUInt().
2679
2680     \sa canConvert(), convert()
2681 */
2682 uint QVariant::toUInt(bool *ok) const
2683 {
2684     return qNumVariantToHelper<uint>(d, handlerManager, ok, d.data.u);
2685 }
2686
2687 /*!
2688     Returns the variant as a long long int if the variant has userType()
2689     \l QMetaType::LongLong, \l QMetaType::Bool, \l QMetaType::QByteArray,
2690     \l QMetaType::QChar, \l QMetaType::Double, \l QMetaType::Int,
2691     \l QMetaType::QString, \l QMetaType::UInt, or \l QMetaType::ULongLong;
2692     otherwise returns 0.
2693
2694     If \a ok is non-null: \c{*}\c{ok} is set to true if the value could be
2695     converted to an int; otherwise \c{*}\c{ok} is set to false.
2696
2697     \sa canConvert(), convert()
2698 */
2699 qlonglong QVariant::toLongLong(bool *ok) const
2700 {
2701     return qNumVariantToHelper<qlonglong>(d, handlerManager, ok, d.data.ll);
2702 }
2703
2704 /*!
2705     Returns the variant as as an unsigned long long int if the
2706     variant has type() \l QMetaType::ULongLong, \l QMetaType::Bool,
2707     \l QMetaType::QByteArray, \l QMetaType::QChar, \l QMetaType::Double,
2708     \l QMetaType::Int, \l QMetaType::LongLong, \l QMetaType::QString, or
2709     \l QMetaType::UInt; otherwise returns 0.
2710
2711     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2712     converted to an int; otherwise \c{*}\a{ok} is set to false.
2713
2714     \sa canConvert(), convert()
2715 */
2716 qulonglong QVariant::toULongLong(bool *ok) const
2717 {
2718     return qNumVariantToHelper<qulonglong>(d, handlerManager, ok, d.data.ull);
2719 }
2720
2721 /*!
2722     Returns the variant as a bool if the variant has userType() Bool.
2723
2724     Returns \c true if the variant has userType() \l QMetaType::Bool,
2725     \l QMetaType::QChar, \l QMetaType::Double, \l QMetaType::Int,
2726     \l QMetaType::LongLong, \l QMetaType::UInt, or \l QMetaType::ULongLong and
2727     the value is non-zero, or if the variant has type \l QMetaType::QString or
2728     \l QMetaType::QByteArray and its lower-case content is not one of the
2729     following: empty, "0" or "false"; otherwise returns \c false.
2730
2731     \sa canConvert(), convert()
2732 */
2733 bool QVariant::toBool() const
2734 {
2735     if (d.type == Bool)
2736         return d.data.b;
2737
2738     bool res = false;
2739     handlerManager[d.type]->convert(&d, Bool, &res, 0);
2740
2741     return res;
2742 }
2743
2744 /*!
2745     Returns the variant as a double if the variant has userType()
2746     \l QMetaType::Double, \l QMetaType::Float, \l QMetaType::Bool,
2747     \l QMetaType::QByteArray, \l QMetaType::Int, \l QMetaType::LongLong,
2748     \l QMetaType::QString, \l QMetaType::UInt, or \l QMetaType::ULongLong;
2749     otherwise returns 0.0.
2750
2751     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2752     converted to a double; otherwise \c{*}\a{ok} is set to false.
2753
2754     \sa canConvert(), convert()
2755 */
2756 double QVariant::toDouble(bool *ok) const
2757 {
2758     return qNumVariantToHelper<double>(d, handlerManager, ok, d.data.d);
2759 }
2760
2761 /*!
2762     Returns the variant as a float if the variant has userType()
2763     \l QMetaType::Double, \l QMetaType::Float, \l QMetaType::Bool,
2764     \l QMetaType::QByteArray, \l QMetaType::Int, \l QMetaType::LongLong,
2765     \l QMetaType::QString, \l QMetaType::UInt, or \l QMetaType::ULongLong;
2766     otherwise returns 0.0.
2767
2768     \since 4.6
2769
2770     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2771     converted to a double; otherwise \c{*}\a{ok} is set to false.
2772
2773     \sa canConvert(), convert()
2774 */
2775 float QVariant::toFloat(bool *ok) const
2776 {
2777     return qNumVariantToHelper<float>(d, handlerManager, ok, d.data.f);
2778 }
2779
2780 /*!
2781     Returns the variant as a qreal if the variant has userType()
2782     \l QMetaType::Double, \l QMetaType::Float, \l QMetaType::Bool,
2783     \l QMetaType::QByteArray, \l QMetaType::Int, \l QMetaType::LongLong,
2784     \l QMetaType::QString, \l QMetaType::UInt, or \l QMetaType::ULongLong;
2785     otherwise returns 0.0.
2786
2787     \since 4.6
2788
2789     If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2790     converted to a double; otherwise \c{*}\a{ok} is set to false.
2791
2792     \sa canConvert(), convert()
2793 */
2794 qreal QVariant::toReal(bool *ok) const
2795 {
2796     return qNumVariantToHelper<qreal>(d, handlerManager, ok, d.data.real);
2797 }
2798
2799 /*!
2800     Returns the variant as a QVariantList if the variant has userType()
2801     \l QMetaType::QVariantList or \l QMetaType::QStringList; otherwise returns
2802     an empty list.
2803
2804     \sa canConvert(), convert()
2805 */
2806 QVariantList QVariant::toList() const
2807 {
2808     return qVariantToHelper<QVariantList>(d, handlerManager);
2809 }
2810
2811
2812 static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
2813 {
2814 /*Invalid*/     0,
2815
2816 /*Bool*/          1 << QVariant::Double     | 1 << QVariant::Int        | 1 << QVariant::UInt
2817                 | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong  | 1 << QVariant::ByteArray
2818                 | 1 << QVariant::String     | 1 << QVariant::Char,
2819
2820 /*Int*/           1 << QVariant::UInt       | 1 << QVariant::String     | 1 << QVariant::Double
2821                 | 1 << QVariant::Bool       | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong
2822                 | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
2823
2824 /*UInt*/          1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
2825                 | 1 << QVariant::Bool       | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong
2826                 | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
2827
2828 /*LLong*/         1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
2829                 | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::ULongLong
2830                 | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
2831
2832 /*ULlong*/        1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
2833                 | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::LongLong
2834                 | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
2835
2836 /*double*/        1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::ULongLong
2837                 | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::LongLong
2838                 | 1 << QVariant::ByteArray,
2839
2840 /*QChar*/         1 << QVariant::Int        | 1 << QVariant::UInt       | 1 << QVariant::LongLong
2841                 | 1 << QVariant::ULongLong,
2842
2843 /*QMap*/          0,
2844
2845 /*QList*/         1 << QVariant::StringList,
2846
2847 /*QString*/       1 << QVariant::StringList | 1 << QVariant::ByteArray  | 1 << QVariant::Int
2848                 | 1 << QVariant::UInt       | 1 << QVariant::Bool       | 1 << QVariant::Double
2849                 | 1 << QVariant::Date       | 1 << QVariant::Time       | 1 << QVariant::DateTime
2850                 | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong  | 1 << QVariant::Char
2851                 | 1 << QVariant::Url        | 1 << QVariant::Uuid,
2852
2853 /*QStringList*/   1 << QVariant::List       | 1 << QVariant::String,
2854
2855 /*QByteArray*/    1 << QVariant::String     | 1 << QVariant::Int        | 1 << QVariant::UInt | 1 << QVariant::Bool
2856                 | 1 << QVariant::Double     | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong,
2857
2858 /*QBitArray*/     0,
2859
2860 /*QDate*/         1 << QVariant::String     | 1 << QVariant::DateTime,
2861
2862 /*QTime*/         1 << QVariant::String     | 1 << QVariant::DateTime,
2863
2864 /*QDateTime*/     1 << QVariant::String     | 1 << QVariant::Date,
2865
2866 /*QUrl*/          1 << QVariant::String,
2867
2868 /*QLocale*/       0,
2869
2870 /*QRect*/         1 << QVariant::RectF,
2871
2872 /*QRectF*/        1 << QVariant::Rect,
2873
2874 /*QSize*/         1 << QVariant::SizeF,
2875
2876 /*QSizeF*/        1 << QVariant::Size,
2877
2878 /*QLine*/         1 << QVariant::LineF,
2879
2880 /*QLineF*/        1 << QVariant::Line,
2881
2882 /*QPoint*/        1 << QVariant::PointF,
2883
2884 /*QPointF*/       1 << QVariant::Point,
2885
2886 /*QRegExp*/       0,
2887
2888 /*QHash*/         0,
2889
2890 /*QEasingCurve*/  0,
2891
2892 /*QUuid*/         1 << QVariant::String
2893 };
2894
2895 #ifndef QT_BOOTSTRAPPED
2896 /*!
2897     Returns \c true if from inherits to.
2898 */
2899 static bool canConvertMetaObject(const QMetaObject *from, const QMetaObject *to)
2900 {
2901     if (from && to == &QObject::staticMetaObject)
2902         return true;
2903
2904     while (from) {
2905         if (from == to)
2906             return true;
2907         from = from->superClass();
2908     }
2909
2910     return false;
2911 }
2912 #endif
2913
2914 static bool canConvertMetaObject(int fromId, int toId, QObject *fromObject)
2915 {
2916 #ifndef QT_BOOTSTRAPPED
2917     QMetaType toType(toId);
2918     if ((QMetaType::typeFlags(fromId) & QMetaType::PointerToQObject) && (toType.flags() & QMetaType::PointerToQObject)) {
2919         if (!fromObject)
2920             return true;
2921         return canConvertMetaObject(fromObject->metaObject(), toType.metaObject());
2922     }
2923 #else
2924     Q_UNUSED(fromId);
2925     Q_UNUSED(toId);
2926     Q_UNUSED(fromObject);
2927 #endif
2928     return false;
2929 }
2930
2931
2932 /*!
2933     Returns \c true if the variant's type can be cast to the requested
2934     type, \a targetTypeId. Such casting is done automatically when calling the
2935     toInt(), toBool(), ... methods.
2936
2937     The following casts are done automatically:
2938
2939     \table
2940     \header \li Type \li Automatically Cast To
2941     \row \li \l QMetaType::Bool \li \l QMetaType::QChar, \l QMetaType::Double,
2942         \l QMetaType::Int, \l QMetaType::LongLong, \l QMetaType::QString,
2943         \l QMetaType::UInt, \l QMetaType::ULongLong
2944     \row \li \l QMetaType::QByteArray \li \l QMetaType::Double,
2945         \l QMetaType::Int, \l QMetaType::LongLong, \l QMetaType::QString,
2946         \l QMetaType::UInt, \l QMetaType::ULongLong
2947     \row \li \l QMetaType::QChar \li \l QMetaType::Bool, \l QMetaType::Int,
2948         \l QMetaType::UInt, \l QMetaType::LongLong, \l QMetaType::ULongLong
2949     \row \li \l QMetaType::QColor \li \l QMetaType::QString
2950     \row \li \l QMetaType::QDate \li \l QMetaType::QDateTime,
2951         \l QMetaType::QString
2952     \row \li \l QMetaType::QDateTime \li \l QMetaType::QDate,
2953         \l QMetaType::QString, \l QMetaType::QTime
2954     \row \li \l QMetaType::Double \li \l QMetaType::Bool, \l QMetaType::Int,
2955         \l QMetaType::LongLong, \l QMetaType::QString, \l QMetaType::UInt,
2956         \l QMetaType::ULongLong
2957     \row \li \l QMetaType::QFont \li \l QMetaType::QString
2958     \row \li \l QMetaType::Int \li \l QMetaType::Bool, \l QMetaType::QChar,
2959         \l QMetaType::Double, \l QMetaType::LongLong, \l QMetaType::QString,
2960         \l QMetaType::UInt, \l QMetaType::ULongLong
2961     \row \li \l QMetaType::QKeySequence \li \l QMetaType::Int,
2962         \l QMetaType::QString
2963     \row \li \l QMetaType::QVariantList \li \l QMetaType::QStringList (if the
2964         list's items can be converted to QStrings)
2965     \row \li \l QMetaType::LongLong \li \l QMetaType::Bool,
2966         \l QMetaType::QByteArray, \l QMetaType::QChar, \l QMetaType::Double,
2967         \l QMetaType::Int, \l QMetaType::QString, \l QMetaType::UInt,
2968         \l QMetaType::ULongLong
2969     \row \li \l QMetaType::QPoint \li QMetaType::QPointF
2970     \row \li \l QMetaType::QRect \li QMetaType::QRectF
2971     \row \li \l QMetaType::QString \li \l QMetaType::Bool,
2972         \l QMetaType::QByteArray, \l QMetaType::QChar, \l QMetaType::QColor,
2973         \l QMetaType::QDate, \l QMetaType::QDateTime, \l QMetaType::Double,
2974         \l QMetaType::QFont, \l QMetaType::Int, \l QMetaType::QKeySequence,
2975         \l QMetaType::LongLong, \l QMetaType::QStringList, \l QMetaType::QTime,
2976         \l QMetaType::UInt, \l QMetaType::ULongLong
2977     \row \li \l QMetaType::QStringList \li \l QMetaType::QVariantList,
2978         \l QMetaType::QString (if the list contains exactly one item)
2979     \row \li \l QMetaType::QTime \li \l QMetaType::QString
2980     \row \li \l QMetaType::UInt \li \l QMetaType::Bool, \l QMetaType::QChar,
2981         \l QMetaType::Double, \l QMetaType::Int, \l QMetaType::LongLong,
2982         \l QMetaType::QString, \l QMetaType::ULongLong
2983     \row \li \l QMetaType::ULongLong \li \l QMetaType::Bool,
2984         \l QMetaType::QChar, \l QMetaType::Double, \l QMetaType::Int,
2985         \l QMetaType::LongLong, \l QMetaType::QString, \l QMetaType::UInt
2986     \endtable
2987
2988     A QVariant containing a pointer to a type derived from QObject will also return true for this
2989     function if a qobject_cast to the type described by \a targetTypeId would succeed. Note that
2990     this only works for QObject subclasses which use the Q_OBJECT macro.
2991
2992     A QVariant containing a sequential container will also return true for this
2993     function if the \a targetTypeId is QVariantList. It is possible to iterate over
2994     the contents of the container without extracting it as a (copied) QVariantList:
2995
2996     \snippet code/src_corelib_kernel_qvariant.cpp 9
2997
2998     This requires that the value_type of the container is itself a metatype.
2999
3000     Similarly, a QVariant containing a sequential container will also return true for this
3001     function the \a targetTypeId is QVariantHash or QVariantMap. It is possible to iterate over
3002     the contents of the container without extracting it as a (copied) QVariantHash or QVariantMap:
3003
3004     \snippet code/src_corelib_kernel_qvariant.cpp 10
3005
3006     \sa convert(), QSequentialIterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QAssociativeIterable,
3007         Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE()
3008 */
3009 bool QVariant::canConvert(int targetTypeId) const
3010 {
3011     if ((targetTypeId == QMetaType::QModelIndex && d.type == QMetaType::QPersistentModelIndex)
3012         || (targetTypeId == QMetaType::QPersistentModelIndex && d.type == QMetaType::QModelIndex))
3013         return true;
3014
3015     if (targetTypeId == QMetaType::QVariantList
3016             && (d.type == QMetaType::QVariantList
3017               || d.type == QMetaType::QStringList
3018               || d.type == QMetaType::QByteArrayList
3019               || QMetaType::hasRegisteredConverterFunction(d.type,
3020                     qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>()))) {
3021         return true;
3022     }
3023
3024     if ((targetTypeId == QMetaType::QVariantHash || targetTypeId == QMetaType::QVariantMap)
3025             && (d.type == QMetaType::QVariantMap
3026               || d.type == QMetaType::QVariantHash
3027               || QMetaType::hasRegisteredConverterFunction(d.type,
3028                     qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>()))) {
3029         return true;
3030     }
3031
3032     if (targetTypeId == qMetaTypeId<QPair<QVariant, QVariant> >() &&
3033               QMetaType::hasRegisteredConverterFunction(d.type,
3034                     qMetaTypeId<QtMetaTypePrivate::QPairVariantInterfaceImpl>())) {
3035         return true;
3036     }
3037
3038     if ((d.type >= QMetaType::User || targetTypeId >= QMetaType::User)
3039         && QMetaType::hasRegisteredConverterFunction(d.type, targetTypeId)) {
3040         return true;
3041     }
3042
3043     // TODO Reimplement this function, currently it works but it is a historical mess.
3044     uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type);
3045     if (currentType == QMetaType::SChar || currentType == QMetaType::Char)
3046         currentType = QMetaType::UInt;
3047     if (targetTypeId == QMetaType::SChar || currentType == QMetaType::Char)
3048         targetTypeId = QMetaType::UInt;
3049     if (uint(targetTypeId) == uint(QMetaType::Float)) targetTypeId = QVariant::Double;
3050
3051
3052     if (currentType == uint(targetTypeId))
3053         return true;
3054
3055     if (targetTypeId < 0)
3056         return false;
3057     if (targetTypeId >= QMetaType::User) {
3058         if (QMetaType::typeFlags(targetTypeId) & QMetaType::IsEnumeration) {
3059             targetTypeId = QMetaType::Int;
3060         } else {
3061             return canConvertMetaObject(currentType, targetTypeId, d.data.o);
3062         }
3063     }
3064
3065     if (currentType == QMetaType::QJsonValue) {
3066         switch (targetTypeId) {
3067         case QMetaType::QString:
3068         case QMetaType::Bool:
3069         case QMetaType::Int:
3070         case QMetaType::UInt:
3071         case QMetaType::Double:
3072         case QMetaType::Float:
3073         case QMetaType::ULong:
3074         case QMetaType::Long:
3075         case QMetaType::LongLong:
3076         case QMetaType::ULongLong:
3077         case QMetaType::UShort:
3078         case QMetaType::UChar:
3079         case QMetaType::Char:
3080         case QMetaType::SChar:
3081         case QMetaType::Short:
3082         case QMetaType::QVariantList:
3083         case QMetaType::QVariantMap:
3084         case QMetaType::QVariantHash:
3085             return true;
3086         default:
3087             return false;
3088         }
3089     }
3090     if (currentType == QMetaType::QJsonArray)
3091         return targetTypeId == QMetaType::QVariantList;
3092     if (currentType == QMetaType::QJsonObject)
3093         return targetTypeId == QMetaType::QVariantMap || targetTypeId == QMetaType::QVariantHash;
3094
3095     // FIXME It should be LastCoreType intead of Uuid
3096     if (currentType > int(QMetaType::QUuid) || targetTypeId > int(QMetaType::QUuid)) {
3097         switch (uint(targetTypeId)) {
3098         case QVariant::Int:
3099             if (currentType == QVariant::KeySequence)
3100                 return true;
3101             // fall through
3102         case QVariant::UInt:
3103         case QVariant::LongLong:
3104         case QVariant::ULongLong:
3105                return currentType == QMetaType::ULong
3106                    || currentType == QMetaType::Long
3107                    || currentType == QMetaType::UShort
3108                    || currentType == QMetaType::UChar
3109                    || currentType == QMetaType::Char
3110                    || currentType == QMetaType::SChar
3111                    || currentType == QMetaType::Short
3112                    || QMetaType::typeFlags(currentType) & QMetaType::IsEnumeration;
3113         case QVariant::Image:
3114             return currentType == QVariant::Pixmap || currentType == QVariant::Bitmap;
3115         case QVariant::Pixmap:
3116             return currentType == QVariant::Image || currentType == QVariant::Bitmap
3117                               || currentType == QVariant::Brush;
3118         case QVariant::Bitmap:
3119             return currentType == QVariant::Pixmap || currentType == QVariant::Image;
3120         case QVariant::ByteArray:
3121             return currentType == QVariant::Color
3122                               || ((QMetaType::typeFlags(currentType) & QMetaType::IsEnumeration) && QMetaType::metaObjectForType(currentType));
3123         case QVariant::String:
3124             return currentType == QVariant::KeySequence || currentType == QVariant::Font
3125                               || currentType == QVariant::Color
3126                               || ((QMetaType::typeFlags(currentType) & QMetaType::IsEnumeration) && QMetaType::metaObjectForType(currentType));
3127         case QVariant::KeySequence:
3128             return currentType == QVariant::String || currentType == QVariant::Int;
3129         case QVariant::Font:
3130             return currentType == QVariant::String;
3131         case QVariant::Color:
3132             return currentType == QVariant::String || currentType == QVariant::ByteArray
3133                               || currentType == QVariant::Brush;
3134         case QVariant::Brush:
3135             return currentType == QVariant::Color || currentType == QVariant::Pixmap;
3136         case QMetaType::Long:
3137         case QMetaType::Char:
3138         case QMetaType::SChar:
3139         case QMetaType::UChar:
3140         case QMetaType::ULong:
3141         case QMetaType::Short:
3142         case QMetaType::UShort:
3143             return qCanConvertMatrix[QVariant::Int] & (1 << currentType)
3144                 || currentType == QVariant::Int
3145                 || QMetaType::typeFlags(currentType) & QMetaType::IsEnumeration;
3146         case QMetaType::QObjectStar:
3147             return canConvertMetaObject(currentType, targetTypeId, d.data.o);
3148         default:
3149             return false;
3150         }
3151     }
3152
3153     if (targetTypeId == String && currentType == StringList)
3154         return v_cast<QStringList>(&d)->count() == 1;
3155     return qCanConvertMatrix[targetTypeId] & (1 << currentType);
3156 }
3157
3158 /*!
3159     Casts the variant to the requested type, \a targetTypeId. If the cast cannot be
3160     done, the variant is cleared. Returns \c true if the current type of
3161     the variant was successfully cast; otherwise returns \c false.
3162
3163     A QVariant containing a pointer to a type derived from QObject will also convert
3164     and return true for this function if a qobject_cast to the type described
3165     by \a targetTypeId would succeed. Note that this only works for QObject subclasses
3166     which use the Q_OBJECT macro.
3167
3168     \warning For historical reasons, converting a null QVariant results
3169     in a null value of the desired type (e.g., an empty string for
3170     QString) and a result of false.
3171
3172     \sa canConvert(), clear()
3173 */
3174
3175 bool QVariant::convert(int targetTypeId)
3176 {
3177     if (d.type == uint(targetTypeId))
3178         return true;
3179
3180     QVariant oldValue = *this;
3181
3182     clear();
3183     if (!oldValue.canConvert(targetTypeId))
3184         return false;
3185
3186     create(targetTypeId, 0);
3187     if (oldValue.isNull())
3188         return false;
3189
3190     if ((QMetaType::typeFlags(oldValue.userType()) & QMetaType::PointerToQObject) && (QMetaType::typeFlags(targetTypeId) & QMetaType::PointerToQObject)) {
3191         create(targetTypeId, &oldValue.d.data.o);
3192         return true;
3193     }
3194
3195     bool isOk = true;
3196     int converterType = std::max(oldValue.userType(), targetTypeId);
3197     if (!handlerManager[converterType]->convert(&oldValue.d, targetTypeId, data(), &isOk))
3198         isOk = false;
3199     d.is_null = !isOk;
3200     return isOk;
3201 }
3202
3203 /*!
3204   \fn bool QVariant::convert(const int type, void *ptr) const
3205   \internal
3206   Created for qvariant_cast() usage
3207 */
3208 bool QVariant::convert(const int type, void *ptr) const
3209 {
3210     return handlerManager[type]->convert(&d, type, ptr, 0);
3211 }
3212
3213
3214 /*!
3215     \fn bool operator==(const QVariant &v1, const QVariant &v2)
3216
3217     \relates QVariant
3218
3219     Returns \c true if \a v1 and \a v2 are equal; otherwise returns \c false.
3220
3221     If \a v1 and \a v2 have the same \l{QVariant::}{type()}, the
3222     type's equality operator is used for comparison. If not, it is
3223     attempted to \l{QVariant::}{convert()} \a v2 to the same type as
3224     \a v1. See \l{QVariant::}{canConvert()} for a list of possible
3225     conversions.
3226
3227     The result of the function is not affected by the result of QVariant::isNull,
3228     which means that two values can be equal even if one of them is null and
3229     another is not.
3230
3231     \warning To make this function work with a custom type registered with
3232     qRegisterMetaType(), its comparison operator must be registered using
3233     QMetaType::registerComparators().
3234 */
3235 /*!
3236     \fn bool operator!=(const QVariant &v1, const QVariant &v2)
3237
3238     \relates QVariant
3239
3240     Returns \c false if \a v1 and \a v2 are equal; otherwise returns \c true.
3241
3242     \warning To make this function work with a custom type registered with
3243     qRegisterMetaType(), its comparison operator must be registered using
3244     QMetaType::registerComparators().
3245 */
3246
3247 /*! \fn bool QVariant::operator==(const QVariant &v) const
3248
3249     Compares this QVariant with \a v and returns \c true if they are
3250     equal; otherwise returns \c false.
3251
3252     QVariant uses the equality operator of the type() it contains to
3253     check for equality. QVariant will try to convert() \a v if its
3254     type is not the same as this variant's type. See canConvert() for
3255     a list of possible conversions.
3256
3257     \warning To make this function work with a custom type registered with
3258     qRegisterMetaType(), its comparison operator must be registered using
3259     QMetaType::registerComparators().
3260 */
3261
3262 /*!
3263     \fn bool QVariant::operator!=(const QVariant &v) const
3264
3265     Compares this QVariant with \a v and returns \c true if they are not
3266     equal; otherwise returns \c false.
3267
3268     \warning To make this function work with a custom type registered with
3269     qRegisterMetaType(), its comparison operator must be registered using
3270     QMetaType::registerComparators().
3271 */
3272
3273 /*!
3274     \fn bool QVariant::operator<(const QVariant &v) const
3275
3276     Compares this QVariant with \a v and returns \c true if this is less than \a v.
3277
3278     \note Comparability might not be availabe for the type stored in this QVariant
3279     or in \a v.
3280
3281     \warning To make this function work with a custom type registered with
3282     qRegisterMetaType(), its comparison operator must be registered using
3283     QMetaType::registerComparators().
3284 */
3285
3286 /*!
3287     \fn bool QVariant::operator<=(const QVariant &v) const
3288
3289     Compares this QVariant with \a v and returns \c true if this is less or equal than \a v.
3290
3291     \note Comparability might not be available for the type stored in this QVariant
3292     or in \a v.
3293
3294     \warning To make this function work with a custom type registered with
3295     qRegisterMetaType(), its comparison operator must be registered using
3296     QMetaType::registerComparators().
3297 */
3298
3299 /*!
3300     \fn bool QVariant::operator>(const QVariant &v) const
3301
3302     Compares this QVariant with \a v and returns \c true if this is larger than \a v.
3303
3304     \note Comparability might not be available for the type stored in this QVariant
3305     or in \a v.
3306
3307     \warning To make this function work with a custom type registered with
3308     qRegisterMetaType(), its comparison operator must be registered using
3309     QMetaType::registerComparators().
3310 */
3311
3312 /*!
3313     \fn bool QVariant::operator>=(const QVariant &v) const
3314
3315     Compares this QVariant with \a v and returns \c true if this is larger or equal than \a v.
3316
3317     \note Comparability might not be available for the type stored in this QVariant
3318     or in \a v.
3319
3320     \warning To make this function work with a custom type registered with
3321     qRegisterMetaType(), its comparison operator must be registered using
3322     QMetaType::registerComparators().
3323 */
3324
3325 static bool qIsNumericType(uint tp)
3326 {
3327     static const qulonglong numericTypeBits =
3328             Q_UINT64_C(1) << QMetaType::Bool |
3329             Q_UINT64_C(1) << QMetaType::Double |
3330             Q_UINT64_C(1) << QMetaType::Float |
3331             Q_UINT64_C(1) << QMetaType::Char |
3332             Q_UINT64_C(1) << QMetaType::SChar |
3333             Q_UINT64_C(1) << QMetaType::UChar |
3334             Q_UINT64_C(1) << QMetaType::Short |
3335             Q_UINT64_C(1) << QMetaType::UShort |
3336             Q_UINT64_C(1) << QMetaType::Int |
3337             Q_UINT64_C(1) << QMetaType::UInt |
3338             Q_UINT64_C(1) << QMetaType::Long |
3339             Q_UINT64_C(1) << QMetaType::ULong |
3340             Q_UINT64_C(1) << QMetaType::LongLong |
3341             Q_UINT64_C(1) << QMetaType::ULongLong;
3342     return tp < (CHAR_BIT * sizeof numericTypeBits) ? numericTypeBits & (Q_UINT64_C(1) << tp) : false;
3343 }
3344
3345 static bool qIsFloatingPoint(uint tp)
3346 {
3347     return tp == QVariant::Double || tp == QMetaType::Float;
3348 }
3349
3350 static int normalizeLowerRanks(uint tp)
3351 {
3352     static const qulonglong numericTypeBits =
3353             Q_UINT64_C(1) << QMetaType::Bool |
3354             Q_UINT64_C(1) << QMetaType::Char |
3355             Q_UINT64_C(1) << QMetaType::SChar |
3356             Q_UINT64_C(1) << QMetaType::UChar |
3357             Q_UINT64_C(1) << QMetaType::Short |
3358             Q_UINT64_C(1) << QMetaType::UShort;
3359     return numericTypeBits & (Q_UINT64_C(1) << tp) ? QVariant::Int : tp;
3360 }
3361
3362 static int normalizeLong(uint tp)
3363 {
3364     const uint IntType = sizeof(long) == sizeof(int) ? QVariant::Int : QVariant::LongLong;
3365     const uint UIntType = sizeof(ulong) == sizeof(uint) ? QVariant::UInt : QVariant::ULongLong;
3366     return tp == QMetaType::Long ? IntType :
3367            tp == QMetaType::ULong ? UIntType : tp;
3368 }
3369
3370 static int numericTypePromotion(uint t1, uint t2)
3371 {
3372     Q_ASSERT(qIsNumericType(t1));
3373     Q_ASSERT(qIsNumericType(t2));
3374
3375     // C++ integral ranks: (4.13 Integer conversion rank [conv.rank])
3376     //   bool < signed char < short < int < long < long long
3377     //   unsigneds have the same rank as their signed counterparts
3378     // C++ integral promotion rules (4.5 Integral Promotions [conv.prom])
3379     // - any type with rank less than int can be converted to int or unsigned int
3380     // 5 Expressions [expr] paragraph 9:
3381     // - if either operand is double, the other shall be converted to double
3382     // -     "       "        float,   "          "         "         float
3383     // - if both operands have the same type, no further conversion is needed.
3384     // - if both are signed or if both are unsigned, convert to the one with highest rank
3385     // - if the unsigned has higher or same rank, convert the signed to the unsigned one
3386     // - if the signed can represent all values of the unsigned, convert to the signed
3387     // - otherwise, convert to the unsigned corresponding to the rank of the signed
3388
3389     // floating point: we deviate from the C++ standard by always using qreal
3390     if (qIsFloatingPoint(t1) || qIsFloatingPoint(t2))
3391         return QMetaType::QReal;
3392
3393     // integral rules:
3394     // for all platforms we support, int can always hold the values of lower-ranked types
3395     t1 = normalizeLowerRanks(t1);
3396     t2 = normalizeLowerRanks(t2);
3397
3398     // normalize long / ulong: in all platforms we run, they're either the same as int or as long long
3399     t1 = normalizeLong(t1);
3400     t2 = normalizeLong(t2);
3401
3402     // implement the other rules
3403     // the four possibilities are Int, UInt, LongLong and ULongLong
3404     // if any of the two is ULongLong, then it wins (highest rank, unsigned)
3405     // otherwise, if one of the two is LongLong, then the other is either LongLong too or lower-ranked
3406     // otherwise, if one of the two is UInt, then the other is either UInt too or Int
3407     if (t1 == QVariant::ULongLong || t2 == QVariant::ULongLong)
3408         return QVariant::ULongLong;
3409     if (t1 == QVariant::LongLong || t2 == QVariant::LongLong)
3410         return QVariant::LongLong;
3411     if (t1 == QVariant::UInt || t2 == QVariant::UInt)
3412         return QVariant::UInt;
3413     return QVariant::Int;
3414 }
3415
3416 static int integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2)
3417 {
3418     // use toLongLong to retrieve the data, it gets us all the bits
3419     bool ok;
3420     qlonglong l1 = qConvertToNumber(d1, &ok);
3421     Q_ASSERT(ok);
3422
3423     qlonglong l2 = qConvertToNumber(d2, &ok);
3424     Q_ASSERT(ok);
3425
3426     if (promotedType == QVariant::Int)
3427         return int(l1) < int(l2) ? -1 : int(l1) == int(l2) ? 0 : 1;
3428     if (promotedType == QVariant::UInt)
3429         return uint(l1) < uint(l2) ? -1 : uint(l1) == uint(l2) ? 0 : 1;
3430     if (promotedType == QVariant::LongLong)
3431         return l1 < l2 ? -1 : l1 == l2 ? 0 : 1;
3432     if (promotedType == QVariant::ULongLong)
3433         return qulonglong(l1) < qulonglong(l2) ? -1 : qulonglong(l1) == qulonglong(l2) ? 0 : 1;
3434
3435     Q_UNREACHABLE();
3436     return 0;
3437 }
3438
3439 static int numericCompare(const QVariant::Private *d1, const QVariant::Private *d2)
3440 {
3441     uint promotedType = numericTypePromotion(d1->type, d2->type);
3442     if (promotedType != QMetaType::QReal)
3443         return integralCompare(promotedType, d1, d2);
3444
3445     // qreal comparisons
3446     bool ok;
3447     qreal r1 = qConvertToRealNumber(d1, &ok);
3448     Q_ASSERT(ok);
3449     qreal r2 = qConvertToRealNumber(d2, &ok);
3450     Q_ASSERT(ok);
3451     if (qFuzzyCompare(r1, r2))
3452         return 0;
3453     return r1 < r2 ? -1 : 1;
3454 }
3455
3456 /*!
3457     \internal
3458  */
3459 bool QVariant::cmp(const QVariant &v) const
3460 {
3461     // try numerics first, with C++ type promotion rules (no conversion)
3462     if (qIsNumericType(d.type) && qIsNumericType(v.d.type))
3463         return numericCompare(&d, &v.d) == 0;
3464
3465     QVariant v1 = *this;
3466     QVariant v2 = v;
3467     if (d.type != v2.d.type) {
3468         if (v2.canConvert(v1.d.type)) {
3469             if (!v2.convert(v1.d.type))
3470                 return false;
3471         } else {
3472             // try the opposite conversion, it might work
3473             qSwap(v1, v2);
3474             if (!v2.convert(v1.d.type))
3475                 return false;
3476         }
3477     }
3478     if (v1.d.type >= QMetaType::User) {
3479         int result;
3480         if (QMetaType::equals(QT_PREPEND_NAMESPACE(constData(v1.d)), QT_PREPEND_NAMESPACE(constData(v2.d)), v1.d.type, &result))
3481             return result == 0;
3482     }
3483     return handlerManager[v1.d.type]->compare(&v1.d, &v2.d);
3484 }
3485
3486 /*!
3487     \internal
3488  */
3489 int QVariant::compare(const QVariant &v) const
3490 {
3491     // try numerics first, with C++ type promotion rules (no conversion)
3492     if (qIsNumericType(d.type) && qIsNumericType(v.d.type))
3493         return numericCompare(&d, &v.d);
3494
3495     // check for equality next, as more types implement operator== than operator<
3496     if (cmp(v))
3497         return 0;
3498
3499     QVariant v1 = *this;
3500     QVariant v2 = v;
3501
3502     if (v1.d.type != v2.d.type) {
3503         // if both types differ, try to convert
3504         if (v2.canConvert(v1.d.type)) {
3505             QVariant temp = v2;
3506             if (temp.convert(v1.d.type))
3507                 v2 = temp;
3508         }
3509         if (v1.d.type != v2.d.type && v1.canConvert(v2.d.type)) {
3510             QVariant temp = v1;
3511             if (temp.convert(v2.d.type))
3512                 v1 = temp;
3513         }
3514         if (v1.d.type != v2.d.type) {
3515             // if conversion fails, default to toString
3516             int r = v1.toString().compare(v2.toString(), Qt::CaseInsensitive);
3517             if (r == 0) {
3518                 // cmp(v) returned false, so we should try to agree with it.
3519                 return (v1.d.type < v2.d.type) ? -1 : 1;
3520             }
3521             return r;
3522         }
3523
3524         // did we end up with two numerics? If so, restart
3525         if (qIsNumericType(v1.d.type) && qIsNumericType(v2.d.type))
3526             return v1.compare(v2);
3527     }
3528     if (v1.d.type >= QMetaType::User) {
3529         int result;
3530         if (QMetaType::compare(QT_PREPEND_NAMESPACE(constData(d)), QT_PREPEND_NAMESPACE(constData(v2.d)), d.type, &result))
3531             return result;
3532     }
3533     switch (v1.d.type) {
3534     case QVariant::Date:
3535         return v1.toDate() < v2.toDate() ? -1 : 1;
3536     case QVariant::Time:
3537         return v1.toTime() < v2.toTime() ? -1 : 1;
3538     case QVariant::DateTime:
3539         return v1.toDateTime() < v2.toDateTime() ? -1 : 1;
3540     }
3541     int r = v1.toString().compare(v2.toString(), Qt::CaseInsensitive);
3542     if (r == 0) {
3543         // cmp(v) returned false, so we should try to agree with it.
3544         return (d.type < v.d.type) ? -1 : 1;
3545     }
3546     return r;
3547 }
3548
3549 /*!
3550     \internal
3551  */
3552
3553 const void *QVariant::constData() const
3554 {
3555     return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
3556 }
3557
3558 /*!
3559     \fn const void* QVariant::data() const
3560
3561     \internal
3562 */
3563
3564 /*!
3565     \internal
3566 */
3567 void* QVariant::data()
3568 {
3569     detach();
3570     return const_cast<void *>(constData());
3571 }
3572
3573
3574 /*!
3575     Returns \c true if this is a null variant, false otherwise. A variant is
3576     considered null if it contains a default constructed value or a built-in
3577     type instance that has an isNull method, in which case the result
3578     would be the same as calling isNull on the wrapped object.
3579
3580     \warning The result of the function doesn't affect == operator, which means
3581     that two values can be equal even if one of them is null and another is not.
3582 */
3583 bool QVariant::isNull() const
3584 {
3585     return handlerManager[d.type]->isNull(&d);
3586 }
3587
3588 #ifndef QT_NO_DEBUG_STREAM
3589 QDebug operator<<(QDebug dbg, const QVariant &v)
3590 {
3591     QDebugStateSaver saver(dbg);
3592     const uint typeId = v.d.type;
3593     dbg.nospace() << "QVariant(";
3594     if (typeId != QMetaType::UnknownType) {
3595         dbg << QMetaType::typeName(typeId) << ", ";
3596         bool userStream = false;
3597         bool canConvertToString = false;
3598         if (typeId >= QMetaType::User) {
3599             userStream = QMetaType::debugStream(dbg, constData(v.d), typeId);
3600             canConvertToString = v.canConvert<QString>();
3601         }
3602         if (!userStream && canConvertToString)
3603             dbg << v.toString();
3604         else if (!userStream)
3605             handlerManager[typeId]->debugStream(dbg, v);
3606     } else {
3607         dbg << "Invalid";
3608     }
3609     dbg << ')';
3610     return dbg;
3611 }
3612
3613 QDebug operator<<(QDebug dbg, const QVariant::Type p)
3614 {
3615     QDebugStateSaver saver(dbg);
3616     dbg.nospace() << "QVariant::"
3617                   << (int(p) != int(QMetaType::UnknownType)
3618                      ? QMetaType::typeName(p)
3619                      : "Invalid");
3620     return dbg;
3621 }
3622 #endif
3623
3624
3625 /*! \fn void QVariant::setValue(const T &value)
3626
3627     Stores a copy of \a value. If \c{T} is a type that QVariant
3628     doesn't support, QMetaType is used to store the value. A compile
3629     error will occur if QMetaType doesn't handle the type.
3630
3631     Example:
3632
3633     \snippet code/src_corelib_kernel_qvariant.cpp 4
3634
3635     \sa value(), fromValue(), canConvert()
3636  */
3637
3638 /*! \fn T QVariant::value() const
3639
3640     Returns the stored value converted to the template type \c{T}.
3641     Call canConvert() to find out whether a type can be converted.
3642     If the value cannot be converted, a \l{default-constructed value}
3643     will be returned.
3644
3645     If the type \c{T} is supported by QVariant, this function behaves
3646     exactly as toString(), toInt() etc.
3647
3648     Example:
3649
3650     \snippet code/src_corelib_kernel_qvariant.cpp 5
3651
3652     If the QVariant contains a pointer to a type derived from QObject then
3653     \c{T} may be any QObject type. If the pointer stored in the QVariant can be
3654     qobject_cast to T, then that result is returned. Otherwise a null pointer is
3655     returned. Note that this only works for QObject subclasses which use the
3656     Q_OBJECT macro.
3657
3658     If the QVariant contains a sequential container and \c{T} is QVariantList, the
3659     elements of the container will be converted into \l {QVariant}s and returned as a QVariantList.
3660
3661     \snippet code/src_corelib_kernel_qvariant.cpp 9
3662
3663     \sa setValue(), fromValue(), canConvert(), Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE()
3664 */
3665
3666 /*! \fn bool QVariant::canConvert() const
3667
3668     Returns \c true if the variant can be converted to the template type \c{T},
3669     otherwise false.
3670
3671     Example:
3672
3673     \snippet code/src_corelib_kernel_qvariant.cpp 6
3674
3675     A QVariant containing a pointer to a type derived from QObject will also return true for this
3676     function if a qobject_cast to the template type \c{T} would succeed. Note that this only works
3677     for QObject subclasses which use the Q_OBJECT macro.
3678
3679     \sa convert()
3680 */
3681
3682 /*! \fn static QVariant QVariant::fromValue(const T &value)
3683
3684     Returns a QVariant containing a copy of \a value. Behaves
3685     exactly like setValue() otherwise.
3686
3687     Example:
3688
3689     \snippet code/src_corelib_kernel_qvariant.cpp 7
3690
3691     \note If you are working with custom types, you should use
3692     the Q_DECLARE_METATYPE() macro to register your custom type.
3693
3694     \sa setValue(), value()
3695 */
3696
3697 /*!
3698     \fn QVariant qVariantFromValue(const T &value)
3699     \relates QVariant
3700     \obsolete
3701
3702     Returns a variant containing a copy of the given \a value
3703     with template type \c{T}.
3704
3705     This function is equivalent to QVariant::fromValue(\a value).
3706
3707     \note This function was provided as a workaround for MSVC 6
3708     which did not support member template functions. It is advised
3709     to use the other form in new code.
3710
3711     For example, a QObject pointer can be stored in a variant with the
3712     following code:
3713
3714     \snippet code/src_corelib_kernel_qvariant.cpp 8
3715
3716     \sa QVariant::fromValue()
3717 */
3718
3719 /*! \fn void qVariantSetValue(QVariant &variant, const T &value)
3720     \relates QVariant
3721     \obsolete
3722
3723     Sets the contents of the given \a variant to a copy of the
3724     \a value with the specified template type \c{T}.
3725
3726     This function is equivalent to QVariant::setValue(\a value).
3727
3728     \note This function was provided as a workaround for MSVC 6
3729     which did not support member template functions. It is advised
3730     to use the other form in new code.
3731
3732     \sa QVariant::setValue()
3733 */
3734
3735 /*!
3736     \fn T qvariant_cast(const QVariant &value)
3737     \relates QVariant
3738
3739     Returns the given \a value converted to the template type \c{T}.
3740
3741     This function is equivalent to QVariant::value().
3742
3743     \sa QVariant::value()
3744 */
3745
3746 /*! \fn T qVariantValue(const QVariant &value)
3747     \relates QVariant
3748     \obsolete
3749
3750     Returns the given \a value converted to the template type \c{T}.
3751
3752     This function is equivalent to
3753     \l{QVariant::value()}{QVariant::value}<T>(\a value).
3754
3755     \note This function was provided as a workaround for MSVC 6
3756     which did not support member template functions. It is advised
3757     to use the other form in new code.
3758
3759     \sa QVariant::value(), qvariant_cast()
3760 */
3761
3762 /*! \fn bool qVariantCanConvert(const QVariant &value)
3763     \relates QVariant
3764     \obsolete
3765
3766     Returns \c true if the given \a value can be converted to the
3767     template type specified; otherwise returns \c false.
3768
3769     This function is equivalent to QVariant::canConvert(\a value).
3770
3771     \note This function was provided as a workaround for MSVC 6
3772     which did not support member template functions. It is advised
3773     to use the other form in new code.
3774
3775     \sa QVariant::canConvert()
3776 */
3777
3778 /*!
3779     \typedef QVariantList
3780     \relates QVariant
3781
3782     Synonym for QList<QVariant>.
3783 */
3784
3785 /*!
3786     \typedef QVariantMap
3787     \relates QVariant
3788
3789     Synonym for QMap<QString, QVariant>.
3790 */
3791
3792 /*!
3793     \typedef QVariantHash
3794     \relates QVariant
3795     \since 4.5
3796
3797     Synonym for QHash<QString, QVariant>.
3798 */
3799
3800 /*!
3801     \typedef QVariant::DataPtr
3802     \internal
3803 */
3804
3805 /*!
3806     \fn DataPtr &QVariant::data_ptr()
3807     \internal
3808 */
3809
3810 /*!
3811     \fn const DataPtr &QVariant::data_ptr() const
3812     \internal
3813 */
3814
3815 /*!
3816     \class QSequentialIterable
3817     \since 5.2
3818     \inmodule QtCore
3819     \brief The QSequentialIterable class is an iterable interface for a container in a QVariant.
3820
3821     This class allows several methods of accessing the elements of a container held within
3822     a QVariant. An instance of QSequentialIterable can be extracted from a QVariant if it can
3823     be converted to a QVariantList.
3824
3825     \snippet code/src_corelib_kernel_qvariant.cpp 9
3826
3827     The container itself is not copied before iterating over it.
3828
3829     \sa QVariant
3830 */
3831
3832 /*!
3833     \internal
3834 */
3835 QSequentialIterable::QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl impl)
3836   : m_impl(impl)
3837 {
3838 }
3839
3840 QSequentialIterable::const_iterator::const_iterator(const QSequentialIterable &iter, QAtomicInt *ref_)
3841   : m_impl(iter.m_impl), ref(ref_)
3842 {
3843     ref->ref();
3844 }
3845
3846 QSequentialIterable::const_iterator::const_iterator(const QtMetaTypePrivate::QSequentialIterableImpl &impl, QAtomicInt *ref_)
3847   : m_impl(impl), ref(ref_)
3848 {
3849     ref->ref();
3850 }
3851
3852 void QSequentialIterable::const_iterator::begin()
3853 {
3854     m_impl.moveToBegin();
3855 }
3856
3857 void QSequentialIterable::const_iterator::end()
3858 {
3859     m_impl.moveToEnd();
3860 }
3861
3862 /*! \fn QSequentialIterable::const_iterator QSequentialIterable::begin() const
3863
3864     Returns a QSequentialIterable::const_iterator for the beginning of the container. This
3865     can be used in stl-style iteration.
3866
3867     \sa end()
3868 */
3869 QSequentialIterable::const_iterator QSequentialIterable::begin() const
3870 {
3871     const_iterator it(*this, new QAtomicInt(0));
3872     it.begin();
3873     return it;
3874 }
3875
3876 /*!
3877     Returns a QSequentialIterable::const_iterator for the end of the container. This
3878     can be used in stl-style iteration.
3879
3880     \sa begin()
3881 */
3882 QSequentialIterable::const_iterator QSequentialIterable::end() const
3883 {
3884     const_iterator it(*this, new QAtomicInt(0));
3885     it.end();
3886     return it;
3887 }
3888
3889 /*!
3890     Returns the element at position \a idx in the container.
3891 */
3892 QVariant QSequentialIterable::at(int idx) const
3893 {
3894     const QtMetaTypePrivate::VariantData d = m_impl.at(idx);
3895     if (d.metaTypeId == qMetaTypeId<QVariant>())
3896         return *reinterpret_cast<const QVariant*>(d.data);
3897     return QVariant(d.metaTypeId, d.data, d.flags);
3898 }
3899
3900 /*!
3901     Returns the number of elements in the container.
3902 */
3903 int QSequentialIterable::size() const
3904 {
3905     return m_impl.size();
3906 }
3907
3908 /*!
3909     Returns whether it is possible to iterate over the container in reverse. This
3910     corresponds to the std::bidirectional_iterator_tag iterator trait of the
3911     const_iterator of the container.
3912 */
3913 bool QSequentialIterable::canReverseIterate() const
3914 {
3915     return m_impl._iteratorCapabilities & QtMetaTypePrivate::BiDirectionalCapability;
3916 }
3917
3918 /*!
3919     \class QSequentialIterable::const_iterator
3920     \since 5.2
3921     \inmodule QtCore
3922     \brief The QSequentialIterable::const_iterator allows iteration over a container in a QVariant.
3923
3924     A QSequentialIterable::const_iterator can only be created by a QSequentialIterable instance,
3925     and can be used in a way similar to other stl-style iterators.
3926
3927     \snippet code/src_corelib_kernel_qvariant.cpp 9
3928
3929     \sa QSequentialIterable
3930 */
3931
3932
3933 /*!
3934     Destroys the QSequentialIterable::const_iterator.
3935 */
3936 QSequentialIterable::const_iterator::~const_iterator() {
3937     if (!ref->deref()) {
3938         m_impl.destroyIter();
3939         delete ref;
3940     }
3941 }
3942
3943 /*!
3944     Creates a copy of \a other.
3945 */
3946 QSequentialIterable::const_iterator::const_iterator(const const_iterator &other)
3947   : m_impl(other.m_impl), ref(other.ref)
3948 {
3949     ref->ref();
3950 }
3951
3952 /*!
3953     Assigns \a other to this.
3954 */
3955 QSequentialIterable::const_iterator&
3956 QSequentialIterable::const_iterator::operator=(const const_iterator &other)
3957 {
3958     other.ref->ref();
3959     if (!ref->deref()) {
3960         m_impl.destroyIter();
3961         delete ref;
3962     }
3963     m_impl = other.m_impl;
3964     ref = other.ref;
3965     return *this;
3966 }
3967
3968 /*!
3969     Returns the current item, converted to a QVariant.
3970 */
3971 const QVariant QSequentialIterable::const_iterator::operator*() const
3972 {
3973     const QtMetaTypePrivate::VariantData d = m_impl.getCurrent();
3974     if (d.metaTypeId == qMetaTypeId<QVariant>())
3975         return *reinterpret_cast<const QVariant*>(d.data);
3976     return QVariant(d.metaTypeId, d.data, d.flags);
3977 }
3978
3979 /*!
3980     Returns \c true if \a other points to the same item as this
3981     iterator; otherwise returns \c false.
3982
3983     \sa operator!=()
3984 */
3985 bool QSequentialIterable::const_iterator::operator==(const const_iterator &other) const
3986 {
3987     return m_impl.equal(other.m_impl);
3988 }
3989
3990 /*!
3991     Returns \c true if \a other points to a different item than this
3992     iterator; otherwise returns \c false.
3993
3994     \sa operator==()
3995 */
3996 bool QSequentialIterable::const_iterator::operator!=(const const_iterator &other) const
3997 {
3998     return !m_impl.equal(other.m_impl);
3999 }
4000
4001 /*!
4002     The prefix ++ operator (\c{++it}) advances the iterator to the
4003     next item in the container and returns an iterator to the new current
4004     item.
4005
4006     Calling this function on QSequentialIterable::end() leads to undefined results.
4007
4008     \sa operator--()
4009 */
4010 QSequentialIterable::const_iterator &QSequentialIterable::const_iterator::operator++()
4011 {
4012     m_impl.advance(1);
4013     return *this;
4014 }
4015
4016 /*!
4017     \overload
4018
4019     The postfix ++ operator (\c{it++}) advances the iterator to the
4020     next item in the container and returns an iterator to the previously
4021     current item.
4022 */
4023 QSequentialIterable::const_iterator QSequentialIterable::const_iterator::operator++(int)
4024 {
4025     QtMetaTypePrivate::QSequentialIterableImpl impl;
4026     impl.copy(m_impl);
4027     m_impl.advance(1);
4028     return const_iterator(impl, new QAtomicInt(0));
4029 }
4030
4031 /*!
4032     The prefix -- operator (\c{--it}) makes the preceding item
4033     current and returns an iterator to the new current item.
4034
4035     Calling this function on QSequentialIterable::begin() leads to undefined results.
4036
4037     If the container in the QVariant does not support bi-directional iteration, calling this function
4038     leads to undefined results.
4039
4040     \sa operator++(), canReverseIterate()
4041 */
4042 QSequentialIterable::const_iterator &QSequentialIterable::const_iterator::operator--()
4043 {
4044     m_impl.advance(-1);
4045     return *this;
4046 }
4047
4048 /*!
4049     \overload