1 /****************************************************************************
3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/
6 ** This file is part of the QtCore module of the Qt Toolkit.
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** GNU Lesser General Public License Usage
10 ** This file may be used under the terms of the GNU Lesser General Public
11 ** License version 2.1 as published by the Free Software Foundation and
12 ** appearing in the file LICENSE.LGPL included in the packaging of this
13 ** file. Please review the following information to ensure the GNU Lesser
14 ** General Public License version 2.1 requirements will be met:
15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 ** In addition, as a special exception, Nokia gives you certain additional
18 ** rights. These rights are described in the Nokia Qt LGPL Exception
19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 ** GNU General Public License Usage
22 ** Alternatively, this file may be used under the terms of the GNU General
23 ** Public License version 3.0 as published by the Free Software Foundation
24 ** and appearing in the file LICENSE.GPL included in the packaging of this
25 ** file. Please review the following information to ensure the GNU General
26 ** Public License version 3.0 requirements will be met:
27 ** http://www.gnu.org/copyleft/gpl.html.
30 ** Alternatively, this file may be used in accordance with the terms and
31 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
43 #include "qbitarray.h"
44 #include "qbytearray.h"
45 #include "qdatastream.h"
48 #include "qdatetime.h"
49 #include "qeasingcurve.h"
52 #include "qstringlist.h"
56 #ifndef QT_BOOTSTRAPPED
57 #include "qabstractitemmodel.h"
59 #include "private/qvariant_p.h"
60 #include "qmetatype_p.h"
62 #ifndef QT_NO_GEOM_VARIANT
83 static const QVariant::Handler *Handlers[QModulesPrivate::ModulesCount];
85 const QVariant::Handler *operator[] (const int typeId) const
87 return Handlers[QModulesPrivate::moduleForType(typeId)];
90 void registerHandler(const QModulesPrivate::Names name, const QVariant::Handler *handler)
92 Handlers[name] = handler;
95 inline void unregisterHandler(const QModulesPrivate::Names name);
101 struct TypeDefinition {
102 static const bool IsAvailable = true;
105 // Ignore these types, as incomplete
106 #ifdef QT_BOOTSTRAPPED
107 template<> struct TypeDefinition<QEasingCurve> { static const bool IsAvailable = false; };
108 template<> struct TypeDefinition<QModelIndex> { static const bool IsAvailable = false; };
110 #ifdef QT_NO_GEOM_VARIANT
111 template<> struct TypeDefinition<QRect> { static const bool IsAvailable = false; };
112 template<> struct TypeDefinition<QRectF> { static const bool IsAvailable = false; };
113 template<> struct TypeDefinition<QSize> { static const bool IsAvailable = false; };
114 template<> struct TypeDefinition<QSizeF> { static const bool IsAvailable = false; };
115 template<> struct TypeDefinition<QLine> { static const bool IsAvailable = false; };
116 template<> struct TypeDefinition<QLineF> { static const bool IsAvailable = false; };
117 template<> struct TypeDefinition<QPoint> { static const bool IsAvailable = false; };
118 template<> struct TypeDefinition<QPointF> { static const bool IsAvailable = false; };
121 struct CoreTypesFilter {
124 static const bool IsAccepted = QTypeModuleInfo<T>::IsCore && TypeDefinition<T>::IsAvailable;
127 } // annonymous used to hide TypeDefinition
129 namespace { // annonymous used to hide QVariant handlers
131 static void construct(QVariant::Private *x, const void *copy)
133 QVariantConstructor<CoreTypesFilter> constructor(x, copy);
134 QMetaTypeSwitcher::switcher<void>(constructor, x->type, 0);
137 static void clear(QVariant::Private *d)
139 QVariantDestructor<CoreTypesFilter> cleaner(d);
140 QMetaTypeSwitcher::switcher<void>(cleaner, d->type, 0);
143 static bool isNull(const QVariant::Private *d)
145 QVariantIsNull<CoreTypesFilter> isNull(d);
146 return QMetaTypeSwitcher::switcher<bool>(isNull, d->type, 0);
152 Compares \a a to \a b. The caller guarantees that \a a and \a b
153 are of the same type.
155 static bool compare(const QVariant::Private *a, const QVariant::Private *b)
157 QVariantComparator<CoreTypesFilter> comparator(a, b);
158 return QMetaTypeSwitcher::switcher<bool>(comparator, a->type, 0);
164 static qlonglong qMetaTypeNumber(const QVariant::Private *d)
169 case QMetaType::LongLong:
171 case QMetaType::Char:
172 return qlonglong(d->data.c);
173 case QMetaType::Short:
174 return qlonglong(d->data.s);
175 case QMetaType::Long:
176 return qlonglong(d->data.l);
177 case QMetaType::Float:
178 return qRound64(d->data.f);
179 case QVariant::Double:
180 return qRound64(d->data.d);
186 static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
191 case QVariant::ULongLong:
193 case QMetaType::UChar:
195 case QMetaType::UShort:
197 case QMetaType::ULong:
204 static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)
208 switch (uint(d->type)) {
209 case QVariant::String:
210 return v_cast<QString>(d)->toLongLong(ok);
212 return v_cast<QChar>(d)->unicode();
213 case QVariant::ByteArray:
214 return v_cast<QByteArray>(d)->toLongLong(ok);
216 return qlonglong(d->data.b);
217 case QVariant::Double:
219 case QMetaType::Char:
220 case QMetaType::Short:
221 case QMetaType::Long:
222 case QMetaType::Float:
223 case QMetaType::LongLong:
224 return qMetaTypeNumber(d);
225 case QVariant::ULongLong:
227 case QMetaType::UChar:
228 case QMetaType::UShort:
229 case QMetaType::ULong:
230 return qlonglong(qMetaTypeUNumber(d));
237 static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)
241 switch (uint(d->type)) {
242 case QVariant::String:
243 return v_cast<QString>(d)->toULongLong(ok);
245 return v_cast<QChar>(d)->unicode();
246 case QVariant::ByteArray:
247 return v_cast<QByteArray>(d)->toULongLong(ok);
249 return qulonglong(d->data.b);
250 case QVariant::Double:
252 case QMetaType::Char:
253 case QMetaType::Short:
254 case QMetaType::Long:
255 case QMetaType::Float:
256 case QMetaType::LongLong:
257 return qulonglong(qMetaTypeNumber(d));
258 case QVariant::ULongLong:
260 case QMetaType::UChar:
261 case QMetaType::UShort:
262 case QMetaType::ULong:
263 return qMetaTypeUNumber(d);
267 return Q_UINT64_C(0);
270 template<typename TInput, typename LiteralWrapper>
271 inline bool qt_convertToBool(const QVariant::Private *const d)
273 TInput str = v_cast<TInput>(d)->toLower();
274 return !(str == LiteralWrapper("0") || str == LiteralWrapper("false") || str.isEmpty());
280 Converts \a d to type \a t, which is placed in \a result.
282 static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
284 Q_ASSERT(d->type != uint(t));
294 case QVariant::String:
295 *static_cast<QUrl *>(result) = QUrl(*v_cast<QString>(d));
301 case QVariant::String: {
302 QString *str = static_cast<QString *>(result);
305 *str = QString(*v_cast<QChar>(d));
307 case QMetaType::Char:
308 case QMetaType::UChar:
309 *str = QChar::fromAscii(d->data.c);
311 case QMetaType::Short:
312 case QMetaType::Long:
314 case QVariant::LongLong:
315 *str = QString::number(qMetaTypeNumber(d));
318 case QVariant::ULongLong:
319 case QMetaType::UShort:
320 case QMetaType::ULong:
321 *str = QString::number(qMetaTypeUNumber(d));
323 case QMetaType::Float:
324 *str = QString::number(d->data.f, 'g', FLT_DIG);
326 case QVariant::Double:
327 *str = QString::number(d->data.d, 'g', DBL_DIG);
329 #if !defined(QT_NO_DATESTRING)
331 *str = v_cast<QDate>(d)->toString(Qt::ISODate);
334 *str = v_cast<QTime>(d)->toString(Qt::ISODate);
336 case QVariant::DateTime:
337 *str = v_cast<QDateTime>(d)->toString(Qt::ISODate);
341 *str = QLatin1String(d->data.b ? "true" : "false");
343 case QVariant::ByteArray:
344 *str = QString::fromAscii(v_cast<QByteArray>(d)->constData());
346 case QVariant::StringList:
347 if (v_cast<QStringList>(d)->count() == 1)
348 *str = v_cast<QStringList>(d)->at(0);
351 *str = v_cast<QUrl>(d)->toString();
354 *str = v_cast<QUuid>(d)->toString();
361 case QVariant::Char: {
362 QChar *c = static_cast<QChar *>(result);
365 case QVariant::LongLong:
366 case QMetaType::Char:
367 case QMetaType::Short:
368 case QMetaType::Long:
369 case QMetaType::Float:
370 *c = QChar(ushort(qMetaTypeNumber(d)));
373 case QVariant::ULongLong:
374 case QMetaType::UChar:
375 case QMetaType::UShort:
376 case QMetaType::ULong:
377 *c = QChar(ushort(qMetaTypeUNumber(d)));
384 #ifndef QT_NO_GEOM_VARIANT
385 case QVariant::Size: {
386 QSize *s = static_cast<QSize *>(result);
388 case QVariant::SizeF:
389 *s = v_cast<QSizeF>(d)->toSize();
397 case QVariant::SizeF: {
398 QSizeF *s = static_cast<QSizeF *>(result);
401 *s = QSizeF(*(v_cast<QSize>(d)));
409 case QVariant::Line: {
410 QLine *s = static_cast<QLine *>(result);
412 case QVariant::LineF:
413 *s = v_cast<QLineF>(d)->toLine();
421 case QVariant::LineF: {
422 QLineF *s = static_cast<QLineF *>(result);
425 *s = QLineF(*(v_cast<QLine>(d)));
433 case QVariant::StringList:
434 if (d->type == QVariant::List) {
435 QStringList *slst = static_cast<QStringList *>(result);
436 const QVariantList *list = v_cast<QVariantList >(d);
437 for (int i = 0; i < list->size(); ++i)
438 slst->append(list->at(i).toString());
439 } else if (d->type == QVariant::String) {
440 QStringList *slst = static_cast<QStringList *>(result);
441 *slst = QStringList(*v_cast<QString>(d));
446 case QVariant::Date: {
447 QDate *dt = static_cast<QDate *>(result);
448 if (d->type == QVariant::DateTime)
449 *dt = v_cast<QDateTime>(d)->date();
450 #ifndef QT_NO_DATESTRING
451 else if (d->type == QVariant::String)
452 *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);
457 return dt->isValid();
459 case QVariant::Time: {
460 QTime *t = static_cast<QTime *>(result);
462 case QVariant::DateTime:
463 *t = v_cast<QDateTime>(d)->time();
465 #ifndef QT_NO_DATESTRING
466 case QVariant::String:
467 *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);
475 case QVariant::DateTime: {
476 QDateTime *dt = static_cast<QDateTime *>(result);
478 #ifndef QT_NO_DATESTRING
479 case QVariant::String:
480 *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);
484 *dt = QDateTime(*v_cast<QDate>(d));
489 return dt->isValid();
491 case QVariant::ByteArray: {
492 QByteArray *ba = static_cast<QByteArray *>(result);
494 case QVariant::String:
495 *ba = v_cast<QString>(d)->toAscii();
497 case QVariant::Double:
498 *ba = QByteArray::number(d->data.d, 'g', DBL_DIG);
500 case QMetaType::Float:
501 *ba = QByteArray::number(d->data.f, 'g', FLT_DIG);
503 case QMetaType::Char:
504 case QMetaType::UChar:
505 *ba = QByteArray(1, d->data.c);
508 case QVariant::LongLong:
509 case QMetaType::Short:
510 case QMetaType::Long:
511 *ba = QByteArray::number(qMetaTypeNumber(d));
514 case QVariant::ULongLong:
515 case QMetaType::UShort:
516 case QMetaType::ULong:
517 *ba = QByteArray::number(qMetaTypeUNumber(d));
520 *ba = QByteArray(d->data.b ? "true" : "false");
527 case QMetaType::Short:
528 *static_cast<short *>(result) = short(qConvertToNumber(d, ok));
530 case QMetaType::Long:
531 *static_cast<long *>(result) = long(qConvertToNumber(d, ok));
533 case QMetaType::UShort:
534 *static_cast<ushort *>(result) = ushort(qConvertToUnsignedNumber(d, ok));
536 case QMetaType::ULong:
537 *static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok));
540 *static_cast<int *>(result) = int(qConvertToNumber(d, ok));
543 *static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok));
545 case QVariant::LongLong:
546 *static_cast<qlonglong *>(result) = qConvertToNumber(d, ok);
548 case QVariant::ULongLong: {
549 *static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok);
552 case QMetaType::UChar: {
553 *static_cast<uchar *>(result) = qConvertToUnsignedNumber(d, ok);
556 case QVariant::Bool: {
557 bool *b = static_cast<bool *>(result);
559 case QVariant::ByteArray:
560 *b = qt_convertToBool<QByteArray, QByteArray>(d);
562 case QVariant::String:
563 *b = qt_convertToBool<QString, QLatin1String>(d);
566 *b = !v_cast<QChar>(d)->isNull();
568 case QVariant::Double:
570 case QVariant::LongLong:
571 case QMetaType::Char:
572 case QMetaType::Short:
573 case QMetaType::Long:
574 case QMetaType::Float:
575 *b = qMetaTypeNumber(d) != Q_INT64_C(0);
578 case QVariant::ULongLong:
579 case QMetaType::UChar:
580 case QMetaType::UShort:
581 case QMetaType::ULong:
582 *b = qMetaTypeUNumber(d) != Q_UINT64_C(0);
590 case QVariant::Double: {
591 double *f = static_cast<double *>(result);
593 case QVariant::String:
594 *f = v_cast<QString>(d)->toDouble(ok);
596 case QVariant::ByteArray:
597 *f = v_cast<QByteArray>(d)->toDouble(ok);
600 *f = double(d->data.b);
602 case QMetaType::Float:
603 *f = double(d->data.f);
605 case QVariant::LongLong:
607 case QMetaType::Char:
608 case QMetaType::Short:
609 case QMetaType::Long:
610 *f = double(qMetaTypeNumber(d));
613 case QVariant::ULongLong:
614 case QMetaType::UChar:
615 case QMetaType::UShort:
616 case QMetaType::ULong:
617 *f = double(qMetaTypeUNumber(d));
625 case QMetaType::Float: {
626 float *f = static_cast<float *>(result);
628 case QVariant::String:
629 *f = v_cast<QString>(d)->toFloat(ok);
631 case QVariant::ByteArray:
632 *f = v_cast<QByteArray>(d)->toFloat(ok);
635 *f = float(d->data.b);
637 case QVariant::Double:
638 *f = float(d->data.d);
640 case QVariant::LongLong:
642 case QMetaType::Char:
643 case QMetaType::Short:
644 case QMetaType::Long:
645 *f = float(qMetaTypeNumber(d));
648 case QVariant::ULongLong:
649 case QMetaType::UChar:
650 case QMetaType::UShort:
651 case QMetaType::ULong:
652 *f = float(qMetaTypeUNumber(d));
661 if (d->type == QVariant::StringList) {
662 QVariantList *lst = static_cast<QVariantList *>(result);
663 const QStringList *slist = v_cast<QStringList>(d);
664 for (int i = 0; i < slist->size(); ++i)
665 lst->append(QVariant(slist->at(i)));
666 } else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {
667 *static_cast<QVariantList *>(result) =
668 *static_cast<QList<QVariant> *>(d->data.shared->ptr);
674 if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
675 *static_cast<QVariantMap *>(result) =
676 *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);
682 if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) {
683 *static_cast<QVariantHash *>(result) =
684 *static_cast<QHash<QString, QVariant> *>(d->data.shared->ptr);
689 #ifndef QT_NO_GEOM_VARIANT
691 if (d->type == QVariant::RectF)
692 *static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect();
696 case QVariant::RectF:
697 if (d->type == QVariant::Rect)
698 *static_cast<QRectF *>(result) = *v_cast<QRect>(d);
702 case QVariant::PointF:
703 if (d->type == QVariant::Point)
704 *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);
708 case QVariant::Point:
709 if (d->type == QVariant::PointF)
710 *static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint();
714 case QMetaType::Char:
716 *static_cast<qint8 *>(result) = qint8(qConvertToNumber(d, ok));
722 case QVariant::String:
723 *static_cast<QUuid *>(result) = QUuid(*v_cast<QString>(d));
735 #if !defined(QT_NO_DEBUG_STREAM)
736 static void streamDebug(QDebug dbg, const QVariant &v)
738 QVariant::Private *d = const_cast<QVariant::Private *>(&v.data_ptr());
739 QVariantDebugStream<CoreTypesFilter> stream(dbg, d);
740 QMetaTypeSwitcher::switcher<void>(stream, d->type, 0);
744 const QVariant::Handler qt_kernel_variant_handler = {
748 #ifndef QT_NO_DATASTREAM
755 #if !defined(QT_NO_DEBUG_STREAM)
762 static void dummyConstruct(QVariant::Private *, const void *) { Q_ASSERT_X(false, "QVariant", "Trying to construct an unknown type"); }
763 static void dummyClear(QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to clear an unknown type"); }
764 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; }
765 static bool dummyCompare(const QVariant::Private *, const QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to compare an unknown types"); return false; }
766 static bool dummyConvert(const QVariant::Private *, int, void *, bool *) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); return false; }
767 #if !defined(QT_NO_DEBUG_STREAM)
768 static void dummyStreamDebug(QDebug, const QVariant &) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); }
770 const QVariant::Handler qt_dummy_variant_handler = {
774 #ifndef QT_NO_DATASTREAM
781 #if !defined(QT_NO_DEBUG_STREAM)
788 static void customConstruct(QVariant::Private *d, const void *copy)
790 const QMetaType type(d->type);
791 const uint size = type.sizeOf();
793 d->type = QVariant::Invalid;
797 // this logic should match with QVariantIntegrator::CanUseInternalSpace
798 if (size <= sizeof(QVariant::Private::Data)
799 && (type.flags() & QMetaType::MovableType)) {
800 type.construct(&d->data.ptr, copy);
801 d->is_shared = false;
803 void *ptr = type.create(copy);
805 d->data.shared = new QVariant::PrivateShared(ptr);
809 static void customClear(QVariant::Private *d)
812 QMetaType::destruct(d->type, &d->data.ptr);
814 QMetaType::destroy(d->type, d->data.shared->ptr);
815 delete d->data.shared;
819 static bool customIsNull(const QVariant::Private *d)
824 static bool customCompare(const QVariant::Private *a, const QVariant::Private *b)
826 const char *const typeName = QMetaType::typeName(a->type);
827 if (Q_UNLIKELY(!typeName) && Q_LIKELY(!QMetaType::isRegistered(a->type)))
828 qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);
830 const void *a_ptr = a->is_shared ? a->data.shared->ptr : &(a->data.ptr);
831 const void *b_ptr = b->is_shared ? b->data.shared->ptr : &(b->data.ptr);
833 uint typeNameLen = qstrlen(typeName);
834 if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*')
835 return *static_cast<void *const *>(a_ptr) == *static_cast<void *const *>(b_ptr);
837 if (a->is_null && b->is_null)
840 return !memcmp(a_ptr, b_ptr, QMetaType::sizeOf(a->type));
843 static bool customConvert(const QVariant::Private *, int, void *, bool *ok)
850 #if !defined(QT_NO_DEBUG_STREAM)
851 static void customStreamDebug(QDebug, const QVariant &) {}
854 const QVariant::Handler qt_custom_variant_handler = {
858 #ifndef QT_NO_DATASTREAM
865 #if !defined(QT_NO_DEBUG_STREAM)
872 } // annonymous used to hide QVariant handlers
874 static HandlersManager handlerManager;
875 Q_STATIC_ASSERT_X(!QModulesPrivate::Core, "Initialization assumes that ModulesNames::Core is 0");
876 const QVariant::Handler *HandlersManager::Handlers[QModulesPrivate::ModulesCount]
877 = { &qt_kernel_variant_handler, &qt_dummy_variant_handler,
878 &qt_dummy_variant_handler, &qt_custom_variant_handler };
880 Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler()
882 return &qt_kernel_variant_handler;
885 inline void HandlersManager::unregisterHandler(const QModulesPrivate::Names name)
887 Handlers[name] = &qt_dummy_variant_handler;
890 Q_CORE_EXPORT void QVariantPrivate::registerHandler(const int /* Modules::Names */name, const QVariant::Handler *handler)
892 handlerManager.registerHandler(static_cast<QModulesPrivate::Names>(name), handler);
895 Q_CORE_EXPORT void QVariantPrivate::unregisterHandler(const int /* Modules::Names */ name)
897 handlerManager.unregisterHandler(static_cast<QModulesPrivate::Names>(name));
902 \brief The QVariant class acts like a union for the most common Qt data types.
908 Because C++ forbids unions from including types that have
909 non-default constructors or destructors, most interesting Qt
910 classes cannot be used in unions. Without QVariant, this would be
911 a problem for QObject::property() and for database work, etc.
913 A QVariant object holds a single value of a single type() at a
914 time. (Some type()s are multi-valued, for example a string list.)
915 You can find out what type, T, the variant holds, convert it to a
916 different type using convert(), get its value using one of the
917 toT() functions (e.g., toSize()) and check whether the type can
918 be converted to a particular type using canConvert().
920 The methods named toT() (e.g., toInt(), toString()) are const. If
921 you ask for the stored type, they return a copy of the stored
922 object. If you ask for a type that can be generated from the
923 stored type, toT() copies and converts and leaves the object
924 itself unchanged. If you ask for a type that cannot be generated
925 from the stored type, the result depends on the type; see the
926 function documentation for details.
928 Here is some example code to demonstrate the use of QVariant:
930 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 0
932 You can even store QList<QVariant> and QMap<QString, QVariant>
933 values in a variant, so you can easily construct arbitrarily
934 complex data structures of arbitrary types. This is very powerful
935 and versatile, but may prove less memory and speed efficient than
936 storing specific types in standard data structures.
938 QVariant also supports the notion of null values, where you can
939 have a defined type with no value set. However, note that QVariant
940 types can only be cast when they have had a value set.
942 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 1
944 QVariant can be extended to support other types than those
945 mentioned in the \l Type enum. See the \l QMetaType documentation
948 \section1 A Note on GUI Types
950 Because QVariant is part of the QtCore library, it cannot provide
951 conversion functions to data types defined in QtGui, such as
952 QColor, QImage, and QPixmap. In other words, there is no \c
953 toColor() function. Instead, you can use the QVariant::value() or
954 the qvariant_cast() template function. For example:
956 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 2
958 The inverse conversion (e.g., from QColor to QVariant) is
959 automatic for all data types supported by QVariant, including
962 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 3
964 \section1 Using canConvert() and convert() Consecutively
966 When using canConvert() and convert() consecutively, it is possible for
967 canConvert() to return true, but convert() to return false. This
968 is typically because canConvert() only reports the general ability of
969 QVariant to convert between types given suitable data; it is still
970 possible to supply data which cannot actually be converted.
972 For example, canConvert() would return true when called on a variant
973 containing a string because, in principle, QVariant is able to convert
974 strings of numbers to integers.
975 However, if the string contains non-numeric characters, it cannot be
976 converted to an integer, and any attempt to convert it will fail.
977 Hence, it is important to have both functions return true for a
978 successful conversion.
984 \obsolete Use QMetaType::Type instead
987 This enum type defines the types of variable that a QVariant can
990 \value Invalid no type
991 \value BitArray a QBitArray
992 \value Bitmap a QBitmap
994 \value Brush a QBrush
995 \value ByteArray a QByteArray
997 \value Color a QColor
998 \value Cursor a QCursor
1000 \value DateTime a QDateTime
1001 \value Double a double
1002 \value EasingCurve a QEasingCurve
1004 \value ModelIndex a QModelIndex
1006 \value Hash a QVariantHash
1008 \value Image a QImage
1010 \value KeySequence a QKeySequence
1012 \value LineF a QLineF
1013 \value List a QVariantList
1014 \value Locale a QLocale
1015 \value LongLong a \l qlonglong
1016 \value Map a QVariantMap
1017 \value Matrix a QMatrix
1018 \value Transform a QTransform
1019 \value Matrix4x4 a QMatrix4x4
1020 \value Palette a QPalette
1022 \value Pixmap a QPixmap
1023 \value Point a QPoint
1024 \value PointF a QPointF
1025 \value Polygon a QPolygon
1026 \value PolygonF a QPolygonF
1027 \value Quaternion a QQuaternion
1029 \value RectF a QRectF
1030 \value RegExp a QRegExp
1031 \value Region a QRegion
1033 \value SizeF a QSizeF
1034 \value SizePolicy a QSizePolicy
1035 \value String a QString
1036 \value StringList a QStringList
1037 \value TextFormat a QTextFormat
1038 \value TextLength a QTextLength
1040 \value UInt a \l uint
1041 \value ULongLong a \l qulonglong
1043 \value Vector2D a QVector2D
1044 \value Vector3D a QVector3D
1045 \value Vector4D a QVector4D
1047 \value UserType Base value for user-defined types.
1050 \omitvalue ColorGroup
1052 \omitvalue LastGuiType
1053 \omitvalue LastCoreType
1058 \fn QVariant::QVariant()
1060 Constructs an invalid variant.
1065 \fn QVariant::QVariant(int typeId, const void *copy)
1067 Constructs variant of type \a typeId, and initializes with
1068 \a copy if \a copy is not 0.
1070 Note that you have to pass the address of the variable you want stored.
1072 Usually, you never have to use this constructor, use QVariant::fromValue()
1073 instead to construct variants from the pointer types represented by
1074 \c QMetaType::VoidStar, \c QMetaType::QObjectStar and
1075 \c QMetaType::QWidgetStar.
1077 \sa QVariant::fromValue(), Type
1081 \fn QVariant::QVariant(Type type)
1083 Constructs a null variant of type \a type.
1089 \fn QVariant::create(int type, const void *copy)
1093 Constructs a variant private of type \a type, and initializes with \a copy if
1097 void QVariant::create(int type, const void *copy)
1100 handlerManager[type]->construct(&d, copy);
1104 \fn QVariant::~QVariant()
1106 Destroys the QVariant and the contained object.
1108 Note that subclasses that reimplement clear() should reimplement
1109 the destructor to call clear(). This destructor calls clear(), but
1110 because it is the destructor, QVariant::clear() is called rather
1111 than a subclass's clear().
1114 QVariant::~QVariant()
1116 if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char))
1117 handlerManager[d.type]->clear(&d);
1121 \fn QVariant::QVariant(const QVariant &p)
1123 Constructs a copy of the variant, \a p, passed as the argument to
1127 QVariant::QVariant(const QVariant &p)
1131 d.data.shared->ref.ref();
1132 } else if (p.d.type > Char) {
1133 handlerManager[d.type]->construct(&d, p.constData());
1134 d.is_null = p.d.is_null;
1138 #ifndef QT_NO_DATASTREAM
1140 Reads the variant from the data stream, \a s.
1142 QVariant::QVariant(QDataStream &s)
1147 #endif //QT_NO_DATASTREAM
1150 \fn QVariant::QVariant(const QString &val)
1152 Constructs a new variant with a string value, \a val.
1156 \fn QVariant::QVariant(const QLatin1String &val)
1158 Constructs a new variant with a string value, \a val.
1162 \fn QVariant::QVariant(const char *val)
1164 Constructs a new variant with a string value of \a val.
1165 The variant creates a deep copy of \a val into a QString assuming
1166 UTF-8 encoding on the input \a val.
1168 Note that \a val is converted to a QString for storing in the
1169 variant and QVariant::userType() will return QMetaType::QString for
1172 You can disable this operator by defining \c
1173 QT_NO_CAST_FROM_ASCII when you compile your applications.
1176 #ifndef QT_NO_CAST_FROM_ASCII
1177 QVariant::QVariant(const char *val)
1179 QString s = QString::fromAscii(val);
1185 \fn QVariant::QVariant(const QStringList &val)
1187 Constructs a new variant with a string list value, \a val.
1191 \fn QVariant::QVariant(const QMap<QString, QVariant> &val)
1193 Constructs a new variant with a map of QVariants, \a val.
1197 \fn QVariant::QVariant(const QHash<QString, QVariant> &val)
1199 Constructs a new variant with a hash of QVariants, \a val.
1203 \fn QVariant::QVariant(const QDate &val)
1205 Constructs a new variant with a date value, \a val.
1209 \fn QVariant::QVariant(const QTime &val)
1211 Constructs a new variant with a time value, \a val.
1215 \fn QVariant::QVariant(const QDateTime &val)
1217 Constructs a new variant with a date/time value, \a val.
1222 \fn QVariant::QVariant(const QEasingCurve &val)
1224 Constructs a new variant with an easing curve value, \a val.
1228 \fn QVariant::QVariant(const QByteArray &val)
1230 Constructs a new variant with a bytearray value, \a val.
1234 \fn QVariant::QVariant(const QBitArray &val)
1236 Constructs a new variant with a bitarray value, \a val.
1240 \fn QVariant::QVariant(const QPoint &val)
1242 Constructs a new variant with a point value of \a val.
1246 \fn QVariant::QVariant(const QPointF &val)
1248 Constructs a new variant with a point value of \a val.
1252 \fn QVariant::QVariant(const QRectF &val)
1254 Constructs a new variant with a rect value of \a val.
1258 \fn QVariant::QVariant(const QLineF &val)
1260 Constructs a new variant with a line value of \a val.
1264 \fn QVariant::QVariant(const QLine &val)
1266 Constructs a new variant with a line value of \a val.
1270 \fn QVariant::QVariant(const QRect &val)
1272 Constructs a new variant with a rect value of \a val.
1276 \fn QVariant::QVariant(const QSize &val)
1278 Constructs a new variant with a size value of \a val.
1282 \fn QVariant::QVariant(const QSizeF &val)
1284 Constructs a new variant with a size value of \a val.
1288 \fn QVariant::QVariant(const QUrl &val)
1290 Constructs a new variant with a url value of \a val.
1294 \fn QVariant::QVariant(int val)
1296 Constructs a new variant with an integer value, \a val.
1300 \fn QVariant::QVariant(uint val)
1302 Constructs a new variant with an unsigned integer value, \a val.
1306 \fn QVariant::QVariant(qlonglong val)
1308 Constructs a new variant with a long long integer value, \a val.
1312 \fn QVariant::QVariant(qulonglong val)
1314 Constructs a new variant with an unsigned long long integer value, \a val.
1319 \fn QVariant::QVariant(bool val)
1321 Constructs a new variant with a boolean value, \a val.
1325 \fn QVariant::QVariant(double val)
1327 Constructs a new variant with a floating point value, \a val.
1331 \fn QVariant::QVariant(float val)
1333 Constructs a new variant with a floating point value, \a val.
1338 \fn QVariant::QVariant(const QList<QVariant> &val)
1340 Constructs a new variant with a list value, \a val.
1344 \fn QVariant::QVariant(QChar c)
1346 Constructs a new variant with a char value, \a c.
1350 \fn QVariant::QVariant(const QLocale &l)
1352 Constructs a new variant with a locale value, \a l.
1356 \fn QVariant::QVariant(const QRegExp ®Exp)
1358 Constructs a new variant with the regexp value \a regExp.
1362 \fn QVariant::QVariant(Qt::GlobalColor color)
1364 Constructs a new variant of type QVariant::Color and initializes
1367 This is a convenience constructor that allows \c{QVariant(Qt::blue);}
1368 to create a valid QVariant storing a QColor.
1370 Note: This constructor will assert if the application does not link
1371 to the Qt GUI library.
1374 QVariant::QVariant(Type type)
1375 { create(type, 0); }
1376 QVariant::QVariant(int typeId, const void *copy)
1377 { create(typeId, copy); d.is_null = false; }
1380 flags is true if it is a pointer type
1382 QVariant::QVariant(int typeId, const void *copy, uint flags)
1384 if (flags) { //type is a pointer type
1386 d.data.ptr = *reinterpret_cast<void *const*>(copy);
1388 create(typeId, copy);
1393 QVariant::QVariant(int val)
1394 { d.is_null = false; d.type = Int; d.data.i = val; }
1395 QVariant::QVariant(uint val)
1396 { d.is_null = false; d.type = UInt; d.data.u = val; }
1397 QVariant::QVariant(qlonglong val)
1398 { d.is_null = false; d.type = LongLong; d.data.ll = val; }
1399 QVariant::QVariant(qulonglong val)
1400 { d.is_null = false; d.type = ULongLong; d.data.ull = val; }
1401 QVariant::QVariant(bool val)
1402 { d.is_null = false; d.type = Bool; d.data.b = val; }
1403 QVariant::QVariant(double val)
1404 { d.is_null = false; d.type = Double; d.data.d = val; }
1406 QVariant::QVariant(const QByteArray &val)
1407 { d.is_null = false; d.type = ByteArray; v_construct<QByteArray>(&d, val); }
1408 QVariant::QVariant(const QBitArray &val)
1409 { d.is_null = false; d.type = BitArray; v_construct<QBitArray>(&d, val); }
1410 QVariant::QVariant(const QString &val)
1411 { d.is_null = false; d.type = String; v_construct<QString>(&d, val); }
1412 QVariant::QVariant(QChar val)
1413 { d.is_null = false; d.type = Char; v_construct<QChar>(&d, val); }
1414 QVariant::QVariant(const QLatin1String &val)
1415 { QString str(val); d.is_null = false; d.type = String; v_construct<QString>(&d, str); }
1416 QVariant::QVariant(const QStringList &val)
1417 { d.is_null = false; d.type = StringList; v_construct<QStringList>(&d, val); }
1419 QVariant::QVariant(const QDate &val)
1420 { d.is_null = false; d.type = Date; v_construct<QDate>(&d, val); }
1421 QVariant::QVariant(const QTime &val)
1422 { d.is_null = false; d.type = Time; v_construct<QTime>(&d, val); }
1423 QVariant::QVariant(const QDateTime &val)
1424 { d.is_null = false; d.type = DateTime; v_construct<QDateTime>(&d, val); }
1425 #ifndef QT_BOOTSTRAPPED
1426 QVariant::QVariant(const QEasingCurve &val)
1427 { d.is_null = false; d.type = EasingCurve; v_construct<QEasingCurve>(&d, val); }
1429 QVariant::QVariant(const QList<QVariant> &list)
1430 { d.is_null = false; d.type = List; v_construct<QVariantList>(&d, list); }
1431 QVariant::QVariant(const QMap<QString, QVariant> &map)
1432 { d.is_null = false; d.type = Map; v_construct<QVariantMap>(&d, map); }
1433 QVariant::QVariant(const QHash<QString, QVariant> &hash)
1434 { d.is_null = false; d.type = Hash; v_construct<QVariantHash>(&d, hash); }
1435 #ifndef QT_NO_GEOM_VARIANT
1436 QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct<QPoint>(&d, pt); }
1437 QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct<QPointF>(&d, pt); }
1438 QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct<QRectF>(&d, r); }
1439 QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct<QLineF>(&d, l); }
1440 QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct<QLine>(&d, l); }
1441 QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct<QRect>(&d, r); }
1442 QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct<QSize>(&d, s); }
1443 QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct<QSizeF>(&d, s); }
1445 QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct<QUrl>(&d, u); }
1446 QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct<QLocale>(&d, l); }
1447 #ifndef QT_NO_REGEXP
1448 QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct<QRegExp>(&d, regExp); }
1450 QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); }
1453 Returns the storage type of the value stored in the variant.
1454 Although this function is declared as returning QVariant::Type,
1455 the return value should be interpreted as QMetaType::Type. In
1456 particular, QVariant::UserType is returned here only if the value
1457 is equal or greater than QMetaType::User.
1459 Note that return values in the ranges QVariant::Char through
1460 QVariant::RegExp and QVariant::Font through QVariant::Transform
1461 correspond to the values in the ranges QMetaType::QChar through
1462 QMetaType::QRegExp and QMetaType::QFont through QMetaType::QQuaternion.
1464 Pay particular attention when working with char and QChar
1465 variants. Note that there is no QVariant constructor specifically
1466 for type char, but there is one for QChar. For a variant of type
1467 QChar, this function returns QVariant::Char, which is the same as
1468 QMetaType::QChar, but for a variant of type \c char, this function
1469 returns QMetaType::Char, which is \e not the same as
1472 Also note that the types \c void*, \c long, \c short, \c unsigned
1473 \c long, \c unsigned \c short, \c unsigned \c char, \c float, \c
1474 QObject*, and \c QWidget* are represented in QMetaType::Type but
1475 not in QVariant::Type, and they can be returned by this function.
1476 However, they are considered to be user defined types when tested
1477 against QVariant::Type.
1479 To test whether an instance of QVariant contains a data type that
1480 is compatible with the data type you are interested in, use
1484 QVariant::Type QVariant::type() const
1486 return d.type >= QMetaType::User ? UserType : static_cast<Type>(d.type);
1490 Returns the storage type of the value stored in the variant. For
1491 non-user types, this is the same as type().
1496 int QVariant::userType() const
1502 Assigns the value of the variant \a variant to this variant.
1504 QVariant& QVariant::operator=(const QVariant &variant)
1506 if (this == &variant)
1510 if (variant.d.is_shared) {
1511 variant.d.data.shared->ref.ref();
1513 } else if (variant.d.type > Char) {
1514 d.type = variant.d.type;
1515 handlerManager[d.type]->construct(&d, variant.constData());
1516 d.is_null = variant.d.is_null;
1525 \fn void QVariant::swap(QVariant &other)
1528 Swaps variant \a other with this variant. This operation is very
1529 fast and never fails.
1533 \fn void QVariant::detach()
1538 void QVariant::detach()
1540 if (!d.is_shared || d.data.shared->ref.load() == 1)
1545 handlerManager[d.type]->construct(&dd, constData());
1546 if (!d.data.shared->ref.deref())
1547 handlerManager[d.type]->clear(&d);
1548 d.data.shared = dd.data.shared;
1552 \fn bool QVariant::isDetached() const
1557 // ### Qt 5: change typeName()(and froends= to return a QString. Suggestion from Harald.
1559 Returns the name of the type stored in the variant. The returned
1560 strings describe the C++ datatype used to store the data: for
1561 example, "QFont", "QString", or "QVariantList". An Invalid
1564 const char *QVariant::typeName() const
1566 return typeToName(d.type);
1570 Convert this variant to type Invalid and free up any resources
1573 void QVariant::clear()
1575 if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char))
1576 handlerManager[d.type]->clear(&d);
1579 d.is_shared = false;
1583 Converts the int representation of the storage type, \a typeId, to
1584 its string representation.
1586 Returns a null pointer if the type is QVariant::Invalid or doesn't exist.
1588 const char *QVariant::typeToName(int typeId)
1590 if (typeId == Invalid)
1593 return QMetaType::typeName(typeId);
1598 Converts the string representation of the storage type given in \a
1599 name, to its enum representation.
1601 If the string representation cannot be converted to any enum
1602 representation, the variant is set to \c Invalid.
1604 QVariant::Type QVariant::nameToType(const char *name)
1606 if (!name || !*name)
1609 int metaType = QMetaType::type(name);
1610 return metaType <= int(UserType) ? QVariant::Type(metaType) : UserType;
1613 #ifndef QT_NO_DATASTREAM
1614 enum { MapFromThreeCount = 36 };
1615 static const ushort mapIdFromQt3ToCurrent[MapFromThreeCount] =
1621 QVariant::StringList,
1637 QVariant::ByteArray,
1642 QVariant::SizePolicy,
1646 QVariant::ByteArray,
1648 QVariant::KeySequence,
1651 QVariant::ULongLong,
1652 QVariant::EasingCurve
1656 Internal function for loading a variant from stream \a s. Use the
1657 stream operators instead.
1661 void QVariant::load(QDataStream &s)
1667 if (s.version() < QDataStream::Qt_4_0) {
1668 if (typeId >= MapFromThreeCount)
1670 typeId = mapIdFromQt3ToCurrent[typeId];
1671 } else if (s.version() < QDataStream::Qt_5_0) {
1672 if (typeId == 127 /* QVariant::UserType */) {
1673 typeId = QMetaType::User;
1674 } else if (typeId >= 128 && typeId != QVariant::UserType) {
1675 // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
1676 // by moving all ids down by 97.
1678 } else if (typeId == 69 /* QIcon */) {
1679 // In Qt5 after modularization project this types where moved to a separate module (and ids were downgraded)
1680 typeId = QMetaType::QIcon;
1681 } else if (typeId == 75 /* QSizePolicy */) {
1682 typeId = QMetaType::QSizePolicy;
1683 } else if (typeId >= 70) {
1684 // and as a result this types recieved lower ids too
1685 if (typeId <= 74) { // QImage QPolygon QRegion QBitmap QCursor
1687 } else if (typeId <= 86) { // QKeySequence QPen QTextLength QTextFormat QMatrix QTransform QMatrix4x4 QVector2D QVector3D QVector4D QQuaternion
1693 qint8 is_null = false;
1694 if (s.version() >= QDataStream::Qt_4_2)
1696 if (typeId == QVariant::UserType) {
1699 typeId = QMetaType::type(name);
1700 if (typeId == QMetaType::UnknownType) {
1701 s.setStatus(QDataStream::ReadCorruptData);
1705 create(static_cast<int>(typeId), 0);
1706 d.is_null = is_null;
1709 // Since we wrote something, we should read something
1716 // const cast is safe since we operate on a newly constructed variant
1717 if (!QMetaType::load(s, d.type, const_cast<void *>(constData()))) {
1718 s.setStatus(QDataStream::ReadCorruptData);
1719 qWarning("QVariant::load: unable to load type %d.", d.type);
1724 Internal function for saving a variant to the stream \a s. Use the
1725 stream operators instead.
1729 void QVariant::save(QDataStream &s) const
1731 quint32 typeId = type();
1732 if (s.version() < QDataStream::Qt_4_0) {
1734 for (i = MapFromThreeCount - 1; i >= 0; i--) {
1735 if (mapIdFromQt3ToCurrent[i] == typeId) {
1744 } else if (s.version() < QDataStream::Qt_5_0) {
1745 if (typeId == QMetaType::User) {
1746 typeId = 127; // QVariant::UserType had this value in Qt4
1747 } else if (typeId >= 128 - 97 && typeId <= LastCoreType) {
1748 // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
1749 // by moving all ids down by 97.
1751 } else if (typeId == QMetaType::QIcon) {
1752 // In Qt5 after modularization project this types where moved to a separate module (and ids were downgraded)
1754 } else if (typeId == QMetaType::QSizePolicy) {
1756 } else if (typeId >= QMetaType::QImage) {
1757 // and as a result this types recieved lower ids too
1758 if (typeId <= QMetaType::QCursor) {
1760 } else if (typeId <= QMetaType::QQuaternion) {
1766 if (s.version() >= QDataStream::Qt_4_2)
1767 s << qint8(d.is_null);
1768 if (d.type >= QVariant::UserType) {
1769 s << QMetaType::typeName(userType());
1777 if (!QMetaType::save(s, d.type, constData())) {
1778 qWarning("QVariant::save: unable to save type '%s' (type id: %d).\n", QMetaType::typeName(d.type), d.type);
1779 Q_ASSERT_X(false, "QVariant::save", "Invalid type to save");
1786 Reads a variant \a p from the stream \a s.
1788 \sa \link datastreamformat.html Format of the QDataStream
1791 QDataStream& operator>>(QDataStream &s, QVariant &p)
1798 Writes a variant \a p to the stream \a s.
1800 \sa \link datastreamformat.html Format of the QDataStream
1803 QDataStream& operator<<(QDataStream &s, const QVariant &p)
1810 Reads a variant type \a p in enum representation from the stream \a s.
1812 QDataStream& operator>>(QDataStream &s, QVariant::Type &p)
1816 p = (QVariant::Type)u;
1822 Writes a variant type \a p to the stream \a s.
1824 QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
1826 s << static_cast<quint32>(p);
1831 #endif //QT_NO_DATASTREAM
1834 \fn bool QVariant::isValid() const
1836 Returns true if the storage type of this variant is not
1837 QVariant::Invalid; otherwise returns false.
1840 template <typename T>
1841 inline T qVariantToHelper(const QVariant::Private &d, const HandlersManager &handlerManager)
1843 const uint targetType = qMetaTypeId<T>();
1844 if (d.type == targetType)
1845 return *v_cast<T>(&d);
1848 handlerManager[d.type]->convert(&d, targetType, &ret, 0);
1853 \fn QStringList QVariant::toStringList() const
1855 Returns the variant as a QStringList if the variant has type()
1856 StringList, \l String, or \l List of a type that can be converted
1857 to QString; otherwise returns an empty list.
1859 \sa canConvert(), convert()
1861 QStringList QVariant::toStringList() const
1863 return qVariantToHelper<QStringList>(d, handlerManager);
1867 Returns the variant as a QString if the variant has type() \l
1868 String, \l Bool, \l ByteArray, \l Char, \l Date, \l DateTime, \l
1869 Double, \l Int, \l LongLong, \l StringList, \l Time, \l UInt, or
1870 \l ULongLong; otherwise returns an empty string.
1872 \sa canConvert(), convert()
1874 QString QVariant::toString() const
1876 return qVariantToHelper<QString>(d, handlerManager);
1880 Returns the variant as a QMap<QString, QVariant> if the variant
1881 has type() \l Map; otherwise returns an empty map.
1883 \sa canConvert(), convert()
1885 QVariantMap QVariant::toMap() const
1887 return qVariantToHelper<QVariantMap>(d, handlerManager);
1891 Returns the variant as a QHash<QString, QVariant> if the variant
1892 has type() \l Hash; otherwise returns an empty map.
1894 \sa canConvert(), convert()
1896 QVariantHash QVariant::toHash() const
1898 return qVariantToHelper<QVariantHash>(d, handlerManager);
1902 \fn QDate QVariant::toDate() const
1904 Returns the variant as a QDate if the variant has type() \l Date,
1905 \l DateTime, or \l String; otherwise returns an invalid date.
1907 If the type() is \l String, an invalid date will be returned if the
1908 string cannot be parsed as a Qt::ISODate format date.
1910 \sa canConvert(), convert()
1912 QDate QVariant::toDate() const
1914 return qVariantToHelper<QDate>(d, handlerManager);
1918 \fn QTime QVariant::toTime() const
1920 Returns the variant as a QTime if the variant has type() \l Time,
1921 \l DateTime, or \l String; otherwise returns an invalid time.
1923 If the type() is \l String, an invalid time will be returned if
1924 the string cannot be parsed as a Qt::ISODate format time.
1926 \sa canConvert(), convert()
1928 QTime QVariant::toTime() const
1930 return qVariantToHelper<QTime>(d, handlerManager);
1934 \fn QDateTime QVariant::toDateTime() const
1936 Returns the variant as a QDateTime if the variant has type() \l
1937 DateTime, \l Date, or \l String; otherwise returns an invalid
1940 If the type() is \l String, an invalid date/time will be returned
1941 if the string cannot be parsed as a Qt::ISODate format date/time.
1943 \sa canConvert(), convert()
1945 QDateTime QVariant::toDateTime() const
1947 return qVariantToHelper<QDateTime>(d, handlerManager);
1952 \fn QEasingCurve QVariant::toEasingCurve() const
1954 Returns the variant as a QEasingCurve if the variant has type() \l
1955 EasingCurve; otherwise returns a default easing curve.
1957 \sa canConvert(), convert()
1959 #ifndef QT_BOOTSTRAPPED
1960 QEasingCurve QVariant::toEasingCurve() const
1962 return qVariantToHelper<QEasingCurve>(d, handlerManager);
1967 \fn QByteArray QVariant::toByteArray() const
1969 Returns the variant as a QByteArray if the variant has type() \l
1970 ByteArray or \l String (converted using QString::fromAscii());
1971 otherwise returns an empty byte array.
1973 \sa canConvert(), convert()
1975 QByteArray QVariant::toByteArray() const
1977 return qVariantToHelper<QByteArray>(d, handlerManager);
1980 #ifndef QT_NO_GEOM_VARIANT
1982 \fn QPoint QVariant::toPoint() const
1984 Returns the variant as a QPoint if the variant has type()
1985 \l Point or \l PointF; otherwise returns a null QPoint.
1987 \sa canConvert(), convert()
1989 QPoint QVariant::toPoint() const
1991 return qVariantToHelper<QPoint>(d, handlerManager);
1995 \fn QRect QVariant::toRect() const
1997 Returns the variant as a QRect if the variant has type() \l Rect;
1998 otherwise returns an invalid QRect.
2000 \sa canConvert(), convert()
2002 QRect QVariant::toRect() const
2004 return qVariantToHelper<QRect>(d, handlerManager);
2008 \fn QSize QVariant::toSize() const
2010 Returns the variant as a QSize if the variant has type() \l Size;
2011 otherwise returns an invalid QSize.
2013 \sa canConvert(), convert()
2015 QSize QVariant::toSize() const
2017 return qVariantToHelper<QSize>(d, handlerManager);
2021 \fn QSizeF QVariant::toSizeF() const
2023 Returns the variant as a QSizeF if the variant has type() \l
2024 SizeF; otherwise returns an invalid QSizeF.
2026 \sa canConvert(), convert()
2028 QSizeF QVariant::toSizeF() const
2030 return qVariantToHelper<QSizeF>(d, handlerManager);
2034 \fn QRectF QVariant::toRectF() const
2036 Returns the variant as a QRectF if the variant has type() \l Rect
2037 or \l RectF; otherwise returns an invalid QRectF.
2039 \sa canConvert(), convert()
2041 QRectF QVariant::toRectF() const
2043 return qVariantToHelper<QRectF>(d, handlerManager);
2047 \fn QLineF QVariant::toLineF() const
2049 Returns the variant as a QLineF if the variant has type() \l
2050 LineF; otherwise returns an invalid QLineF.
2052 \sa canConvert(), convert()
2054 QLineF QVariant::toLineF() const
2056 return qVariantToHelper<QLineF>(d, handlerManager);
2060 \fn QLine QVariant::toLine() const
2062 Returns the variant as a QLine if the variant has type() \l Line;
2063 otherwise returns an invalid QLine.
2065 \sa canConvert(), convert()
2067 QLine QVariant::toLine() const
2069 return qVariantToHelper<QLine>(d, handlerManager);
2073 \fn QPointF QVariant::toPointF() const
2075 Returns the variant as a QPointF if the variant has type() \l
2076 Point or \l PointF; otherwise returns a null QPointF.
2078 \sa canConvert(), convert()
2080 QPointF QVariant::toPointF() const
2082 return qVariantToHelper<QPointF>(d, handlerManager);
2085 #endif // QT_NO_GEOM_VARIANT
2088 \fn QUrl QVariant::toUrl() const
2090 Returns the variant as a QUrl if the variant has type()
2091 \l Url; otherwise returns an invalid QUrl.
2093 \sa canConvert(), convert()
2095 QUrl QVariant::toUrl() const
2097 return qVariantToHelper<QUrl>(d, handlerManager);
2101 \fn QLocale QVariant::toLocale() const
2103 Returns the variant as a QLocale if the variant has type()
2104 \l Locale; otherwise returns an invalid QLocale.
2106 \sa canConvert(), convert()
2108 QLocale QVariant::toLocale() const
2110 return qVariantToHelper<QLocale>(d, handlerManager);
2114 \fn QRegExp QVariant::toRegExp() const
2117 Returns the variant as a QRegExp if the variant has type() \l
2118 RegExp; otherwise returns an empty QRegExp.
2120 \sa canConvert(), convert()
2122 #ifndef QT_NO_REGEXP
2123 QRegExp QVariant::toRegExp() const
2125 return qVariantToHelper<QRegExp>(d, handlerManager);
2130 \fn QChar QVariant::toChar() const
2132 Returns the variant as a QChar if the variant has type() \l Char,
2133 \l Int, or \l UInt; otherwise returns an invalid QChar.
2135 \sa canConvert(), convert()
2137 QChar QVariant::toChar() const
2139 return qVariantToHelper<QChar>(d, handlerManager);
2143 Returns the variant as a QBitArray if the variant has type()
2144 \l BitArray; otherwise returns an empty bit array.
2146 \sa canConvert(), convert()
2148 QBitArray QVariant::toBitArray() const
2150 return qVariantToHelper<QBitArray>(d, handlerManager);
2153 template <typename T>
2154 inline T qNumVariantToHelper(const QVariant::Private &d,
2155 const HandlersManager &handlerManager, bool *ok, const T& val)
2157 uint t = qMetaTypeId<T>();
2164 if (!handlerManager[d.type]->convert(&d, t, &ret, ok) && ok)
2170 Returns the variant as an int if the variant has type() \l Int,
2171 \l Bool, \l ByteArray, \l Char, \l Double, \l LongLong, \l
2172 String, \l UInt, or \l ULongLong; otherwise returns 0.
2174 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2175 converted to an int; otherwise \c{*}\a{ok} is set to false.
2177 \bold{Warning:} If the value is convertible to a \l LongLong but is too
2178 large to be represented in an int, the resulting arithmetic overflow will
2179 not be reflected in \a ok. A simple workaround is to use QString::toInt().
2180 Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code.
2182 \sa canConvert(), convert()
2184 int QVariant::toInt(bool *ok) const
2186 return qNumVariantToHelper<int>(d, handlerManager, ok, d.data.i);
2190 Returns the variant as an unsigned int if the variant has type()
2191 \l UInt, \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l
2192 LongLong, \l String, or \l ULongLong; otherwise returns 0.
2194 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2195 converted to an unsigned int; otherwise \c{*}\a{ok} is set to false.
2197 \bold{Warning:} If the value is convertible to a \l ULongLong but is too
2198 large to be represented in an unsigned int, the resulting arithmetic overflow will
2199 not be reflected in \a ok. A simple workaround is to use QString::toUInt().
2200 Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code.
2202 \sa canConvert(), convert()
2204 uint QVariant::toUInt(bool *ok) const
2206 return qNumVariantToHelper<uint>(d, handlerManager, ok, d.data.u);
2210 Returns the variant as a long long int if the variant has type()
2211 \l LongLong, \l Bool, \l ByteArray, \l Char, \l Double, \l Int,
2212 \l String, \l UInt, or \l ULongLong; otherwise returns 0.
2214 If \a ok is non-null: \c{*}\c{ok} is set to true if the value could be
2215 converted to an int; otherwise \c{*}\c{ok} is set to false.
2217 \sa canConvert(), convert()
2219 qlonglong QVariant::toLongLong(bool *ok) const
2221 return qNumVariantToHelper<qlonglong>(d, handlerManager, ok, d.data.ll);
2225 Returns the variant as as an unsigned long long int if the
2226 variant has type() \l ULongLong, \l Bool, \l ByteArray, \l Char,
2227 \l Double, \l Int, \l LongLong, \l String, or \l UInt; otherwise
2230 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2231 converted to an int; otherwise \c{*}\a{ok} is set to false.
2233 \sa canConvert(), convert()
2235 qulonglong QVariant::toULongLong(bool *ok) const
2237 return qNumVariantToHelper<qulonglong>(d, handlerManager, ok, d.data.ull);
2241 Returns the variant as a bool if the variant has type() Bool.
2243 Returns true if the variant has type() \l Bool, \l Char, \l Double,
2244 \l Int, \l LongLong, \l UInt, or \l ULongLong and the value is
2245 non-zero, or if the variant has type \l String or \l ByteArray and
2246 its lower-case content is not empty, "0" or "false"; otherwise
2249 \sa canConvert(), convert()
2251 bool QVariant::toBool() const
2257 handlerManager[d.type]->convert(&d, Bool, &res, 0);
2263 Returns the variant as a double if the variant has type() \l
2264 Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
2265 UInt, or \l ULongLong; otherwise returns 0.0.
2267 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2268 converted to a double; otherwise \c{*}\a{ok} is set to false.
2270 \sa canConvert(), convert()
2272 double QVariant::toDouble(bool *ok) const
2274 return qNumVariantToHelper<double>(d, handlerManager, ok, d.data.d);
2278 Returns the variant as a float if the variant has type() \l
2279 Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
2280 UInt, or \l ULongLong; otherwise returns 0.0.
2284 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2285 converted to a double; otherwise \c{*}\a{ok} is set to false.
2287 \sa canConvert(), convert()
2289 float QVariant::toFloat(bool *ok) const
2291 return qNumVariantToHelper<float>(d, handlerManager, ok, d.data.f);
2295 Returns the variant as a qreal if the variant has type() \l
2296 Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
2297 UInt, or \l ULongLong; otherwise returns 0.0.
2301 If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
2302 converted to a double; otherwise \c{*}\a{ok} is set to false.
2304 \sa canConvert(), convert()
2306 qreal QVariant::toReal(bool *ok) const
2308 return qNumVariantToHelper<qreal>(d, handlerManager, ok, d.data.real);
2312 Returns the variant as a QVariantList if the variant has type()
2313 \l List or \l StringList; otherwise returns an empty list.
2315 \sa canConvert(), convert()
2317 QVariantList QVariant::toList() const
2319 return qVariantToHelper<QVariantList>(d, handlerManager);
2323 static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
2327 /*Bool*/ 1 << QVariant::Double | 1 << QVariant::Int | 1 << QVariant::UInt
2328 | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::ByteArray
2329 | 1 << QVariant::String | 1 << QVariant::Char,
2331 /*Int*/ 1 << QVariant::UInt | 1 << QVariant::String | 1 << QVariant::Double
2332 | 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong
2333 | 1 << QVariant::Char | 1 << QVariant::ByteArray,
2335 /*UInt*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double
2336 | 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong
2337 | 1 << QVariant::Char | 1 << QVariant::ByteArray,
2339 /*LLong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double
2340 | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::ULongLong
2341 | 1 << QVariant::Char | 1 << QVariant::ByteArray,
2343 /*ULlong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double
2344 | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong
2345 | 1 << QVariant::Char | 1 << QVariant::ByteArray,
2347 /*double*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::ULongLong
2348 | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong
2349 | 1 << QVariant::ByteArray,
2351 /*QChar*/ 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::LongLong
2352 | 1 << QVariant::ULongLong,
2356 /*QList*/ 1 << QVariant::StringList,
2358 /*QString*/ 1 << QVariant::StringList | 1 << QVariant::ByteArray | 1 << QVariant::Int
2359 | 1 << QVariant::UInt | 1 << QVariant::Bool | 1 << QVariant::Double
2360 | 1 << QVariant::Date | 1 << QVariant::Time | 1 << QVariant::DateTime
2361 | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::Char
2362 | 1 << QVariant::Url | 1 << QVariant::Uuid,
2364 /*QStringList*/ 1 << QVariant::List | 1 << QVariant::String,
2366 /*QByteArray*/ 1 << QVariant::String | 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::Bool
2367 | 1 << QVariant::Double | 1 << QVariant::LongLong | 1 << QVariant::ULongLong,
2371 /*QDate*/ 1 << QVariant::String | 1 << QVariant::DateTime,
2373 /*QTime*/ 1 << QVariant::String | 1 << QVariant::DateTime,
2375 /*QDateTime*/ 1 << QVariant::String | 1 << QVariant::Date,
2377 /*QUrl*/ 1 << QVariant::String,
2381 /*QRect*/ 1 << QVariant::RectF,
2383 /*QRectF*/ 1 << QVariant::Rect,
2385 /*QSize*/ 1 << QVariant::SizeF,
2387 /*QSizeF*/ 1 << QVariant::Size,
2389 /*QLine*/ 1 << QVariant::LineF,
2391 /*QLineF*/ 1 << QVariant::Line,
2393 /*QPoint*/ 1 << QVariant::PointF,
2395 /*QPointF*/ 1 << QVariant::Point,
2403 /*QUuid*/ 1 << QVariant::String
2407 Returns true if the variant's type can be cast to the requested
2408 type, \a targetTypeId. Such casting is done automatically when calling the
2409 toInt(), toBool(), ... methods.
2411 The following casts are done automatically:
2414 \header \o Type \o Automatically Cast To
2415 \row \o \l Bool \o \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
2416 \row \o \l ByteArray \o \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
2417 \row \o \l Char \o \l Bool, \l Int, \l UInt, \l LongLong, \l ULongLong
2418 \row \o \l Color \o \l String
2419 \row \o \l Date \o \l DateTime, \l String
2420 \row \o \l DateTime \o \l Date, \l String, \l Time
2421 \row \o \l Double \o \l Bool, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
2422 \row \o \l Font \o \l String
2423 \row \o \l Int \o \l Bool, \l Char, \l Double, \l LongLong, \l String, \l UInt, \l ULongLong
2424 \row \o \l KeySequence \o \l Int, \l String
2425 \row \o \l List \o \l StringList (if the list's items can be converted to strings)
2426 \row \o \l LongLong \o \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l String, \l UInt, \l ULongLong
2427 \row \o \l Point \o PointF
2428 \row \o \l Rect \o RectF
2429 \row \o \l String \o \l Bool, \l ByteArray, \l Char, \l Color, \l Date, \l DateTime, \l Double,
2430 \l Font, \l Int, \l KeySequence, \l LongLong, \l StringList, \l Time, \l UInt,
2432 \row \o \l StringList \o \l List, \l String (if the list contains exactly one item)
2433 \row \o \l Time \o \l String
2434 \row \o \l UInt \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l ULongLong
2435 \row \o \l ULongLong \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt
2440 bool QVariant::canConvert(int targetTypeId) const
2442 // TODO Reimplement this function, currently it works but it is a historical mess.
2443 const uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type);
2444 if (uint(targetTypeId) == uint(QMetaType::Float)) targetTypeId = QVariant::Double;
2446 if (currentType == uint(targetTypeId))
2449 // FIXME It should be LastCoreType intead of Uuid
2450 if (currentType > int(QMetaType::QUuid) || targetTypeId > int(QMetaType::QUuid)) {
2451 switch (uint(targetTypeId)) {
2453 return currentType == QVariant::KeySequence
2454 || currentType == QMetaType::ULong
2455 || currentType == QMetaType::Long
2456 || currentType == QMetaType::UShort
2457 || currentType == QMetaType::UChar
2458 || currentType == QMetaType::Char
2459 || currentType == QMetaType::Short;
2460 case QVariant::Image:
2461 return currentType == QVariant::Pixmap || currentType == QVariant::Bitmap;
2462 case QVariant::Pixmap:
2463 return currentType == QVariant::Image || currentType == QVariant::Bitmap
2464 || currentType == QVariant::Brush;
2465 case QVariant::Bitmap:
2466 return currentType == QVariant::Pixmap || currentType == QVariant::Image;
2467 case QVariant::ByteArray:
2468 return currentType == QVariant::Color;
2469 case QVariant::String:
2470 return currentType == QVariant::KeySequence || currentType == QVariant::Font
2471 || currentType == QVariant::Color;
2472 case QVariant::KeySequence:
2473 return currentType == QVariant::String || currentType == QVariant::Int;
2474 case QVariant::Font:
2475 return currentType == QVariant::String;
2476 case QVariant::Color:
2477 return currentType == QVariant::String || currentType == QVariant::ByteArray
2478 || currentType == QVariant::Brush;
2479 case QVariant::Brush:
2480 return currentType == QVariant::Color || currentType == QVariant::Pixmap;
2481 case QMetaType::Long:
2482 case QMetaType::Char:
2483 case QMetaType::UChar:
2484 case QMetaType::ULong:
2485 case QMetaType::Short:
2486 case QMetaType::UShort:
2487 return qCanConvertMatrix[QVariant::Int] & (1 << currentType) || currentType == QVariant::Int;
2493 if (targetTypeId == String && currentType == StringList)
2494 return v_cast<QStringList>(&d)->count() == 1;
2496 return qCanConvertMatrix[targetTypeId] & (1 << currentType);
2500 Casts the variant to the requested type, \a targetTypeId. If the cast cannot be
2501 done, the variant is cleared. Returns true if the current type of
2502 the variant was successfully cast; otherwise returns false.
2504 \warning For historical reasons, converting a null QVariant results
2505 in a null value of the desired type (e.g., an empty string for
2506 QString) and a result of false.
2508 \sa canConvert(), clear()
2511 bool QVariant::convert(int targetTypeId)
2513 if (d.type == uint(targetTypeId))
2516 QVariant oldValue = *this;
2519 if (!oldValue.canConvert(targetTypeId))
2522 create(targetTypeId, 0);
2523 if (oldValue.isNull())
2527 if (!handlerManager[d.type]->convert(&oldValue.d, targetTypeId, data(), &isOk))
2534 \fn convert(const int type, void *ptr) const
2536 Created for qvariant_cast() usage
2538 bool QVariant::convert(const int type, void *ptr) const
2540 Q_ASSERT(type < int(QMetaType::User));
2541 return handlerManager[type]->convert(&d, type, ptr, 0);
2546 \fn bool operator==(const QVariant &v1, const QVariant &v2)
2550 Returns true if \a v1 and \a v2 are equal; otherwise returns false.
2552 \warning This function doesn't support custom types registered
2553 with qRegisterMetaType().
2556 \fn bool operator!=(const QVariant &v1, const QVariant &v2)
2560 Returns false if \a v1 and \a v2 are equal; otherwise returns true.
2562 \warning This function doesn't support custom types registered
2563 with qRegisterMetaType().
2566 /*! \fn bool QVariant::operator==(const QVariant &v) const
2568 Compares this QVariant with \a v and returns true if they are
2569 equal; otherwise returns false.
2571 In the case of custom types, their equalness operators are not called.
2572 Instead the values' addresses are compared.
2576 \fn bool QVariant::operator!=(const QVariant &v) const
2578 Compares this QVariant with \a v and returns true if they are not
2579 equal; otherwise returns false.
2581 \warning This function doesn't support custom types registered
2582 with qRegisterMetaType().
2585 static bool qIsNumericType(uint tp)
2587 return (tp >= QVariant::Bool && tp <= QVariant::Double)
2588 || (tp >= QMetaType::Long && tp <= QMetaType::Float);
2591 static bool qIsFloatingPoint(uint tp)
2593 return tp == QVariant::Double || tp == QMetaType::Float;
2598 bool QVariant::cmp(const QVariant &v) const
2601 if (d.type != v2.d.type) {
2602 if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) {
2603 if (qIsFloatingPoint(d.type) || qIsFloatingPoint(v.d.type))
2604 return qFuzzyCompare(toReal(), v.toReal());
2606 return toLongLong() == v.toLongLong();
2608 if (!v2.canConvert(d.type) || !v2.convert(d.type))
2611 return handlerManager[d.type]->compare(&d, &v2.d);
2617 const void *QVariant::constData() const
2619 return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
2623 \fn const void* QVariant::data() const
2629 void* QVariant::data()
2632 return const_cast<void *>(constData());
2637 Returns true if this is a NULL variant, false otherwise.
2639 bool QVariant::isNull() const
2641 return handlerManager[d.type]->isNull(&d);
2644 #ifndef QT_NO_DEBUG_STREAM
2645 QDebug operator<<(QDebug dbg, const QVariant &v)
2647 dbg.nospace() << "QVariant(" << QMetaType::typeName(v.userType()) << ", ";
2648 handlerManager[v.d.type]->debugStream(dbg, v);
2649 dbg.nospace() << ')';
2653 QDebug operator<<(QDebug dbg, const QVariant::Type p)
2655 dbg.nospace() << "QVariant::" << QMetaType::typeName(p);
2661 /*! \fn void QVariant::setValue(const T &value)
2663 Stores a copy of \a value. If \c{T} is a type that QVariant
2664 doesn't support, QMetaType is used to store the value. A compile
2665 error will occur if QMetaType doesn't handle the type.
2669 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 4
2671 \sa value(), fromValue(), canConvert()
2674 /*! \fn T QVariant::value() const
2676 Returns the stored value converted to the template type \c{T}.
2677 Call canConvert() to find out whether a type can be converted.
2678 If the value cannot be converted, \l{default-constructed value}
2681 If the type \c{T} is supported by QVariant, this function behaves
2682 exactly as toString(), toInt() etc.
2686 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 5
2688 \sa setValue(), fromValue(), canConvert()
2691 /*! \fn bool QVariant::canConvert() const
2693 Returns true if the variant can be converted to the template type \c{T},
2698 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 6
2703 /*! \fn static QVariant QVariant::fromValue(const T &value)
2705 Returns a QVariant containing a copy of \a value. Behaves
2706 exactly like setValue() otherwise.
2710 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 7
2712 \note If you are working with custom types, you should use
2713 the Q_DECLARE_METATYPE() macro to register your custom type.
2715 \sa setValue(), value()
2719 \fn QVariant qVariantFromValue(const T &value)
2723 Returns a variant containing a copy of the given \a value
2724 with template type \c{T}.
2726 This function is equivalent to QVariant::fromValue(\a value).
2728 \note This function was provided as a workaround for MSVC 6
2729 which did not support member template functions. It is advised
2730 to use the other form in new code.
2732 For example, a QObject pointer can be stored in a variant with the
2735 \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 8
2737 \sa QVariant::fromValue()
2740 /*! \fn void qVariantSetValue(QVariant &variant, const T &value)
2744 Sets the contents of the given \a variant to a copy of the
2745 \a value with the specified template type \c{T}.
2747 This function is equivalent to QVariant::setValue(\a value).
2749 \note This function was provided as a workaround for MSVC 6
2750 which did not support member template functions. It is advised
2751 to use the other form in new code.
2753 \sa QVariant::setValue()
2757 \fn T qvariant_cast(const QVariant &value)
2760 Returns the given \a value converted to the template type \c{T}.
2762 This function is equivalent to QVariant::value().
2764 \sa QVariant::value()
2767 /*! \fn T qVariantValue(const QVariant &value)
2771 Returns the given \a value converted to the template type \c{T}.
2773 This function is equivalent to
2774 \l{QVariant::value()}{QVariant::value}<T>(\a value).
2776 \note This function was provided as a workaround for MSVC 6
2777 which did not support member template functions. It is advised
2778 to use the other form in new code.
2780 \sa QVariant::value(), qvariant_cast()
2783 /*! \fn bool qVariantCanConvert(const QVariant &value)
2787 Returns true if the given \a value can be converted to the
2788 template type specified; otherwise returns false.
2790 This function is equivalent to QVariant::canConvert(\a value).
2792 \note This function was provided as a workaround for MSVC 6
2793 which did not support member template functions. It is advised
2794 to use the other form in new code.
2796 \sa QVariant::canConvert()
2800 \typedef QVariantList
2803 Synonym for QList<QVariant>.
2807 \typedef QVariantMap
2810 Synonym for QMap<QString, QVariant>.
2814 \typedef QVariantHash
2818 Synonym for QHash<QString, QVariant>.
2822 \typedef QVariant::DataPtr
2827 \fn DataPtr &QVariant::data_ptr()