Gitorious

8f427b2 by axis at 2009-04-24	1	/****************************************************************************
	2	**
89c08c0 by Jason McDonald at 2012-01-11	3	** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
04e3b30 by Jason McDonald at 2009-09-09	4	** All rights reserved.
858c70f by Jason McDonald at 2009-06-16	5	** Contact: Nokia Corporation (qt-info@nokia.com)
8f427b2 by axis at 2009-04-24	6	**
	7	** This file is part of the QtCore module of the Qt Toolkit.
	8	**
	9	** $QT_BEGIN_LICENSE:LGPL$
	10	** GNU Lesser General Public License Usage
1eea52e by Jyri Tahtela at 2011-05-13	11	** This file may be used under the terms of the GNU Lesser General Public
	12	** License version 2.1 as published by the Free Software Foundation and
	13	** appearing in the file LICENSE.LGPL included in the packaging of this
	14	** file. Please review the following information to ensure the GNU Lesser
	15	** General Public License version 2.1 requirements will be met:
	16	** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
8f427b2 by axis at 2009-04-24	17	**
04e3b30 by Jason McDonald at 2009-09-09	18	** In addition, as a special exception, Nokia gives you certain additional
1eea52e by Jyri Tahtela at 2011-05-13	19	** rights. These rights are described in the Nokia Qt LGPL Exception
04e3b30 by Jason McDonald at 2009-09-09	20	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
8f427b2 by axis at 2009-04-24	21	**
1eea52e by Jyri Tahtela at 2011-05-13	22	** GNU General Public License Usage
	23	** Alternatively, this file may be used under the terms of the GNU General
	24	** Public License version 3.0 as published by the Free Software Foundation
	25	** and appearing in the file LICENSE.GPL included in the packaging of this
	26	** file. Please review the following information to ensure the GNU General
	27	** Public License version 3.0 requirements will be met:
	28	** http://www.gnu.org/copyleft/gpl.html.
	29	**
	30	** Other Usage
	31	** Alternatively, this file may be used in accordance with the terms and
	32	** conditions contained in a signed written agreement between you and Nokia.
309db73 by Jason McDonald at 2009-08-31	33	**
	34	**
	35	**
	36	**
8f427b2 by axis at 2009-04-24	37	**
	38	** $QT_END_LICENSE$
	39	**
	40	****************************************************************************/
	41
	42	#include "qvariant.h"
	43	#include "qbitarray.h"
	44	#include "qbytearray.h"
	45	#include "qdatastream.h"
	46	#include "qdebug.h"
	47	#include "qmap.h"
	48	#include "qdatetime.h"
ab2497c by Leonardo Sobral Cunha at 2010-02-23	49	#include "qeasingcurve.h"
8f427b2 by axis at 2009-04-24	50	#include "qlist.h"
	51	#include "qstring.h"
	52	#include "qstringlist.h"
	53	#include "qurl.h"
	54	#include "qlocale.h"
	55	#include "private/qvariant_p.h"
	56
	57	#ifndef QT_NO_GEOM_VARIANT
	58	#include "qsize.h"
	59	#include "qpoint.h"
	60	#include "qrect.h"
	61	#include "qline.h"
	62	#endif
	63
	64	#include <float.h>
	65
	66	QT_BEGIN_NAMESPACE
	67
	68	#ifndef DBL_DIG
	69	# define DBL_DIG 10
	70	#endif
	71	#ifndef FLT_DIG
	72	# define FLT_DIG 6
	73	#endif
	74
	75	static void construct(QVariant::Private x, const void copy)
	76	{
	77	x->is_shared = false;
	78
	79	switch (x->type) {
	80	case QVariant::String:
	81	v_construct<QString>(x, copy);
	82	break;
	83	case QVariant::Char:
	84	v_construct<QChar>(x, copy);
	85	break;
	86	case QVariant::StringList:
	87	v_construct<QStringList>(x, copy);
	88	break;
	89	case QVariant::Map:
	90	v_construct<QVariantMap>(x, copy);
	91	break;
	92	case QVariant::Hash:
	93	v_construct<QVariantHash>(x, copy);
	94	break;
	95	case QVariant::List:
	96	v_construct<QVariantList>(x, copy);
	97	break;
	98	case QVariant::Date:
	99	v_construct<QDate>(x, copy);
	100	break;
	101	case QVariant::Time:
	102	v_construct<QTime>(x, copy);
	103	break;
	104	case QVariant::DateTime:
	105	v_construct<QDateTime>(x, copy);
	106	break;
	107	case QVariant::ByteArray:
	108	v_construct<QByteArray>(x, copy);
	109	break;
	110	case QVariant::BitArray:
	111	v_construct<QBitArray>(x, copy);
	112	break;
	113	#ifndef QT_NO_GEOM_VARIANT
	114	case QVariant::Size:
	115	v_construct<QSize>(x, copy);
	116	break;
	117	case QVariant::SizeF:
	118	v_construct<QSizeF>(x, copy);
	119	break;
	120	case QVariant::Rect:
	121	v_construct<QRect>(x, copy);
	122	break;
	123	case QVariant::LineF:
	124	v_construct<QLineF>(x, copy);
	125	break;
	126	case QVariant::Line:
	127	v_construct<QLine>(x, copy);
	128	break;
	129	case QVariant::RectF:
	130	v_construct<QRectF>(x, copy);
	131	break;
	132	case QVariant::Point:
	133	v_construct<QPoint>(x, copy);
	134	break;
	135	case QVariant::PointF:
	136	v_construct<QPointF>(x, copy);
	137	break;
	138	#endif
	139	case QVariant::Url:
	140	v_construct<QUrl>(x, copy);
	141	break;
	142	case QVariant::Locale:
	143	v_construct<QLocale>(x, copy);
	144	break;
	145	#ifndef QT_NO_REGEXP
	146	case QVariant::RegExp:
	147	v_construct<QRegExp>(x, copy);
	148	break;
	149	#endif
ab2497c by Leonardo Sobral Cunha at 2010-02-23	150	#ifndef QT_BOOTSTRAPPED
	151	case QVariant::EasingCurve:
	152	v_construct<QEasingCurve>(x, copy);
	153	break;
	154	#endif
8f427b2 by axis at 2009-04-24	155	case QVariant::Int:
	156	x->data.i = copy ? static_cast<const int >(copy) : 0;
	157	break;
	158	case QVariant::UInt:
	159	x->data.u = copy ? static_cast<const uint >(copy) : 0u;
	160	break;
	161	case QVariant::Bool:
	162	x->data.b = copy ? static_cast<const bool >(copy) : false;
	163	break;
	164	case QVariant::Double:
	165	x->data.d = copy ? static_cast<const double>(copy) : 0.0;
	166	break;
f68ce73 by Thierry Bastian at 2009-03-26	167	case QMetaType::Float:
	168	x->data.f = copy ? static_cast<const float>(copy) : 0.0f;
	169	break;
01f6bb9 by Aaron Kennedy at 2009-08-07	170	case QMetaType::QObjectStar:
	171	x->data.o = copy ? static_cast<QObject const*>(copy) : 0;
	172	break;
8f427b2 by axis at 2009-04-24	173	case QVariant::LongLong:
	174	x->data.ll = copy ? static_cast<const qlonglong >(copy) : Q_INT64_C(0);
	175	break;
	176	case QVariant::ULongLong:
	177	x->data.ull = copy ? static_cast<const qulonglong >(copy) : Q_UINT64_C(0);
	178	break;
	179	case QVariant::Invalid:
	180	case QVariant::UserType:
	181	break;
	182	default:
d1ced31 by Olivier Goffart at 2009-08-21	183	void *ptr = QMetaType::construct(x->type, copy);
	184	if (!ptr) {
8f427b2 by axis at 2009-04-24	185	x->type = QVariant::Invalid;
d1ced31 by Olivier Goffart at 2009-08-21	186	} else {
	187	x->is_shared = true;
	188	x->data.shared = new QVariant::PrivateShared(ptr);
	189	}
8f427b2 by axis at 2009-04-24	190	break;
	191	}
	192	x->is_null = !copy;
	193	}
	194
	195	static void clear(QVariant::Private *d)
	196	{
	197	switch (d->type) {
	198	case QVariant::String:
	199	v_clear<QString>(d);
	200	break;
	201	case QVariant::Char:
	202	v_clear<QChar>(d);
	203	break;
	204	case QVariant::StringList:
	205	v_clear<QStringList>(d);
	206	break;
	207	case QVariant::Map:
	208	v_clear<QVariantMap>(d);
	209	break;
	210	case QVariant::Hash:
	211	v_clear<QVariantHash>(d);
	212	break;
	213	case QVariant::List:
	214	v_clear<QVariantList>(d);
	215	break;
	216	case QVariant::Date:
	217	v_clear<QDate>(d);
	218	break;
	219	case QVariant::Time:
	220	v_clear<QTime>(d);
	221	break;
	222	case QVariant::DateTime:
	223	v_clear<QDateTime>(d);
	224	break;
	225	case QVariant::ByteArray:
	226	v_clear<QByteArray>(d);
	227	break;
	228	case QVariant::BitArray:
	229	v_clear<QBitArray>(d);
	230	break;
	231	#ifndef QT_NO_GEOM_VARIANT
	232	case QVariant::Point:
	233	v_clear<QPoint>(d);
	234	break;
	235	case QVariant::PointF:
	236	v_clear<QPointF>(d);
	237	break;
	238	case QVariant::Size:
	239	v_clear<QSize>(d);
	240	break;
	241	case QVariant::SizeF:
	242	v_clear<QSizeF>(d);
	243	break;
	244	case QVariant::Rect:
	245	v_clear<QRect>(d);
	246	break;
	247	case QVariant::LineF:
	248	v_clear<QLineF>(d);
	249	break;
	250	case QVariant::Line:
	251	v_clear<QLine>(d);
	252	break;
	253	case QVariant::RectF:
	254	v_clear<QRectF>(d);
	255	break;
	256	#endif
	257	case QVariant::Url:
	258	v_clear<QUrl>(d);
	259	break;
	260	case QVariant::Locale:
	261	v_clear<QLocale>(d);
	262	break;
	263	#ifndef QT_NO_REGEXP
	264	case QVariant::RegExp:
	265	v_clear<QRegExp>(d);
	266	break;
	267	#endif
ab2497c by Leonardo Sobral Cunha at 2010-02-23	268	#ifndef QT_BOOTSTRAPPED
	269	case QVariant::EasingCurve:
	270	v_clear<QEasingCurve>(d);
	271	break;
	272	#endif
8f427b2 by axis at 2009-04-24	273	case QVariant::LongLong:
	274	case QVariant::ULongLong:
	275	case QVariant::Double:
f68ce73 by Thierry Bastian at 2009-03-26	276	case QMetaType::Float:
01f6bb9 by Aaron Kennedy at 2009-08-07	277	case QMetaType::QObjectStar:
8f427b2 by axis at 2009-04-24	278	break;
	279	case QVariant::Invalid:
	280	case QVariant::UserType:
	281	case QVariant::Int:
	282	case QVariant::UInt:
	283	case QVariant::Bool:
	284	break;
	285	default:
	286	QMetaType::destroy(d->type, d->data.shared->ptr);
	287	delete d->data.shared;
	288	break;
	289	}
	290
	291	d->type = QVariant::Invalid;
	292	d->is_null = true;
	293	d->is_shared = false;
	294	}
	295
	296	static bool isNull(const QVariant::Private *d)
	297	{
	298	switch(d->type) {
	299	case QVariant::String:
	300	return v_cast<QString>(d)->isNull();
	301	case QVariant::Char:
	302	return v_cast<QChar>(d)->isNull();
	303	case QVariant::Date:
	304	return v_cast<QDate>(d)->isNull();
	305	case QVariant::Time:
	306	return v_cast<QTime>(d)->isNull();
	307	case QVariant::DateTime:
	308	return v_cast<QDateTime>(d)->isNull();
	309	case QVariant::ByteArray:
	310	return v_cast<QByteArray>(d)->isNull();
	311	case QVariant::BitArray:
	312	return v_cast<QBitArray>(d)->isNull();
	313	#ifndef QT_NO_GEOM_VARIANT
	314	case QVariant::Size:
	315	return v_cast<QSize>(d)->isNull();
	316	case QVariant::SizeF:
	317	return v_cast<QSizeF>(d)->isNull();
	318	case QVariant::Rect:
	319	return v_cast<QRect>(d)->isNull();
	320	case QVariant::Line:
	321	return v_cast<QLine>(d)->isNull();
	322	case QVariant::LineF:
	323	return v_cast<QLineF>(d)->isNull();
	324	case QVariant::RectF:
	325	return v_cast<QRectF>(d)->isNull();
	326	case QVariant::Point:
	327	return v_cast<QPoint>(d)->isNull();
	328	case QVariant::PointF:
	329	return v_cast<QPointF>(d)->isNull();
	330	#endif
ab2497c by Leonardo Sobral Cunha at 2010-02-23	331	#ifndef QT_BOOTSTRAPPED
	332	case QVariant::EasingCurve:
	333	#endif
8f427b2 by axis at 2009-04-24	334	case QVariant::Url:
	335	case QVariant::Locale:
	336	case QVariant::RegExp:
	337	case QVariant::StringList:
	338	case QVariant::Map:
	339	case QVariant::Hash:
	340	case QVariant::List:
	341	case QVariant::Invalid:
	342	case QVariant::UserType:
	343	case QVariant::Int:
	344	case QVariant::UInt:
	345	case QVariant::LongLong:
	346	case QVariant::ULongLong:
	347	case QVariant::Bool:
	348	case QVariant::Double:
728a7c2 by Thierry Bastian at 2009-04-27	349	case QMetaType::Float:
01f6bb9 by Aaron Kennedy at 2009-08-07	350	case QMetaType::QObjectStar:
8f427b2 by axis at 2009-04-24	351	break;
	352	}
	353	return d->is_null;
	354	}
	355
	356	/*
	357	\internal
	358	\since 4.4
	359
	360	We cannot use v_cast() for QMetaType's numeric types because they're smaller than QVariant::Private::Data,
	361	which in turns makes v_cast() believe the value is stored in d->data.c. But
	362	it's not, since we're a QMetaType type.
	363	*/
	364	template<typename T>
	365	inline bool compareNumericMetaType(const QVariant::Private const a, const QVariant::Private const b)
	366	{
	367	return static_cast<const T >(a->data.shared->ptr) == static_cast<const T >(b->data.shared->ptr);
	368	}
	369
	370	/*!
	371	\internal
	372
	373	Compares \a a to \a b. The caller guarantees that \a a and \a b
	374	are of the same type.
	375	*/
	376	static bool compare(const QVariant::Private a, const QVariant::Private b)
	377	{
	378	switch(a->type) {
	379	case QVariant::List:
	380	return v_cast<QVariantList>(a) == v_cast<QVariantList>(b);
	381	case QVariant::Map: {
	382	const QVariantMap *m1 = v_cast<QVariantMap>(a);
	383	const QVariantMap *m2 = v_cast<QVariantMap>(b);
	384	if (m1->count() != m2->count())
	385	return false;
	386	QVariantMap::ConstIterator it = m1->constBegin();
	387	QVariantMap::ConstIterator it2 = m2->constBegin();
	388	while (it != m1->constEnd()) {
	389	if (it != it2 \|\| it.key() != it2.key())
	390	return false;
	391	++it;
	392	++it2;
	393	}
	394	return true;
	395	}
	396	case QVariant::Hash:
	397	return v_cast<QVariantHash>(a) == v_cast<QVariantHash>(b);
	398	case QVariant::String:
	399	return v_cast<QString>(a) == v_cast<QString>(b);
	400	case QVariant::Char:
	401	return v_cast<QChar>(a) == v_cast<QChar>(b);
	402	case QVariant::StringList:
	403	return v_cast<QStringList>(a) == v_cast<QStringList>(b);
	404	#ifndef QT_NO_GEOM_VARIANT
	405	case QVariant::Size:
	406	return v_cast<QSize>(a) == v_cast<QSize>(b);
	407	case QVariant::SizeF:
	408	return v_cast<QSizeF>(a) == v_cast<QSizeF>(b);
	409	case QVariant::Rect:
	410	return v_cast<QRect>(a) == v_cast<QRect>(b);
	411	case QVariant::Line:
	412	return v_cast<QLine>(a) == v_cast<QLine>(b);
	413	case QVariant::LineF:
	414	return v_cast<QLineF>(a) == v_cast<QLineF>(b);
	415	case QVariant::RectF:
	416	return v_cast<QRectF>(a) == v_cast<QRectF>(b);
	417	case QVariant::Point:
	418	return v_cast<QPoint>(a) == v_cast<QPoint>(b);
	419	case QVariant::PointF:
	420	return v_cast<QPointF>(a) == v_cast<QPointF>(b);
	421	#endif
	422	case QVariant::Url:
	423	return v_cast<QUrl>(a) == v_cast<QUrl>(b);
	424	case QVariant::Locale:
	425	return v_cast<QLocale>(a) == v_cast<QLocale>(b);
	426	#ifndef QT_NO_REGEXP
	427	case QVariant::RegExp:
	428	return v_cast<QRegExp>(a) == v_cast<QRegExp>(b);
	429	#endif
	430	case QVariant::Int:
	431	return a->data.i == b->data.i;
	432	case QVariant::UInt:
	433	return a->data.u == b->data.u;
	434	case QVariant::LongLong:
	435	return a->data.ll == b->data.ll;
	436	case QVariant::ULongLong:
	437	return a->data.ull == b->data.ull;
	438	case QVariant::Bool:
	439	return a->data.b == b->data.b;
	440	case QVariant::Double:
	441	return a->data.d == b->data.d;
728a7c2 by Thierry Bastian at 2009-04-27	442	case QMetaType::Float:
	443	return a->data.f == b->data.f;
01f6bb9 by Aaron Kennedy at 2009-08-07	444	case QMetaType::QObjectStar:
	445	return a->data.o == b->data.o;
8f427b2 by axis at 2009-04-24	446	case QVariant::Date:
	447	return v_cast<QDate>(a) == v_cast<QDate>(b);
	448	case QVariant::Time:
	449	return v_cast<QTime>(a) == v_cast<QTime>(b);
	450	case QVariant::DateTime:
	451	return v_cast<QDateTime>(a) == v_cast<QDateTime>(b);
ab2497c by Leonardo Sobral Cunha at 2010-02-23	452	#ifndef QT_BOOTSTRAPPED
	453	case QVariant::EasingCurve:
	454	return v_cast<QEasingCurve>(a) == v_cast<QEasingCurve>(b);
	455	#endif
8f427b2 by axis at 2009-04-24	456	case QVariant::ByteArray:
	457	return v_cast<QByteArray>(a) == v_cast<QByteArray>(b);
	458	case QVariant::BitArray:
	459	return v_cast<QBitArray>(a) == v_cast<QBitArray>(b);
	460	case QVariant::Invalid:
	461	return true;
	462	case QMetaType::Long:
	463	return compareNumericMetaType<long>(a, b);
	464	case QMetaType::ULong:
	465	return compareNumericMetaType<ulong>(a, b);
	466	case QMetaType::Short:
	467	return compareNumericMetaType<short>(a, b);
	468	case QMetaType::UShort:
	469	return compareNumericMetaType<ushort>(a, b);
	470	case QMetaType::UChar:
	471	return compareNumericMetaType<uchar>(a, b);
	472	case QMetaType::Char:
	473	return compareNumericMetaType<char>(a, b);
	474	default:
	475	break;
	476	}
	477	if (!QMetaType::isRegistered(a->type))
	478	qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);
	479
f5f89d3 by Olivier Goffart at 2009-08-21	480	const void *a_ptr = a->is_shared ? a->data.shared->ptr : &(a->data.ptr);
	481	const void *b_ptr = b->is_shared ? b->data.shared->ptr : &(b->data.ptr);
	482
8f427b2 by axis at 2009-04-24	483	/* The reason we cannot place this test in a case branch above for the types
	484	* QMetaType::VoidStar, QMetaType::QObjectStar and so forth, is that it wouldn't include
	485	* user defined pointer types. */
	486	const char *const typeName = QMetaType::typeName(a->type);
a4d7572 by Olivier Goffart at 2010-03-03	487	uint typeNameLen = qstrlen(typeName);
	488	if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*')
f5f89d3 by Olivier Goffart at 2009-08-21	489	return static_cast<void const >(a_ptr) == static_cast<void const >(b_ptr);
8f427b2 by axis at 2009-04-24	490
2aaf4d1 by Olivier Goffart at 2010-03-04	491	if (a->is_null && b->is_null)
	492	return true;
	493
f5f89d3 by Olivier Goffart at 2009-08-21	494	return a_ptr == b_ptr;
8f427b2 by axis at 2009-04-24	495	}
	496
	497	/*!
	498	\internal
	499	*/
	500	static qlonglong qMetaTypeNumber(const QVariant::Private *d)
	501	{
	502	switch (d->type) {
	503	case QMetaType::Int:
	504	return d->data.i;
	505	case QMetaType::LongLong:
	506	return d->data.ll;
	507	case QMetaType::Char:
	508	return qlonglong(static_cast<signed char >(d->data.shared->ptr));
	509	case QMetaType::Short:
	510	return qlonglong(static_cast<short >(d->data.shared->ptr));
	511	case QMetaType::Long:
	512	return qlonglong(static_cast<long >(d->data.shared->ptr));
	513	case QMetaType::Float:
f68ce73 by Thierry Bastian at 2009-03-26	514	return qRound64(d->data.f);
8f427b2 by axis at 2009-04-24	515	case QVariant::Double:
	516	return qRound64(d->data.d);
	517	}
	518	Q_ASSERT(false);
	519	return 0;
	520	}
	521
	522	static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
	523	{
	524	switch (d->type) {
	525	case QVariant::UInt:
	526	return d->data.u;
	527	case QVariant::ULongLong:
	528	return d->data.ull;
	529	case QMetaType::UChar:
	530	return qulonglong(static_cast<unsigned char >(d->data.shared->ptr));
	531	case QMetaType::UShort:
	532	return qulonglong(static_cast<ushort >(d->data.shared->ptr));
	533	case QMetaType::ULong:
	534	return qulonglong(static_cast<ulong >(d->data.shared->ptr));
	535	}
	536	Q_ASSERT(false);
	537	return 0;
	538	}
	539
	540	static qlonglong qConvertToNumber(const QVariant::Private d, bool ok)
	541	{
	542	*ok = true;
	543
	544	switch (uint(d->type)) {
	545	case QVariant::String:
	546	return v_cast<QString>(d)->toLongLong(ok);
	547	case QVariant::Char:
	548	return v_cast<QChar>(d)->unicode();
	549	case QVariant::ByteArray:
	550	return v_cast<QByteArray>(d)->toLongLong(ok);
	551	case QVariant::Bool:
	552	return qlonglong(d->data.b);
	553	case QVariant::Double:
	554	case QVariant::Int:
	555	case QMetaType::Char:
	556	case QMetaType::Short:
	557	case QMetaType::Long:
	558	case QMetaType::Float:
	559	case QMetaType::LongLong:
	560	return qMetaTypeNumber(d);
	561	case QVariant::ULongLong:
	562	case QVariant::UInt:
	563	case QMetaType::UChar:
	564	case QMetaType::UShort:
	565	case QMetaType::ULong:
	566	return qlonglong(qMetaTypeUNumber(d));
	567	}
	568
	569	*ok = false;
	570	return Q_INT64_C(0);
	571	}
	572
	573	static qulonglong qConvertToUnsignedNumber(const QVariant::Private d, bool ok)
	574	{
	575	*ok = true;
	576
	577	switch (uint(d->type)) {
	578	case QVariant::String:
	579	return v_cast<QString>(d)->toULongLong(ok);
	580	case QVariant::Char:
	581	return v_cast<QChar>(d)->unicode();
	582	case QVariant::ByteArray:
	583	return v_cast<QByteArray>(d)->toULongLong(ok);
	584	case QVariant::Bool:
	585	return qulonglong(d->data.b);
	586	case QVariant::Double:
	587	case QVariant::Int:
	588	case QMetaType::Char:
	589	case QMetaType::Short:
	590	case QMetaType::Long:
	591	case QMetaType::Float:
	592	case QMetaType::LongLong:
	593	return qulonglong(qMetaTypeNumber(d));
	594	case QVariant::ULongLong:
	595	case QVariant::UInt:
	596	case QMetaType::UChar:
	597	case QMetaType::UShort:
	598	case QMetaType::ULong:
	599	return qMetaTypeUNumber(d);
	600	}
	601
	602	*ok = false;
	603	return Q_UINT64_C(0);
	604	}
	605
	606	template<typename TInput, typename LiteralWrapper>
	607	inline bool qt_convertToBool(const QVariant::Private *const d)
	608	{
	609	TInput str = v_cast<TInput>(d)->toLower();
	610	return !(str == LiteralWrapper("0") \|\| str == LiteralWrapper("false") \|\| str.isEmpty());
	611	}
	612
	613	/*!
	614	\internal
	615
	616	Converts \a d to type \a t, which is placed in \a result.
	617	*/
	618	static bool convert(const QVariant::Private d, QVariant::Type t, void result, bool *ok)
	619	{
	620	Q_ASSERT(d->type != uint(t));
	621	Q_ASSERT(result);
	622
	623	bool dummy;
	624	if (!ok)
	625	ok = &dummy;
	626
	627	switch (uint(t)) {
fbe7f34 by Janne Anttila at 2009-08-04	628	case QVariant::Url:
060727e by Thierry Bastian at 2009-06-10	629	switch (d->type) {
	630	case QVariant::String:
	631	static_cast<QUrl >(result) = QUrl(*v_cast<QString>(d));
	632	break;
	633	default:
	634	return false;
	635	}
	636	break;
8f427b2 by axis at 2009-04-24	637	case QVariant::String: {
	638	QString str = static_cast<QString >(result);
	639	switch (d->type) {
	640	case QVariant::Char:
	641	str = QString(v_cast<QChar>(d));
	642	break;
	643	case QMetaType::Char:
	644	case QMetaType::UChar:
	645	str = QChar::fromAscii(static_cast<char *>(d->data.shared->ptr));
	646	break;
	647	case QMetaType::Short:
	648	case QMetaType::Long:
	649	case QVariant::Int:
	650	case QVariant::LongLong:
	651	*str = QString::number(qMetaTypeNumber(d));
	652	break;
	653	case QVariant::UInt:
	654	case QVariant::ULongLong:
	655	case QMetaType::UShort:
	656	case QMetaType::ULong:
	657	*str = QString::number(qMetaTypeUNumber(d));
	658	break;
	659	case QMetaType::Float:
f68ce73 by Thierry Bastian at 2009-03-26	660	*str = QString::number(d->data.f, 'g', FLT_DIG);
8f427b2 by axis at 2009-04-24	661	break;
	662	case QVariant::Double:
	663	*str = QString::number(d->data.d, 'g', DBL_DIG);
	664	break;
	665	#if !defined(QT_NO_DATESTRING)
	666	case QVariant::Date:
	667	*str = v_cast<QDate>(d)->toString(Qt::ISODate);
	668	break;
	669	case QVariant::Time:
	670	*str = v_cast<QTime>(d)->toString(Qt::ISODate);
	671	break;
	672	case QVariant::DateTime:
	673	*str = v_cast<QDateTime>(d)->toString(Qt::ISODate);
	674	break;
	675	#endif
	676	case QVariant::Bool:
	677	*str = QLatin1String(d->data.b ? "true" : "false");
	678	break;
	679	case QVariant::ByteArray:
	680	*str = QString::fromAscii(v_cast<QByteArray>(d)->constData());
	681	break;
	682	case QVariant::StringList:
	683	if (v_cast<QStringList>(d)->count() == 1)
	684	*str = v_cast<QStringList>(d)->at(0);
	685	break;
060727e by Thierry Bastian at 2009-06-10	686	case QVariant::Url:
	687	*str = v_cast<QUrl>(d)->toString();
e2bb75e by Thierry Bastian at 2009-08-13	688	break;
8f427b2 by axis at 2009-04-24	689	default:
	690	return false;
	691	}
	692	break;
	693	}
	694	case QVariant::Char: {
	695	QChar c = static_cast<QChar >(result);
	696	switch (d->type) {
	697	case QVariant::Int:
	698	case QVariant::LongLong:
	699	case QMetaType::Char:
	700	case QMetaType::Short:
	701	case QMetaType::Long:
	702	case QMetaType::Float:
	703	*c = QChar(ushort(qMetaTypeNumber(d)));
	704	break;
	705	case QVariant::UInt:
	706	case QVariant::ULongLong:
	707	case QMetaType::UChar:
	708	case QMetaType::UShort:
	709	case QMetaType::ULong:
	710	*c = QChar(ushort(qMetaTypeUNumber(d)));
	711	break;
	712	default:
	713	return false;
	714	}
	715	break;
	716	}
	717	#ifndef QT_NO_GEOM_VARIANT
	718	case QVariant::Size: {
	719	QSize s = static_cast<QSize >(result);
	720	switch (d->type) {
	721	case QVariant::SizeF:
	722	*s = v_cast<QSizeF>(d)->toSize();
	723	break;
	724	default:
	725	return false;
	726	}
	727	break;
	728	}
	729
	730	case QVariant::SizeF: {
	731	QSizeF s = static_cast<QSizeF >(result);
	732	switch (d->type) {
	733	case QVariant::Size:
	734	s = QSizeF((v_cast<QSize>(d)));
	735	break;
	736	default:
	737	return false;
	738	}
	739	break;
	740	}
	741
	742	case QVariant::Line: {
	743	QLine s = static_cast<QLine >(result);
	744	switch (d->type) {
	745	case QVariant::LineF:
	746	*s = v_cast<QLineF>(d)->toLine();
	747	break;
	748	default:
	749	return false;
	750	}
	751	break;
	752	}
	753
	754	case QVariant::LineF: {
	755	QLineF s = static_cast<QLineF >(result);
	756	switch (d->type) {
	757	case QVariant::Line:
	758	s = QLineF((v_cast<QLine>(d)));
	759	break;
	760	default:
	761	return false;
	762	}
	763	break;
	764	}
	765	#endif
	766	case QVariant::StringList:
	767	if (d->type == QVariant::List) {
	768	QStringList slst = static_cast<QStringList >(result);
	769	const QVariantList *list = v_cast<QVariantList >(d);
	770	for (int i = 0; i < list->size(); ++i)
	771	slst->append(list->at(i).toString());
	772	} else if (d->type == QVariant::String) {
	773	QStringList slst = static_cast<QStringList >(result);
	774	slst = QStringList(v_cast<QString>(d));
	775	} else {
	776	return false;
	777	}
	778	break;
	779	case QVariant::Date: {
	780	QDate dt = static_cast<QDate >(result);
	781	if (d->type == QVariant::DateTime)
	782	*dt = v_cast<QDateTime>(d)->date();
	783	#ifndef QT_NO_DATESTRING
	784	else if (d->type == QVariant::String)
	785	dt = QDate::fromString(v_cast<QString>(d), Qt::ISODate);
	786	#endif
	787	else
	788	return false;
	789
	790	return dt->isValid();
	791	}
	792	case QVariant::Time: {
	793	QTime t = static_cast<QTime >(result);
	794	switch (d->type) {
	795	case QVariant::DateTime:
	796	*t = v_cast<QDateTime>(d)->time();
	797	break;
	798	#ifndef QT_NO_DATESTRING
	799	case QVariant::String:
	800	t = QTime::fromString(v_cast<QString>(d), Qt::ISODate);
	801	break;
	802	#endif
	803	default:
	804	return false;
	805	}
	806	return t->isValid();
	807	}
	808	case QVariant::DateTime: {
	809	QDateTime dt = static_cast<QDateTime >(result);
	810	switch (d->type) {
	811	#ifndef QT_NO_DATESTRING
	812	case QVariant::String:
	813	dt = QDateTime::fromString(v_cast<QString>(d), Qt::ISODate);
	814	break;
	815	#endif
	816	case QVariant::Date:
	817	dt = QDateTime(v_cast<QDate>(d));
	818	break;
	819	default:
	820	return false;
	821	}
	822	return dt->isValid();
	823	}
	824	case QVariant::ByteArray: {
	825	QByteArray ba = static_cast<QByteArray >(result);
	826	switch (d->type) {
	827	case QVariant::String:
	828	*ba = v_cast<QString>(d)->toAscii();
	829	break;
	830	case QVariant::Double:
	831	*ba = QByteArray::number(d->data.d, 'g', DBL_DIG);
	832	break;
	833	case QMetaType::Float:
f68ce73 by Thierry Bastian at 2009-03-26	834	*ba = QByteArray::number(d->data.f, 'g', FLT_DIG);
8f427b2 by axis at 2009-04-24	835	break;
	836	case QMetaType::Char:
	837	case QMetaType::UChar:
	838	ba = QByteArray(1, static_cast<char *>(d->data.shared->ptr));
	839	break;
	840	case QVariant::Int:
	841	case QVariant::LongLong:
	842	case QMetaType::Short:
	843	case QMetaType::Long:
	844	*ba = QByteArray::number(qMetaTypeNumber(d));
	845	break;
	846	case QVariant::UInt:
	847	case QVariant::ULongLong:
	848	case QMetaType::UShort:
	849	case QMetaType::ULong:
	850	*ba = QByteArray::number(qMetaTypeUNumber(d));
	851	break;
	852	case QVariant::Bool:
	853	*ba = QByteArray(d->data.b ? "true" : "false");
	854	break;
	855	default:
	856	return false;
	857	}
	858	}
	859	break;
	860	case QMetaType::Short:
	861	static_cast<short >(result) = short(qConvertToNumber(d, ok));
	862	return *ok;
	863	case QMetaType::Long:
	864	static_cast<long >(result) = long(qConvertToNumber(d, ok));
	865	return *ok;
	866	case QMetaType::UShort:
	867	static_cast<ushort >(result) = ushort(qConvertToUnsignedNumber(d, ok));
	868	return *ok;
	869	case QMetaType::ULong:
	870	static_cast<ulong >(result) = ulong(qConvertToUnsignedNumber(d, ok));
	871	return *ok;
	872	case QVariant::Int:
	873	static_cast<int >(result) = int(qConvertToNumber(d, ok));
	874	return *ok;
	875	case QVariant::UInt:
	876	static_cast<uint >(result) = uint(qConvertToUnsignedNumber(d, ok));
	877	return *ok;
	878	case QVariant::LongLong:
	879	static_cast<qlonglong >(result) = qConvertToNumber(d, ok);
	880	return *ok;
	881	case QVariant::ULongLong: {
	882	static_cast<qulonglong >(result) = qConvertToUnsignedNumber(d, ok);
	883	return *ok;
	884	}
	885	case QMetaType::UChar: {
	886	static_cast<uchar >(result) = qConvertToUnsignedNumber(d, ok);
	887	return *ok;
	888	}
	889	case QVariant::Bool: {
	890	bool b = static_cast<bool >(result);
	891	switch(d->type) {
	892	case QVariant::ByteArray:
	893	*b = qt_convertToBool<QByteArray, QByteArray>(d);
	894	break;
	895	case QVariant::String:
	896	*b = qt_convertToBool<QString, QLatin1String>(d);
	897	break;
	898	case QVariant::Char:
	899	*b = !v_cast<QChar>(d)->isNull();
	900	break;
	901	case QVariant::Double:
	902	case QVariant::Int:
	903	case QVariant::LongLong:
	904	case QMetaType::Char:
	905	case QMetaType::Short:
	906	case QMetaType::Long:
	907	case QMetaType::Float:
	908	*b = qMetaTypeNumber(d) != Q_INT64_C(0);
	909	break;
	910	case QVariant::UInt:
	911	case QVariant::ULongLong:
	912	case QMetaType::UChar:
	913	case QMetaType::UShort:
	914	case QMetaType::ULong:
	915	*b = qMetaTypeUNumber(d) != Q_UINT64_C(0);
	916	break;
	917	default:
	918	*b = false;
	919	return false;
	920	}
	921	break;
	922	}
	923	case QVariant::Double: {
	924	double f = static_cast<double >(result);
	925	switch (d->type) {
	926	case QVariant::String:
	927	*f = v_cast<QString>(d)->toDouble(ok);
	928	break;
	929	case QVariant::ByteArray:
	930	*f = v_cast<QByteArray>(d)->toDouble(ok);
	931	break;
	932	case QVariant::Bool:
	933	*f = double(d->data.b);
	934	break;
	935	case QMetaType::Float:
f68ce73 by Thierry Bastian at 2009-03-26	936	*f = double(d->data.f);
8f427b2 by axis at 2009-04-24	937	break;
	938	case QVariant::LongLong:
	939	case QVariant::Int:
	940	case QMetaType::Char:
	941	case QMetaType::Short:
	942	case QMetaType::Long:
	943	*f = double(qMetaTypeNumber(d));
	944	break;
	945	case QVariant::UInt:
	946	case QVariant::ULongLong:
	947	case QMetaType::UChar:
	948	case QMetaType::UShort:
	949	case QMetaType::ULong:
	950	*f = double(qMetaTypeUNumber(d));
	951	break;
	952	default:
	953	*f = 0.0;
	954	return false;
	955	}
	956	break;
	957	}
	958	case QMetaType::Float: {
	959	float f = static_cast<float >(result);
	960	switch (d->type) {
	961	case QVariant::String:
b770651 by Thierry Bastian at 2009-08-14	962	*f = v_cast<QString>(d)->toFloat(ok);
8f427b2 by axis at 2009-04-24	963	break;
	964	case QVariant::ByteArray:
b770651 by Thierry Bastian at 2009-08-14	965	*f = v_cast<QByteArray>(d)->toFloat(ok);
8f427b2 by axis at 2009-04-24	966	break;
	967	case QVariant::Bool:
	968	*f = float(d->data.b);
	969	break;
	970	case QVariant::Double:
	971	*f = float(d->data.d);
	972	break;
	973	case QVariant::LongLong:
	974	case QVariant::Int:
	975	case QMetaType::Char:
	976	case QMetaType::Short:
	977	case QMetaType::Long:
	978	*f = float(qMetaTypeNumber(d));
	979	break;
	980	case QVariant::UInt:
	981	case QVariant::ULongLong:
	982	case QMetaType::UChar:
	983	case QMetaType::UShort:
	984	case QMetaType::ULong:
	985	*f = float(qMetaTypeUNumber(d));
	986	break;
	987	default:
	988	*f = 0.0f;
	989	return false;
	990	}
	991	break;
	992	}
	993	case QVariant::List:
	994	if (d->type == QVariant::StringList) {
	995	QVariantList lst = static_cast<QVariantList >(result);
	996	const QStringList *slist = v_cast<QStringList>(d);
	997	for (int i = 0; i < slist->size(); ++i)
	998	lst->append(QVariant(slist->at(i)));
	999	} else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {
	1000	static_cast<QVariantList >(result) =
	1001	static_cast<QList<QVariant> >(d->data.shared->ptr);
	1002	} else {
	1003	return false;
	1004	}
	1005	break;
	1006	case QVariant::Map:
	1007	if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
	1008	static_cast<QVariantMap >(result) =
	1009	static_cast<QMap<QString, QVariant> >(d->data.shared->ptr);
	1010	} else {
	1011	return false;
	1012	}
	1013	break;
	1014	case QVariant::Hash:
	1015	if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) {
	1016	static_cast<QVariantHash >(result) =
	1017	static_cast<QHash<QString, QVariant> >(d->data.shared->ptr);
	1018	} else {
	1019	return false;
	1020	}
	1021	break;
	1022	#ifndef QT_NO_GEOM_VARIANT
	1023	case QVariant::Rect:
	1024	if (d->type == QVariant::RectF)
	1025	static_cast<QRect >(result) = (v_cast<QRectF>(d))->toRect();
	1026	else
	1027	return false;
	1028	break;
	1029	case QVariant::RectF:
	1030	if (d->type == QVariant::Rect)
	1031	static_cast<QRectF >(result) = *v_cast<QRect>(d);
	1032	else
	1033	return false;
	1034	break;
	1035	case QVariant::PointF:
	1036	if (d->type == QVariant::Point)
	1037	static_cast<QPointF >(result) = *v_cast<QPoint>(d);
	1038	else
	1039	return false;
	1040	break;
	1041	case QVariant::Point:
	1042	if (d->type == QVariant::PointF)
	1043	static_cast<QPoint >(result) = (v_cast<QPointF>(d))->toPoint();
	1044	else
	1045	return false;
	1046	break;
	1047	case QMetaType::Char:
	1048	{
	1049	static_cast<qint8 >(result) = qint8(qConvertToNumber(d, ok));
	1050	return *ok;
	1051	}
	1052	#endif
	1053	default:
	1054	return false;
	1055	}
	1056	return true;
	1057	}
	1058
	1059	#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
	1060	static void streamDebug(QDebug dbg, const QVariant &v)
	1061	{
d2e3f2a by Thierry Bastian at 2009-05-20	1062	switch (v.userType()) {
8f427b2 by axis at 2009-04-24	1063	case QVariant::Int:
	1064	dbg.nospace() << v.toInt();
	1065	break;
	1066	case QVariant::UInt:
	1067	dbg.nospace() << v.toUInt();
	1068	break;
	1069	case QVariant::LongLong:
	1070	dbg.nospace() << v.toLongLong();
	1071	break;
	1072	case QVariant::ULongLong:
	1073	dbg.nospace() << v.toULongLong();
	1074	break;
d2e3f2a by Thierry Bastian at 2009-05-20	1075	case QMetaType::Float:
b770651 by Thierry Bastian at 2009-08-14	1076	dbg.nospace() << v.toFloat();
d2e3f2a by Thierry Bastian at 2009-05-20	1077	break;
01f6bb9 by Aaron Kennedy at 2009-08-07	1078	case QMetaType::QObjectStar:
7b5e37c by Olivier Goffart at 2010-08-06	1079	dbg.nospace() << qvariant_cast<QObject *>(v);
01f6bb9 by Aaron Kennedy at 2009-08-07	1080	break;
8f427b2 by axis at 2009-04-24	1081	case QVariant::Double:
	1082	dbg.nospace() << v.toDouble();
	1083	break;
	1084	case QVariant::Bool:
	1085	dbg.nospace() << v.toBool();
	1086	break;
	1087	case QVariant::String:
	1088	dbg.nospace() << v.toString();
	1089	break;
	1090	case QVariant::Char:
	1091	dbg.nospace() << v.toChar();
	1092	break;
	1093	case QVariant::StringList:
	1094	dbg.nospace() << v.toStringList();
	1095	break;
	1096	case QVariant::Map:
	1097	dbg.nospace() << v.toMap();
	1098	break;
	1099	case QVariant::Hash:
	1100	dbg.nospace() << v.toHash();
	1101	break;
	1102	case QVariant::List:
	1103	dbg.nospace() << v.toList();
	1104	break;
	1105	case QVariant::Date:
	1106	dbg.nospace() << v.toDate();
	1107	break;
	1108	case QVariant::Time:
	1109	dbg.nospace() << v.toTime();
	1110	break;
	1111	case QVariant::DateTime:
	1112	dbg.nospace() << v.toDateTime();
	1113	break;
ab2497c by Leonardo Sobral Cunha at 2010-02-23	1114	#ifndef QT_BOOTSTRAPPED
	1115	case QVariant::EasingCurve:
	1116	dbg.nospace() << v.toEasingCurve();
	1117	break;
	1118	#endif
8f427b2 by axis at 2009-04-24	1119	case QVariant::ByteArray:
	1120	dbg.nospace() << v.toByteArray();
	1121	break;
	1122	case QVariant::Url:
	1123	dbg.nospace() << v.toUrl();
	1124	break;
	1125	#ifndef QT_NO_GEOM_VARIANT
	1126	case QVariant::Point:
	1127	dbg.nospace() << v.toPoint();
	1128	break;
	1129	case QVariant::PointF:
	1130	dbg.nospace() << v.toPointF();
	1131	break;
	1132	case QVariant::Rect:
	1133	dbg.nospace() << v.toRect();
	1134	break;
	1135	case QVariant::Size:
	1136	dbg.nospace() << v.toSize();
	1137	break;
	1138	case QVariant::SizeF:
	1139	dbg.nospace() << v.toSizeF();
	1140	break;
	1141	case QVariant::Line:
	1142	dbg.nospace() << v.toLine();
	1143	break;
	1144	case QVariant::LineF:
	1145	dbg.nospace() << v.toLineF();
	1146	break;
	1147	case QVariant::RectF:
	1148	dbg.nospace() << v.toRectF();
	1149	break;
	1150	#endif
	1151	case QVariant::BitArray:
	1152	//dbg.nospace() << v.toBitArray();
	1153	break;
	1154	default:
	1155	break;
	1156	}
	1157	}
	1158	#endif
	1159
	1160	const QVariant::Handler qt_kernel_variant_handler = {
	1161	construct,
	1162	clear,
	1163	isNull,
	1164	#ifndef QT_NO_DATASTREAM
	1165	0,
	1166	0,
	1167	#endif
	1168	compare,
	1169	convert,
	1170	0,
	1171	#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
	1172	streamDebug
	1173	#else
	1174	0
	1175	#endif
	1176	};
	1177
	1178	Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler()
	1179	{
	1180	return &qt_kernel_variant_handler;
	1181	}
	1182
	1183
	1184	const QVariant::Handler *QVariant::handler = &qt_kernel_variant_handler;
	1185
	1186	/*!
	1187	\class QVariant
	1188	\brief The QVariant class acts like a union for the most common Qt data types.
	1189
	1190	\ingroup objectmodel
	1191	\ingroup shared
911557f by Volker Hilsheimer at 2009-08-17	1192
8f427b2 by axis at 2009-04-24	1193
	1194	Because C++ forbids unions from including types that have
	1195	non-default constructors or destructors, most interesting Qt
	1196	classes cannot be used in unions. Without QVariant, this would be
	1197	a problem for QObject::property() and for database work, etc.
	1198
	1199	A QVariant object holds a single value of a single type() at a
	1200	time. (Some type()s are multi-valued, for example a string list.)
	1201	You can find out what type, T, the variant holds, convert it to a
	1202	different type using convert(), get its value using one of the
	1203	toT() functions (e.g., toSize()) and check whether the type can
	1204	be converted to a particular type using canConvert().
	1205
	1206	The methods named toT() (e.g., toInt(), toString()) are const. If
	1207	you ask for the stored type, they return a copy of the stored
	1208	object. If you ask for a type that can be generated from the
	1209	stored type, toT() copies and converts and leaves the object
	1210	itself unchanged. If you ask for a type that cannot be generated
	1211	from the stored type, the result depends on the type; see the
	1212	function documentation for details.
	1213
	1214	Here is some example code to demonstrate the use of QVariant:
	1215
	1216	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 0
	1217
	1218	You can even store QList<QVariant> and QMap<QString, QVariant>
	1219	values in a variant, so you can easily construct arbitrarily
	1220	complex data structures of arbitrary types. This is very powerful
	1221	and versatile, but may prove less memory and speed efficient than
	1222	storing specific types in standard data structures.
	1223
fbe7f34 by Janne Anttila at 2009-08-04	1224	QVariant also supports the notion of null values, where you can
	1225	have a defined type with no value set. However, note that QVariant
960d2a7 by Morten Engvoldsen at 2009-05-13	1226	types can only be cast when they have had a value set.
8f427b2 by axis at 2009-04-24	1227
	1228	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 1
	1229
	1230	QVariant can be extended to support other types than those
	1231	mentioned in the \l Type enum. See the \l QMetaType documentation
	1232	for details.
	1233
	1234	\section1 A Note on GUI Types
	1235
	1236	Because QVariant is part of the QtCore library, it cannot provide
	1237	conversion functions to data types defined in QtGui, such as
	1238	QColor, QImage, and QPixmap. In other words, there is no \c
	1239	toColor() function. Instead, you can use the QVariant::value() or
7b5e37c by Olivier Goffart at 2010-08-06	1240	the qvariant_cast() template function. For example:
8f427b2 by axis at 2009-04-24	1241
	1242	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 2
	1243
	1244	The inverse conversion (e.g., from QColor to QVariant) is
	1245	automatic for all data types supported by QVariant, including
	1246	GUI-related types:
	1247
	1248	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 3
	1249
	1250	\section1 Using canConvert() and convert() Consecutively
	1251
	1252	When using canConvert() and convert() consecutively, it is possible for
	1253	canConvert() to return true, but convert() to return false. This
	1254	is typically because canConvert() only reports the general ability of
	1255	QVariant to convert between types given suitable data; it is still
	1256	possible to supply data which cannot actually be converted.
	1257
	1258	For example, canConvert() would return true when called on a variant
	1259	containing a string because, in principle, QVariant is able to convert
	1260	strings of numbers to integers.
	1261	However, if the string contains non-numeric characters, it cannot be
	1262	converted to an integer, and any attempt to convert it will fail.
	1263	Hence, it is important to have both functions return true for a
	1264	successful conversion.
	1265
	1266	\sa QMetaType
	1267	*/
	1268
	1269	/*!
	1270	\enum QVariant::Type
	1271
	1272	This enum type defines the types of variable that a QVariant can
	1273	contain.
	1274
	1275	\value Invalid no type
	1276	\value BitArray a QBitArray
	1277	\value Bitmap a QBitmap
	1278	\value Bool a bool
	1279	\value Brush a QBrush
	1280	\value ByteArray a QByteArray
	1281	\value Char a QChar
	1282	\value Color a QColor
	1283	\value Cursor a QCursor
	1284	\value Date a QDate
	1285	\value DateTime a QDateTime
	1286	\value Double a double
ab2497c by Leonardo Sobral Cunha at 2010-02-23	1287	\value EasingCurve a QEasingCurve
8f427b2 by axis at 2009-04-24	1288	\value Font a QFont
	1289	\value Hash a QVariantHash
	1290	\value Icon a QIcon
	1291	\value Image a QImage
	1292	\value Int an int
	1293	\value KeySequence a QKeySequence
	1294	\value Line a QLine
	1295	\value LineF a QLineF
	1296	\value List a QVariantList
	1297	\value Locale a QLocale
	1298	\value LongLong a \l qlonglong
	1299	\value Map a QVariantMap
	1300	\value Matrix a QMatrix
	1301	\value Transform a QTransform
c42f705 by Rhys Weatherley at 2009-07-23	1302	\value Matrix4x4 a QMatrix4x4
8f427b2 by axis at 2009-04-24	1303	\value Palette a QPalette
	1304	\value Pen a QPen
	1305	\value Pixmap a QPixmap
	1306	\value Point a QPoint
	1307	\value PointArray a QPointArray
	1308	\value PointF a QPointF
	1309	\value Polygon a QPolygon
c42f705 by Rhys Weatherley at 2009-07-23	1310	\value Quaternion a QQuaternion
8f427b2 by axis at 2009-04-24	1311	\value Rect a QRect
	1312	\value RectF a QRectF
	1313	\value RegExp a QRegExp
	1314	\value Region a QRegion
	1315	\value Size a QSize
	1316	\value SizeF a QSizeF
	1317	\value SizePolicy a QSizePolicy
	1318	\value String a QString
	1319	\value StringList a QStringList
	1320	\value TextFormat a QTextFormat
	1321	\value TextLength a QTextLength
	1322	\value Time a QTime
	1323	\value UInt a \l uint
	1324	\value ULongLong a \l qulonglong
	1325	\value Url a QUrl
c42f705 by Rhys Weatherley at 2009-07-23	1326	\value Vector2D a QVector2D
	1327	\value Vector3D a QVector3D
	1328	\value Vector4D a QVector4D
8f427b2 by axis at 2009-04-24	1329
	1330	\value UserType Base value for user-defined types.
	1331
	1332	\omitvalue CString
	1333	\omitvalue ColorGroup
	1334	\omitvalue IconSet
	1335	\omitvalue LastGuiType
	1336	\omitvalue LastCoreType
	1337	\omitvalue LastType
	1338	*/
	1339
	1340	/*!
	1341	\fn QVariant::QVariant()
	1342
	1343	Constructs an invalid variant.
	1344	*/
	1345
	1346
	1347	/*!
	1348	\fn QVariant::QVariant(int typeOrUserType, const void *copy)
	1349
	1350	Constructs variant of type \a typeOrUserType, and initializes with
	1351	\a copy if \a copy is not 0.
	1352
	1353	Note that you have to pass the address of the variable you want stored.
	1354
7b5e37c by Olivier Goffart at 2010-08-06	1355	Usually, you never have to use this constructor, use QVariant::fromValue()
8f427b2 by axis at 2009-04-24	1356	instead to construct variants from the pointer types represented by
	1357	\c QMetaType::VoidStar, \c QMetaType::QObjectStar and
	1358	\c QMetaType::QWidgetStar.
	1359
7b5e37c by Olivier Goffart at 2010-08-06	1360	\sa QVariant::fromValue(), Type
8f427b2 by axis at 2009-04-24	1361	*/
	1362
	1363	/*!
	1364	\fn QVariant::QVariant(Type type)
	1365
	1366	Constructs a null variant of type \a type.
	1367	*/
	1368
	1369
	1370
	1371	/*!
	1372	\fn QVariant::create(int type, const void *copy)
	1373
	1374	\internal
	1375
	1376	Constructs a variant private of type \a type, and initializes with \a copy if
	1377	\a copy is not 0.
	1378	*/
	1379
	1380	void QVariant::create(int type, const void *copy)
	1381	{
	1382	d.type = type;
	1383	handler->construct(&d, copy);
	1384	}
	1385
	1386	/*!
	1387	\fn QVariant::~QVariant()
	1388
	1389	Destroys the QVariant and the contained object.
	1390
	1391	Note that subclasses that reimplement clear() should reimplement
	1392	the destructor to call clear(). This destructor calls clear(), but
	1393	because it is the destructor, QVariant::clear() is called rather
	1394	than a subclass's clear().
	1395	*/
	1396
	1397	QVariant::~QVariant()
	1398	{
f5f89d3 by Olivier Goffart at 2009-08-21	1399	if ((d.is_shared && !d.data.shared->ref.deref()) \|\| (!d.is_shared && d.type > Char && d.type < UserType))
8f427b2 by axis at 2009-04-24	1400	handler->clear(&d);
	1401	}
	1402
	1403	/*!
	1404	\fn QVariant::QVariant(const QVariant &p)
	1405
	1406	Constructs a copy of the variant, \a p, passed as the argument to
	1407	this constructor.
	1408	*/
	1409
	1410	QVariant::QVariant(const QVariant &p)
	1411	: d(p.d)
	1412	{
	1413	if (d.is_shared) {
	1414	d.data.shared->ref.ref();
f5f89d3 by Olivier Goffart at 2009-08-21	1415	} else if (p.d.type > Char && p.d.type < QVariant::UserType) {
8f427b2 by axis at 2009-04-24	1416	handler->construct(&d, p.constData());
	1417	d.is_null = p.d.is_null;
	1418	}
	1419	}
	1420
	1421	#ifndef QT_NO_DATASTREAM
	1422	/*!
	1423	Reads the variant from the data stream, \a s.
	1424	*/
	1425	QVariant::QVariant(QDataStream &s)
	1426	{
	1427	d.is_null = true;
	1428	s >> *this;
	1429	}
	1430	#endif //QT_NO_DATASTREAM
	1431
	1432	/*!
	1433	\fn QVariant::QVariant(const QString &val)
	1434
	1435	Constructs a new variant with a string value, \a val.
	1436	*/
	1437
	1438	/*!
	1439	\fn QVariant::QVariant(const QLatin1String &val)
	1440
	1441	Constructs a new variant with a string value, \a val.
	1442	*/
	1443
	1444	/*!
	1445	\fn QVariant::QVariant(const char *val)
	1446
	1447	Constructs a new variant with a string value of \a val.
	1448	The variant creates a deep copy of \a val, using the encoding
	1449	set by QTextCodec::setCodecForCStrings().
	1450
	1451	Note that \a val is converted to a QString for storing in the
	1452	variant and QVariant::type() will return QMetaType::QString for
	1453	the variant.
	1454
	1455	You can disable this operator by defining \c
	1456	QT_NO_CAST_FROM_ASCII when you compile your applications.
	1457
	1458	\sa QTextCodec::setCodecForCStrings()
	1459	*/
	1460
	1461	#ifndef QT_NO_CAST_FROM_ASCII
	1462	QVariant::QVariant(const char *val)
	1463	{
	1464	QString s = QString::fromAscii(val);
	1465	create(String, &s);
	1466	}
	1467	#endif
	1468
	1469	/*!
	1470	\fn QVariant::QVariant(const QStringList &val)
	1471
	1472	Constructs a new variant with a string list value, \a val.
	1473	*/
	1474
	1475	/*!
	1476	\fn QVariant::QVariant(const QMap<QString, QVariant> &val)
	1477
	1478	Constructs a new variant with a map of QVariants, \a val.
	1479	*/
	1480
	1481	/*!
	1482	\fn QVariant::QVariant(const QHash<QString, QVariant> &val)
	1483
	1484	Constructs a new variant with a hash of QVariants, \a val.
	1485	*/
	1486
	1487	/*!
	1488	\fn QVariant::QVariant(const QDate &val)
	1489
	1490	Constructs a new variant with a date value, \a val.
	1491	*/
	1492
	1493	/*!
	1494	\fn QVariant::QVariant(const QTime &val)
	1495
	1496	Constructs a new variant with a time value, \a val.
	1497	*/
	1498
	1499	/*!
	1500	\fn QVariant::QVariant(const QDateTime &val)
	1501
	1502	Constructs a new variant with a date/time value, \a val.
	1503	*/
	1504
	1505	/*!
00e358a by Volker Hilsheimer at 2010-03-08	1506	\since 4.7
ab2497c by Leonardo Sobral Cunha at 2010-02-23	1507	\fn QVariant::QVariant(const QEasingCurve &val)
	1508
	1509	Constructs a new variant with an easing curve value, \a val.
	1510	*/
	1511
	1512	/*!
8f427b2 by axis at 2009-04-24	1513	\fn QVariant::QVariant(const QByteArray &val)
	1514
	1515	Constructs a new variant with a bytearray value, \a val.
	1516	*/
	1517
	1518	/*!
	1519	\fn QVariant::QVariant(const QBitArray &val)
	1520
	1521	Constructs a new variant with a bitarray value, \a val.
	1522	*/
	1523
	1524	/*!
	1525	\fn QVariant::QVariant(const QPoint &val)
	1526
	1527	Constructs a new variant with a point value of \a val.
	1528	*/
	1529
	1530	/*!
	1531	\fn QVariant::QVariant(const QPointF &val)
	1532
	1533	Constructs a new variant with a point value of \a val.
	1534	*/
	1535
	1536	/*!
	1537	\fn QVariant::QVariant(const QRectF &val)
	1538
	1539	Constructs a new variant with a rect value of \a val.
	1540	*/
	1541
	1542	/*!
	1543	\fn QVariant::QVariant(const QLineF &val)
	1544
	1545	Constructs a new variant with a line value of \a val.
	1546	*/
	1547
	1548	/*!
	1549	\fn QVariant::QVariant(const QLine &val)
	1550
	1551	Constructs a new variant with a line value of \a val.
	1552	*/
	1553
	1554	/*!
	1555	\fn QVariant::QVariant(const QRect &val)
	1556
	1557	Constructs a new variant with a rect value of \a val.
	1558	*/
	1559
	1560	/*!
	1561	\fn QVariant::QVariant(const QSize &val)
	1562
	1563	Constructs a new variant with a size value of \a val.
	1564	*/
	1565
	1566	/*!
	1567	\fn QVariant::QVariant(const QSizeF &val)
	1568
	1569	Constructs a new variant with a size value of \a val.
	1570	*/
	1571
	1572	/*!
	1573	\fn QVariant::QVariant(const QUrl &val)
	1574
	1575	Constructs a new variant with a url value of \a val.
	1576	*/
	1577
	1578	/*!
	1579	\fn QVariant::QVariant(int val)
	1580
	1581	Constructs a new variant with an integer value, \a val.
	1582	*/
	1583
	1584	/*!
	1585	\fn QVariant::QVariant(uint val)
	1586
	1587	Constructs a new variant with an unsigned integer value, \a val.
	1588	*/
	1589
	1590	/*!
	1591	\fn QVariant::QVariant(qlonglong val)
	1592
	1593	Constructs a new variant with a long long integer value, \a val.
	1594	*/
	1595
	1596	/*!
	1597	\fn QVariant::QVariant(qulonglong val)
	1598
	1599	Constructs a new variant with an unsigned long long integer value, \a val.
	1600	*/
	1601
	1602
	1603	/*!
	1604	\fn QVariant::QVariant(bool val)
	1605
	1606	Constructs a new variant with a boolean value, \a val.
	1607	*/
	1608
	1609	/*!
	1610	\fn QVariant::QVariant(double val)
	1611
	1612	Constructs a new variant with a floating point value, \a val.
	1613	*/
	1614
	1615	/*!
f68ce73 by Thierry Bastian at 2009-03-26	1616	\fn QVariant::QVariant(float val)
	1617
	1618	Constructs a new variant with a floating point value, \a val.
ab2faea by Olivier Goffart at 2009-08-31	1619	\since 4.6
f68ce73 by Thierry Bastian at 2009-03-26	1620	*/
	1621
	1622	/*!
8f427b2 by axis at 2009-04-24	1623	\fn QVariant::QVariant(const QList<QVariant> &val)
	1624
	1625	Constructs a new variant with a list value, \a val.
	1626	*/
	1627
	1628	/*!
	1629	\fn QVariant::QVariant(const QChar &c)
	1630
	1631	Constructs a new variant with a char value, \a c.
	1632	*/
	1633
	1634	/*!
	1635	\fn QVariant::QVariant(const QLocale &l)
	1636
	1637	Constructs a new variant with a locale value, \a l.
	1638	*/
	1639
	1640	/*!
	1641	\fn QVariant::QVariant(const QRegExp &regExp)
	1642
	1643	Constructs a new variant with the regexp value \a regExp.
	1644	*/
	1645
	1646	/*! \since 4.2
	1647	\fn QVariant::QVariant(Qt::GlobalColor color)
	1648
	1649	Constructs a new variant of type QVariant::Color and initializes
	1650	it with \a color.
	1651
	1652	This is a convenience constructor that allows \c{QVariant(Qt::blue);}
	1653	to create a valid QVariant storing a QColor.
	1654
	1655	Note: This constructor will assert if the application does not link
	1656	to the Qt GUI library.
	1657	*/
	1658
	1659	QVariant::QVariant(Type type)
	1660	{ create(type, 0); }
	1661	QVariant::QVariant(int typeOrUserType, const void *copy)
	1662	{ create(typeOrUserType, copy); d.is_null = false; }
f5f89d3 by Olivier Goffart at 2009-08-21	1663
	1664	/*! \internal
	1665	flags is true if it is a pointer type
	1666	*/
	1667	QVariant::QVariant(int typeOrUserType, const void *copy, uint flags)
	1668	{
	1669	if (flags) { //type is a pointer type
	1670	d.type = typeOrUserType;
	1671	d.data.ptr = reinterpret_cast<void const*>(copy);
	1672	d.is_null = false;
	1673	} else {
	1674	create(typeOrUserType, copy);
	1675	d.is_null = false;
	1676	}
	1677	}
	1678
8f427b2 by axis at 2009-04-24	1679	QVariant::QVariant(int val)
	1680	{ d.is_null = false; d.type = Int; d.data.i = val; }
	1681	QVariant::QVariant(uint val)
	1682	{ d.is_null = false; d.type = UInt; d.data.u = val; }
	1683	QVariant::QVariant(qlonglong val)
	1684	{ d.is_null = false; d.type = LongLong; d.data.ll = val; }
	1685	QVariant::QVariant(qulonglong val)
	1686	{ d.is_null = false; d.type = ULongLong; d.data.ull = val; }
	1687	QVariant::QVariant(bool val)
	1688	{ d.is_null = false; d.type = Bool; d.data.b = val; }
	1689	QVariant::QVariant(double val)
	1690	{ d.is_null = false; d.type = Double; d.data.d = val; }
	1691
	1692	QVariant::QVariant(const QByteArray &val)
ba31fca by Thierry Bastian at 2009-03-31	1693	{ d.is_null = false; d.type = ByteArray; v_construct<QByteArray>(&d, val); }
8f427b2 by axis at 2009-04-24	1694	QVariant::QVariant(const QBitArray &val)
ba31fca by Thierry Bastian at 2009-03-31	1695	{ d.is_null = false; d.type = BitArray; v_construct<QBitArray>(&d, val); }
8f427b2 by axis at 2009-04-24	1696	QVariant::QVariant(const QString &val)
ba31fca by Thierry Bastian at 2009-03-31	1697	{ d.is_null = false; d.type = String; v_construct<QString>(&d, val); }
8f427b2 by axis at 2009-04-24	1698	QVariant::QVariant(const QChar &val)
ba31fca by Thierry Bastian at 2009-03-31	1699	{ d.is_null = false; d.type = Char; v_construct<QChar>(&d, val); }
8f427b2 by axis at 2009-04-24	1700	QVariant::QVariant(const QLatin1String &val)
ba31fca by Thierry Bastian at 2009-03-31	1701	{ QString str(val); d.is_null = false; d.type = String; v_construct<QString>(&d, str); }
8f427b2 by axis at 2009-04-24	1702	QVariant::QVariant(const QStringList &val)
ba31fca by Thierry Bastian at 2009-03-31	1703	{ d.is_null = false; d.type = StringList; v_construct<QStringList>(&d, val); }
8f427b2 by axis at 2009-04-24	1704
	1705	QVariant::QVariant(const QDate &val)
ba31fca by Thierry Bastian at 2009-03-31	1706	{ d.is_null = false; d.type = Date; v_construct<QDate>(&d, val); }
8f427b2 by axis at 2009-04-24	1707	QVariant::QVariant(const QTime &val)
ba31fca by Thierry Bastian at 2009-03-31	1708	{ d.is_null = false; d.type = Time; v_construct<QTime>(&d, val); }
8f427b2 by axis at 2009-04-24	1709	QVariant::QVariant(const QDateTime &val)
ba31fca by Thierry Bastian at 2009-03-31	1710	{ d.is_null = false; d.type = DateTime; v_construct<QDateTime>(&d, val); }
ab2497c by Leonardo Sobral Cunha at 2010-02-23	1711	#ifndef QT_BOOTSTRAPPED
	1712	QVariant::QVariant(const QEasingCurve &val)
	1713	{ d.is_null = false; d.type = EasingCurve; v_construct<QEasingCurve>(&d, val); }
	1714	#endif
8f427b2 by axis at 2009-04-24	1715	QVariant::QVariant(const QList<QVariant> &list)
ba31fca by Thierry Bastian at 2009-03-31	1716	{ d.is_null = false; d.type = List; v_construct<QVariantList>(&d, list); }
8f427b2 by axis at 2009-04-24	1717	QVariant::QVariant(const QMap<QString, QVariant> &map)
ba31fca by Thierry Bastian at 2009-03-31	1718	{ d.is_null = false; d.type = Map; v_construct<QVariantMap>(&d, map); }
8f427b2 by axis at 2009-04-24	1719	QVariant::QVariant(const QHash<QString, QVariant> &hash)
ba31fca by Thierry Bastian at 2009-03-31	1720	{ d.is_null = false; d.type = Hash; v_construct<QVariantHash>(&d, hash); }
8f427b2 by axis at 2009-04-24	1721	#ifndef QT_NO_GEOM_VARIANT
ba31fca by Thierry Bastian at 2009-03-31	1722	QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct<QPoint>(&d, pt); }
	1723	QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct<QPointF>(&d, pt); }
	1724	QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct<QRectF>(&d, r); }
	1725	QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct<QLineF>(&d, l); }
	1726	QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct<QLine>(&d, l); }
	1727	QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct<QRect>(&d, r); }
	1728	QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct<QSize>(&d, s); }
	1729	QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct<QSizeF>(&d, s); }
8f427b2 by axis at 2009-04-24	1730	#endif
ba31fca by Thierry Bastian at 2009-03-31	1731	QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct<QUrl>(&d, u); }
	1732	QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct<QLocale>(&d, l); }
8f427b2 by axis at 2009-04-24	1733	#ifndef QT_NO_REGEXP
ba31fca by Thierry Bastian at 2009-03-31	1734	QVariant::QVariant(const QRegExp &regExp) { d.is_null = false; d.type = RegExp; v_construct<QRegExp>(&d, regExp); }
8f427b2 by axis at 2009-04-24	1735	#endif
	1736	QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); }
	1737
	1738	/*!
	1739	Returns the storage type of the value stored in the variant.
	1740	Although this function is declared as returning QVariant::Type,
	1741	the return value should be interpreted as QMetaType::Type. In
	1742	particular, QVariant::UserType is returned here only if the value
	1743	is equal or greater than QMetaType::User.
	1744
	1745	Note that return values in the ranges QVariant::Char through
	1746	QVariant::RegExp and QVariant::Font through QVariant::Transform
	1747	correspond to the values in the ranges QMetaType::QChar through
c42f705 by Rhys Weatherley at 2009-07-23	1748	QMetaType::QRegExp and QMetaType::QFont through QMetaType::QQuaternion.
8f427b2 by axis at 2009-04-24	1749
	1750	Pay particular attention when working with char and QChar
	1751	variants. Note that there is no QVariant constructor specifically
	1752	for type char, but there is one for QChar. For a variant of type
	1753	QChar, this function returns QVariant::Char, which is the same as
	1754	QMetaType::QChar, but for a variant of type \c char, this function
	1755	returns QMetaType::Char, which is \e not the same as
	1756	QVariant::Char.
	1757
	1758	Also note that the types \c void*, \c long, \c short, \c unsigned
	1759	\c long, \c unsigned \c short, \c unsigned \c char, \c float, \c
	1760	QObject, and \c QWidget are represented in QMetaType::Type but
	1761	not in QVariant::Type, and they can be returned by this function.
	1762	However, they are considered to be user defined types when tested
	1763	against QVariant::Type.
	1764
	1765	To test whether an instance of QVariant contains a data type that
	1766	is compatible with the data type you are interested in, use
	1767	canConvert().
	1768	*/
	1769
	1770	QVariant::Type QVariant::type() const
	1771	{
	1772	return d.type >= QMetaType::User ? UserType : static_cast<Type>(d.type);
	1773	}
	1774
	1775	/*!
	1776	Returns the storage type of the value stored in the variant. For
	1777	non-user types, this is the same as type().
	1778
	1779	\sa type()
	1780	*/
	1781
	1782	int QVariant::userType() const
	1783	{
	1784	return d.type;
	1785	}
	1786
	1787	/*!
	1788	Assigns the value of the variant \a variant to this variant.
	1789	*/
	1790	QVariant& QVariant::operator=(const QVariant &variant)
	1791	{
	1792	if (this == &variant)
	1793	return *this;
	1794
	1795	clear();
	1796	if (variant.d.is_shared) {
	1797	variant.d.data.shared->ref.ref();
	1798	d = variant.d;
f5f89d3 by Olivier Goffart at 2009-08-21	1799	} else if (variant.d.type > Char && variant.d.type < UserType) {
8f427b2 by axis at 2009-04-24	1800	d.type = variant.d.type;
	1801	handler->construct(&d, variant.constData());
	1802	d.is_null = variant.d.is_null;
	1803	} else {
	1804	d = variant.d;
	1805	}
	1806
	1807	return *this;
	1808	}
	1809
	1810	/*!
86ea852 by Marc Mutz at 2010-11-03	1811	\fn void QVariant::swap(QVariant &other)
	1812	\since 4.8
	1813
	1814	Swaps variant \a other with this variant. This operation is very
	1815	fast and never fails.
	1816	*/
	1817
	1818	/*!
8f427b2 by axis at 2009-04-24	1819	\fn void QVariant::detach()
	1820
	1821	\internal
	1822	*/
	1823
	1824	void QVariant::detach()
	1825	{
	1826	if (!d.is_shared \|\| d.data.shared->ref == 1)
	1827	return;
	1828
	1829	Private dd;
	1830	dd.type = d.type;
	1831	handler->construct(&dd, constData());
	1832	if (!d.data.shared->ref.deref())
	1833	handler->clear(&d);
	1834	d.data.shared = dd.data.shared;
	1835	}
	1836
	1837	/*!
	1838	\fn bool QVariant::isDetached() const
	1839
	1840	\internal
	1841	*/
	1842
	1843	// ### Qt 5: change typeName()(and froends= to return a QString. Suggestion from Harald.
	1844	/*!
	1845	Returns the name of the type stored in the variant. The returned
	1846	strings describe the C++ datatype used to store the data: for
	1847	example, "QFont", "QString", or "QVariantList". An Invalid
	1848	variant returns 0.
	1849	*/
	1850	const char *QVariant::typeName() const
	1851	{
	1852	return typeToName(Type(d.type));
	1853	}
	1854
	1855	/*!
	1856	Convert this variant to type Invalid and free up any resources
	1857	used.
	1858	*/
	1859	void QVariant::clear()
	1860	{
f5f89d3 by Olivier Goffart at 2009-08-21	1861	if ((d.is_shared && !d.data.shared->ref.deref()) \|\| (!d.is_shared && d.type < UserType && d.type > Char))
8f427b2 by axis at 2009-04-24	1862	handler->clear(&d);
	1863	d.type = Invalid;
	1864	d.is_null = true;
	1865	d.is_shared = false;
	1866	}
	1867
	1868	/*!
	1869	Converts the enum representation of the storage type, \a typ, to
	1870	its string representation.
	1871
	1872	Returns a null pointer if the type is QVariant::Invalid or doesn't exist.
	1873	*/
	1874	const char *QVariant::typeToName(Type typ)
	1875	{
	1876	if (typ == Invalid)
	1877	return 0;
	1878	if (typ == UserType)
	1879	return "UserType";
	1880
	1881	return QMetaType::typeName(typ);
	1882	}
	1883
	1884
	1885	/*!
	1886	Converts the string representation of the storage type given in \a
	1887	name, to its enum representation.
	1888
	1889	If the string representation cannot be converted to any enum
	1890	representation, the variant is set to \c Invalid.
	1891	*/
	1892	QVariant::Type QVariant::nameToType(const char *name)
	1893	{
	1894	if (!name \|\| !*name)
	1895	return Invalid;
	1896	if (strcmp(name, "Q3CString") == 0)
	1897	return ByteArray;
	1898	if (strcmp(name, "Q_LLONG") == 0)
	1899	return LongLong;
	1900	if (strcmp(name, "Q_ULLONG") == 0)
	1901	return ULongLong;
	1902	if (strcmp(name, "QIconSet") == 0)
	1903	return Icon;
	1904	if (strcmp(name, "UserType") == 0)
	1905	return UserType;
	1906
	1907	int metaType = QMetaType::type(name);
	1908	return metaType <= int(LastGuiType) ? QVariant::Type(metaType) : UserType;
	1909	}
	1910
	1911	#ifndef QT_NO_DATASTREAM
ab2497c by Leonardo Sobral Cunha at 2010-02-23	1912	enum { MapFromThreeCount = 36 };
5039d39 by Thierry Bastian at 2009-06-09	1913	static const ushort map_from_three[MapFromThreeCount] =
8f427b2 by axis at 2009-04-24	1914	{
	1915	QVariant::Invalid,
	1916	QVariant::Map,
	1917	QVariant::List,
	1918	QVariant::String,
	1919	QVariant::StringList,
	1920	QVariant::Font,
	1921	QVariant::Pixmap,
	1922	QVariant::Brush,
	1923	QVariant::Rect,
	1924	QVariant::Size,
	1925	QVariant::Color,
	1926	QVariant::Palette,
	1927	63, // ColorGroup
	1928	QVariant::Icon,
	1929	QVariant::Point,
	1930	QVariant::Image,
	1931	QVariant::Int,
	1932	QVariant::UInt,
	1933	QVariant::Bool,
	1934	QVariant::Double,
	1935	QVariant::ByteArray,
	1936	QVariant::Polygon,
	1937	QVariant::Region,
	1938	QVariant::Bitmap,
	1939	QVariant::Cursor,
	1940	QVariant::SizePolicy,
	1941	QVariant::Date,
	1942	QVariant::Time,
	1943	QVariant::DateTime,
	1944	QVariant::ByteArray,
	1945	QVariant::BitArray,
	1946	QVariant::KeySequence,
	1947	QVariant::Pen,
	1948	QVariant::LongLong,
e1abb8b by Leonardo Sobral Cunha at 2010-02-26	1949	QVariant::ULongLong,
	1950	QVariant::EasingCurve
8f427b2 by axis at 2009-04-24	1951	};
	1952
	1953	/*!
	1954	Internal function for loading a variant from stream \a s. Use the
	1955	stream operators instead.
	1956
	1957	\internal
	1958	*/
	1959	void QVariant::load(QDataStream &s)
	1960	{
	1961	clear();
	1962
	1963	quint32 u;
	1964	s >> u;
	1965	if (s.version() < QDataStream::Qt_4_0) {
	1966	if (u >= MapFromThreeCount)
	1967	return;
	1968	u = map_from_three[u];
	1969	}
	1970	qint8 is_null = false;
	1971	if (s.version() >= QDataStream::Qt_4_2)
	1972	s >> is_null;
	1973	if (u == QVariant::UserType) {
	1974	QByteArray name;
	1975	s >> name;
	1976	u = QMetaType::type(name);
	1977	if (!u) {
	1978	s.setStatus(QDataStream::ReadCorruptData);
	1979	return;
	1980	}
	1981	}
	1982	create(static_cast<int>(u), 0);
	1983	d.is_null = is_null;
	1984
32182d1 by Thierry Bastian at 2009-07-13	1985	if (!isValid()) {
8f427b2 by axis at 2009-04-24	1986	// Since we wrote something, we should read something
	1987	QString x;
	1988	s >> x;
	1989	d.is_null = true;
	1990	return;
	1991	}
	1992
	1993	// const cast is safe since we operate on a newly constructed variant
262ce9e by Thierry Bastian at 2009-03-26	1994	if (!QMetaType::load(s, d.type, const_cast<void *>(constData()))) {
8f427b2 by axis at 2009-04-24	1995	s.setStatus(QDataStream::ReadCorruptData);
	1996	qWarning("QVariant::load: unable to load type %d.", d.type);
	1997	}
	1998	}
	1999
	2000	/*!
	2001	Internal function for saving a variant to the stream \a s. Use the
	2002	stream operators instead.
	2003
	2004	\internal
	2005	*/
	2006	void QVariant::save(QDataStream &s) const
	2007	{
	2008	quint32 tp = type();
	2009	if (s.version() < QDataStream::Qt_4_0) {
	2010	int i;
	2011	for (i = MapFromThreeCount - 1; i >= 0; i--) {
	2012	if (map_from_three[i] == tp) {
	2013	tp = i;
	2014	break;
	2015	}
	2016	}
	2017	if (i == -1) {
	2018	s << QVariant();
	2019	return;
	2020	}
	2021	}
	2022	s << tp;
	2023	if (s.version() >= QDataStream::Qt_4_2)
	2024	s << qint8(d.is_null);
	2025	if (tp == QVariant::UserType) {
	2026	s << QMetaType::typeName(userType());
	2027	}
	2028
32182d1 by Thierry Bastian at 2009-07-13	2029	if (!isValid()) {
8f427b2 by axis at 2009-04-24	2030	s << QString();
	2031	return;
	2032	}
	2033
262ce9e by Thierry Bastian at 2009-03-26	2034	if (!QMetaType::save(s, d.type, constData())) {
8f427b2 by axis at 2009-04-24	2035	Q_ASSERT_X(false, "QVariant::save", "Invalid type to save");
	2036	qWarning("QVariant::save: unable to save type %d.", d.type);
	2037	}
	2038	}
	2039
	2040	/*!
	2041	\since 4.4
	2042
	2043	Reads a variant \a p from the stream \a s.
	2044
	2045	\sa \link datastreamformat.html Format of the QDataStream
	2046	operators \endlink
	2047	*/
	2048	QDataStream& operator>>(QDataStream &s, QVariant &p)
	2049	{
	2050	p.load(s);
	2051	return s;
	2052	}
	2053
	2054	/*!
	2055	Writes a variant \a p to the stream \a s.
	2056
	2057	\sa \link datastreamformat.html Format of the QDataStream
	2058	operators \endlink
	2059	*/
	2060	QDataStream& operator<<(QDataStream &s, const QVariant &p)
	2061	{
	2062	p.save(s);
	2063	return s;
	2064	}
	2065
	2066	/*!
	2067	Reads a variant type \a p in enum representation from the stream \a s.
	2068	*/
	2069	QDataStream& operator>>(QDataStream &s, QVariant::Type &p)
	2070	{
	2071	quint32 u;
	2072	s >> u;
	2073	p = (QVariant::Type)u;
	2074
	2075	return s;
	2076	}
	2077
	2078	/*!
	2079	Writes a variant type \a p to the stream \a s.
	2080	*/
	2081	QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
	2082	{
	2083	s << static_cast<quint32>(p);
	2084
	2085	return s;
	2086	}
	2087
	2088	#endif //QT_NO_DATASTREAM
	2089
	2090	/*!
	2091	\fn bool QVariant::isValid() const
	2092
	2093	Returns true if the storage type of this variant is not
	2094	QVariant::Invalid; otherwise returns false.
	2095	*/
	2096
	2097	template <typename T>
	2098	inline T qVariantToHelper(const QVariant::Private &d, QVariant::Type t,
	2099	const QVariant::Handler handler, T = 0)
	2100	{
	2101	if (d.type == t)
	2102	return *v_cast<T>(&d);
	2103
	2104	T ret;
	2105	handler->convert(&d, t, &ret, 0);
	2106	return ret;
	2107	}
	2108
	2109	/*!
	2110	\fn QStringList QVariant::toStringList() const
	2111
	2112	Returns the variant as a QStringList if the variant has type()
	2113	StringList, \l String, or \l List of a type that can be converted
	2114	to QString; otherwise returns an empty list.
	2115
	2116	\sa canConvert(), convert()
	2117	*/
	2118	QStringList QVariant::toStringList() const
	2119	{
	2120	return qVariantToHelper<QStringList>(d, StringList, handler);
	2121	}
	2122
	2123	/*!
	2124	Returns the variant as a QString if the variant has type() \l
	2125	String, \l Bool, \l ByteArray, \l Char, \l Date, \l DateTime, \l
	2126	Double, \l Int, \l LongLong, \l StringList, \l Time, \l UInt, or
	2127	\l ULongLong; otherwise returns an empty string.
	2128
	2129	\sa canConvert(), convert()
	2130	*/
	2131	QString QVariant::toString() const
	2132	{
	2133	return qVariantToHelper<QString>(d, String, handler);
	2134	}
	2135
	2136	/*!
	2137	Returns the variant as a QMap<QString, QVariant> if the variant
	2138	has type() \l Map; otherwise returns an empty map.
	2139
	2140	\sa canConvert(), convert()
	2141	*/
	2142	QVariantMap QVariant::toMap() const
	2143	{
	2144	return qVariantToHelper<QVariantMap>(d, Map, handler);
	2145	}
	2146
	2147	/*!
	2148	Returns the variant as a QHash<QString, QVariant> if the variant
	2149	has type() \l Hash; otherwise returns an empty map.
	2150
	2151	\sa canConvert(), convert()
	2152	*/
	2153	QVariantHash QVariant::toHash() const
	2154	{
	2155	return qVariantToHelper<QVariantHash>(d, Hash, handler);
	2156	}
	2157
	2158	/*!
	2159	\fn QDate QVariant::toDate() const
	2160
	2161	Returns the variant as a QDate if the variant has type() \l Date,
	2162	\l DateTime, or \l String; otherwise returns an invalid date.
	2163
	2164	If the type() is \l String, an invalid date will be returned if the
	2165	string cannot be parsed as a Qt::ISODate format date.
	2166
	2167	\sa canConvert(), convert()
	2168	*/
	2169	QDate QVariant::toDate() const
	2170	{
	2171	return qVariantToHelper<QDate>(d, Date, handler);
	2172	}
	2173
	2174	/*!
	2175	\fn QTime QVariant::toTime() const
	2176
	2177	Returns the variant as a QTime if the variant has type() \l Time,
	2178	\l DateTime, or \l String; otherwise returns an invalid time.
	2179
	2180	If the type() is \l String, an invalid time will be returned if
	2181	the string cannot be parsed as a Qt::ISODate format time.
	2182
	2183	\sa canConvert(), convert()
	2184	*/
	2185	QTime QVariant::toTime() const
	2186	{
	2187	return qVariantToHelper<QTime>(d, Time, handler);
	2188	}
	2189
	2190	/*!
	2191	\fn QDateTime QVariant::toDateTime() const
	2192
	2193	Returns the variant as a QDateTime if the variant has type() \l
	2194	DateTime, \l Date, or \l String; otherwise returns an invalid
	2195	date/time.
	2196
	2197	If the type() is \l String, an invalid date/time will be returned
	2198	if the string cannot be parsed as a Qt::ISODate format date/time.
	2199
	2200	\sa canConvert(), convert()
	2201	*/
	2202	QDateTime QVariant::toDateTime() const
	2203	{
	2204	return qVariantToHelper<QDateTime>(d, DateTime, handler);
	2205	}
	2206
	2207	/*!
00e358a by Volker Hilsheimer at 2010-03-08	2208	\since 4.7
ab2497c by Leonardo Sobral Cunha at 2010-02-23	2209	\fn QEasingCurve QVariant::toEasingCurve() const
	2210
	2211	Returns the variant as a QEasingCurve if the variant has type() \l
	2212	EasingCurve; otherwise returns a default easing curve.
	2213
	2214	\sa canConvert(), convert()
	2215	*/
	2216	#ifndef QT_BOOTSTRAPPED
	2217	QEasingCurve QVariant::toEasingCurve() const
	2218	{
	2219	return qVariantToHelper<QEasingCurve>(d, EasingCurve, handler);
	2220	}
	2221	#endif
	2222
	2223	/*!
8f427b2 by axis at 2009-04-24	2224	\fn QByteArray QVariant::toByteArray() const
	2225
	2226	Returns the variant as a QByteArray if the variant has type() \l
	2227	ByteArray or \l String (converted using QString::fromAscii());
	2228	otherwise returns an empty byte array.
	2229
	2230	\sa canConvert(), convert()
	2231	*/
	2232	QByteArray QVariant::toByteArray() const
	2233	{
	2234	return qVariantToHelper<QByteArray>(d, ByteArray, handler);
	2235	}
	2236
	2237	#ifndef QT_NO_GEOM_VARIANT
	2238	/*!
	2239	\fn QPoint QVariant::toPoint() const
	2240
	2241	Returns the variant as a QPoint if the variant has type()
	2242	\l Point or \l PointF; otherwise returns a null QPoint.
	2243
	2244	\sa canConvert(), convert()
	2245	*/
	2246	QPoint QVariant::toPoint() const
	2247	{
	2248	return qVariantToHelper<QPoint>(d, Point, handler);
	2249	}
	2250
	2251	/*!
	2252	\fn QRect QVariant::toRect() const
	2253
	2254	Returns the variant as a QRect if the variant has type() \l Rect;
	2255	otherwise returns an invalid QRect.
	2256
	2257	\sa canConvert(), convert()
	2258	*/
	2259	QRect QVariant::toRect() const
	2260	{
	2261	return qVariantToHelper<QRect>(d, Rect, handler);
	2262	}
	2263
	2264	/*!
	2265	\fn QSize QVariant::toSize() const
	2266
	2267	Returns the variant as a QSize if the variant has type() \l Size;
	2268	otherwise returns an invalid QSize.
	2269
	2270	\sa canConvert(), convert()
	2271	*/
	2272	QSize QVariant::toSize() const
	2273	{
	2274	return qVariantToHelper<QSize>(d, Size, handler);
	2275	}
	2276
	2277	/*!
	2278	\fn QSizeF QVariant::toSizeF() const
	2279
	2280	Returns the variant as a QSizeF if the variant has type() \l
	2281	SizeF; otherwise returns an invalid QSizeF.
	2282
	2283	\sa canConvert(), convert()
	2284	*/
	2285	QSizeF QVariant::toSizeF() const
	2286	{
	2287	return qVariantToHelper<QSizeF>(d, SizeF, handler);
	2288	}
	2289
	2290	/*!
	2291	\fn QRectF QVariant::toRectF() const
	2292
	2293	Returns the variant as a QRectF if the variant has type() \l Rect
	2294	or \l RectF; otherwise returns an invalid QRectF.
	2295
	2296	\sa canConvert(), convert()
	2297	*/
	2298	QRectF QVariant::toRectF() const
	2299	{
	2300	return qVariantToHelper<QRectF>(d, RectF, handler);
	2301	}
	2302
	2303	/*!
	2304	\fn QLineF QVariant::toLineF() const
	2305
	2306	Returns the variant as a QLineF if the variant has type() \l
	2307	LineF; otherwise returns an invalid QLineF.
	2308
	2309	\sa canConvert(), convert()
	2310	*/
	2311	QLineF QVariant::toLineF() const
	2312	{
	2313	return qVariantToHelper<QLineF>(d, LineF, handler);
	2314	}
	2315
	2316	/*!
	2317	\fn QLine QVariant::toLine() const
	2318
	2319	Returns the variant as a QLine if the variant has type() \l Line;
	2320	otherwise returns an invalid QLine.
	2321
	2322	\sa canConvert(), convert()
	2323	*/
	2324	QLine QVariant::toLine() const
	2325	{
	2326	return qVariantToHelper<QLine>(d, Line, handler);
	2327	}
	2328
	2329	/*!
	2330	\fn QPointF QVariant::toPointF() const
	2331
	2332	Returns the variant as a QPointF if the variant has type() \l
	2333	Point or \l PointF; otherwise returns a null QPointF.
	2334
	2335	\sa canConvert(), convert()
	2336	*/
	2337	QPointF QVariant::toPointF() const
	2338	{
	2339	return qVariantToHelper<QPointF>(d, PointF, handler);
	2340	}
	2341
	2342	#endif // QT_NO_GEOM_VARIANT
	2343
	2344	/*!
	2345	\fn QUrl QVariant::toUrl() const
	2346
	2347	Returns the variant as a QUrl if the variant has type()
	2348	\l Url; otherwise returns an invalid QUrl.
	2349
	2350	\sa canConvert(), convert()
	2351	*/
	2352	QUrl QVariant::toUrl() const
	2353	{
	2354	return qVariantToHelper<QUrl>(d, Url, handler);
	2355	}
	2356
	2357	/*!
	2358	\fn QLocale QVariant::toLocale() const
	2359
	2360	Returns the variant as a QLocale if the variant has type()
	2361	\l Locale; otherwise returns an invalid QLocale.
	2362
	2363	\sa canConvert(), convert()
	2364	*/
	2365	QLocale QVariant::toLocale() const
	2366	{
	2367	return qVariantToHelper<QLocale>(d, Locale, handler);
	2368	}
	2369
	2370	/*!
	2371	\fn QRegExp QVariant::toRegExp() const
	2372	\since 4.1
	2373
	2374	Returns the variant as a QRegExp if the variant has type() \l
	2375	RegExp; otherwise returns an empty QRegExp.
	2376
	2377	\sa canConvert(), convert()
	2378	*/
	2379	#ifndef QT_NO_REGEXP
	2380	QRegExp QVariant::toRegExp() const
	2381	{
	2382	return qVariantToHelper<QRegExp>(d, RegExp, handler);
	2383	}
	2384	#endif
	2385
	2386	/*!
	2387	\fn QChar QVariant::toChar() const
	2388
	2389	Returns the variant as a QChar if the variant has type() \l Char,
	2390	\l Int, or \l UInt; otherwise returns an invalid QChar.
	2391
	2392	\sa canConvert(), convert()
	2393	*/
	2394	QChar QVariant::toChar() const
	2395	{
	2396	return qVariantToHelper<QChar>(d, Char, handler);
	2397	}
	2398
	2399	/*!
	2400	Returns the variant as a QBitArray if the variant has type()
	2401	\l BitArray; otherwise returns an empty bit array.
	2402
	2403	\sa canConvert(), convert()
	2404	*/
	2405	QBitArray QVariant::toBitArray() const
	2406	{
	2407	return qVariantToHelper<QBitArray>(d, BitArray, handler);
	2408	}
	2409
	2410	template <typename T>
b770651 by Thierry Bastian at 2009-08-14	2411	inline T qNumVariantToHelper(const QVariant::Private &d,
8f427b2 by axis at 2009-04-24	2412	const QVariant::Handler handler, bool ok, const T& val)
	2413	{
b770651 by Thierry Bastian at 2009-08-14	2414	uint t = qMetaTypeId<T>();
8f427b2 by axis at 2009-04-24	2415	if (ok)
	2416	*ok = true;
	2417	if (d.type == t)
	2418	return val;
	2419
	2420	T ret;
b770651 by Thierry Bastian at 2009-08-14	2421	if (!handler->convert(&d, QVariant::Type(t), &ret, ok) && ok)
8f427b2 by axis at 2009-04-24	2422	*ok = false;
	2423	return ret;
	2424	}
	2425
	2426	/*!
	2427	Returns the variant as an int if the variant has type() \l Int,
	2428	\l Bool, \l ByteArray, \l Char, \l Double, \l LongLong, \l
	2429	String, \l UInt, or \l ULongLong; otherwise returns 0.
	2430
	2431	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2432	converted to an int; otherwise \c{*}\a{ok} is set to false.
	2433
	2434	\bold{Warning:} If the value is convertible to a \l LongLong but is too
	2435	large to be represented in an int, the resulting arithmetic overflow will
	2436	not be reflected in \a ok. A simple workaround is to use QString::toInt().
	2437	Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code.
	2438
	2439	\sa canConvert(), convert()
	2440	*/
	2441	int QVariant::toInt(bool *ok) const
	2442	{
b770651 by Thierry Bastian at 2009-08-14	2443	return qNumVariantToHelper<int>(d, handler, ok, d.data.i);
8f427b2 by axis at 2009-04-24	2444	}
	2445
	2446	/*!
	2447	Returns the variant as an unsigned int if the variant has type()
	2448	\l UInt, \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l
	2449	LongLong, \l String, or \l ULongLong; otherwise returns 0.
	2450
	2451	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2452	converted to an unsigned int; otherwise \c{*}\a{ok} is set to false.
	2453
	2454	\bold{Warning:} If the value is convertible to a \l ULongLong but is too
	2455	large to be represented in an unsigned int, the resulting arithmetic overflow will
	2456	not be reflected in \a ok. A simple workaround is to use QString::toUInt().
	2457	Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code.
	2458
	2459	\sa canConvert(), convert()
	2460	*/
	2461	uint QVariant::toUInt(bool *ok) const
	2462	{
b770651 by Thierry Bastian at 2009-08-14	2463	return qNumVariantToHelper<uint>(d, handler, ok, d.data.u);
8f427b2 by axis at 2009-04-24	2464	}
	2465
	2466	/*!
	2467	Returns the variant as a long long int if the variant has type()
	2468	\l LongLong, \l Bool, \l ByteArray, \l Char, \l Double, \l Int,
	2469	\l String, \l UInt, or \l ULongLong; otherwise returns 0.
	2470
	2471	If \a ok is non-null: \c{*}\c{ok} is set to true if the value could be
	2472	converted to an int; otherwise \c{*}\c{ok} is set to false.
	2473
	2474	\sa canConvert(), convert()
	2475	*/
	2476	qlonglong QVariant::toLongLong(bool *ok) const
	2477	{
b770651 by Thierry Bastian at 2009-08-14	2478	return qNumVariantToHelper<qlonglong>(d, handler, ok, d.data.ll);
8f427b2 by axis at 2009-04-24	2479	}
	2480
	2481	/*!
	2482	Returns the variant as as an unsigned long long int if the
	2483	variant has type() \l ULongLong, \l Bool, \l ByteArray, \l Char,
	2484	\l Double, \l Int, \l LongLong, \l String, or \l UInt; otherwise
	2485	returns 0.
	2486
	2487	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2488	converted to an int; otherwise \c{*}\a{ok} is set to false.
	2489
	2490	\sa canConvert(), convert()
	2491	*/
	2492	qulonglong QVariant::toULongLong(bool *ok) const
	2493	{
b770651 by Thierry Bastian at 2009-08-14	2494	return qNumVariantToHelper<qulonglong>(d, handler, ok, d.data.ull);
8f427b2 by axis at 2009-04-24	2495	}
	2496
	2497	/*!
	2498	Returns the variant as a bool if the variant has type() Bool.
	2499
	2500	Returns true if the variant has type() \l Bool, \l Char, \l Double,
	2501	\l Int, \l LongLong, \l UInt, or \l ULongLong and the value is
	2502	non-zero, or if the variant has type \l String or \l ByteArray and
	2503	its lower-case content is not empty, "0" or "false"; otherwise
	2504	returns false.
	2505
	2506	\sa canConvert(), convert()
	2507	*/
	2508	bool QVariant::toBool() const
	2509	{
	2510	if (d.type == Bool)
	2511	return d.data.b;
	2512
	2513	bool res = false;
	2514	handler->convert(&d, Bool, &res, 0);
	2515
	2516	return res;
	2517	}
	2518
	2519	/*!
	2520	Returns the variant as a double if the variant has type() \l
b770651 by Thierry Bastian at 2009-08-14	2521	Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
8f427b2 by axis at 2009-04-24	2522	UInt, or \l ULongLong; otherwise returns 0.0.
	2523
	2524	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2525	converted to a double; otherwise \c{*}\a{ok} is set to false.
	2526
	2527	\sa canConvert(), convert()
	2528	*/
	2529	double QVariant::toDouble(bool *ok) const
	2530	{
b770651 by Thierry Bastian at 2009-08-14	2531	return qNumVariantToHelper<double>(d, handler, ok, d.data.d);
	2532	}
	2533
	2534	/*!
	2535	Returns the variant as a float if the variant has type() \l
	2536	Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
	2537	UInt, or \l ULongLong; otherwise returns 0.0.
	2538
	2539	\since 4.6
	2540
	2541	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2542	converted to a double; otherwise \c{*}\a{ok} is set to false.
	2543
	2544	\sa canConvert(), convert()
	2545	*/
	2546	float QVariant::toFloat(bool *ok) const
	2547	{
264eb34 by Olivier Goffart at 2009-08-20	2548	return qNumVariantToHelper<float>(d, handler, ok, d.data.f);
b770651 by Thierry Bastian at 2009-08-14	2549	}
	2550
	2551	/*!
	2552	Returns the variant as a qreal if the variant has type() \l
	2553	Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l
	2554	UInt, or \l ULongLong; otherwise returns 0.0.
	2555
	2556	\since 4.6
	2557
	2558	If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be
	2559	converted to a double; otherwise \c{*}\a{ok} is set to false.
	2560
	2561	\sa canConvert(), convert()
	2562	*/
	2563	qreal QVariant::toReal(bool *ok) const
	2564	{
264eb34 by Olivier Goffart at 2009-08-20	2565	return qNumVariantToHelper<qreal>(d, handler, ok, d.data.real);
8f427b2 by axis at 2009-04-24	2566	}
	2567
	2568	/*!
	2569	Returns the variant as a QVariantList if the variant has type()
	2570	\l List or \l StringList; otherwise returns an empty list.
	2571
	2572	\sa canConvert(), convert()
	2573	*/
	2574	QVariantList QVariant::toList() const
	2575	{
	2576	return qVariantToHelper<QVariantList>(d, List, handler);
	2577	}
	2578
	2579	/*! \fn QVariant::canCast(Type t) const
	2580	Use canConvert() instead.
	2581	*/
	2582
	2583	/*! \fn QVariant::cast(Type t)
	2584	Use convert() instead.
	2585	*/
	2586
	2587
	2588	static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
	2589	{
	2590	/Invalid/ 0,
	2591
	2592	/Bool/ 1 << QVariant::Double \| 1 << QVariant::Int \| 1 << QVariant::UInt
	2593	\| 1 << QVariant::LongLong \| 1 << QVariant::ULongLong \| 1 << QVariant::ByteArray
	2594	\| 1 << QVariant::String \| 1 << QVariant::Char,
	2595
	2596	/Int/ 1 << QVariant::UInt \| 1 << QVariant::String \| 1 << QVariant::Double
	2597	\| 1 << QVariant::Bool \| 1 << QVariant::LongLong \| 1 << QVariant::ULongLong
	2598	\| 1 << QVariant::Char \| 1 << QVariant::ByteArray,
	2599
	2600	/UInt/ 1 << QVariant::Int \| 1 << QVariant::String \| 1 << QVariant::Double
	2601	\| 1 << QVariant::Bool \| 1 << QVariant::LongLong \| 1 << QVariant::ULongLong
	2602	\| 1 << QVariant::Char \| 1 << QVariant::ByteArray,
	2603
	2604	/LLong/ 1 << QVariant::Int \| 1 << QVariant::String \| 1 << QVariant::Double
	2605	\| 1 << QVariant::Bool \| 1 << QVariant::UInt \| 1 << QVariant::ULongLong
	2606	\| 1 << QVariant::Char \| 1 << QVariant::ByteArray,
	2607
	2608	/ULlong/ 1 << QVariant::Int \| 1 << QVariant::String \| 1 << QVariant::Double
	2609	\| 1 << QVariant::Bool \| 1 << QVariant::UInt \| 1 << QVariant::LongLong
	2610	\| 1 << QVariant::Char \| 1 << QVariant::ByteArray,
	2611
	2612	/double/ 1 << QVariant::Int \| 1 << QVariant::String \| 1 << QVariant::ULongLong
	2613	\| 1 << QVariant::Bool \| 1 << QVariant::UInt \| 1 << QVariant::LongLong
	2614	\| 1 << QVariant::ByteArray,
	2615
	2616	/QChar/ 1 << QVariant::Int \| 1 << QVariant::UInt \| 1 << QVariant::LongLong
	2617	\| 1 << QVariant::ULongLong,
	2618
	2619	/QMap/ 0,
	2620
	2621	/QList/ 1 << QVariant::StringList,
	2622
	2623	/QString/ 1 << QVariant::StringList \| 1 << QVariant::ByteArray \| 1 << QVariant::Int
	2624	\| 1 << QVariant::UInt \| 1 << QVariant::Bool \| 1 << QVariant::Double
	2625	\| 1 << QVariant::Date \| 1 << QVariant::Time \| 1 << QVariant::DateTime
060727e by Thierry Bastian at 2009-06-10	2626	\| 1 << QVariant::LongLong \| 1 << QVariant::ULongLong \| 1 << QVariant::Char
	2627	\| 1 << QVariant::Url,
8f427b2 by axis at 2009-04-24	2628
	2629	/QStringList/ 1 << QVariant::List \| 1 << QVariant::String,
	2630
	2631	/QByteArray/ 1 << QVariant::String \| 1 << QVariant::Int \| 1 << QVariant::UInt \| 1 << QVariant::Bool
	2632	\| 1 << QVariant::Double \| 1 << QVariant::LongLong \| 1 << QVariant::ULongLong,
	2633
	2634	/QBitArray/ 0,
	2635
	2636	/QDate/ 1 << QVariant::String \| 1 << QVariant::DateTime,
	2637
	2638	/QTime/ 1 << QVariant::String \| 1 << QVariant::DateTime,
	2639
	2640	/QDateTime/ 1 << QVariant::String \| 1 << QVariant::Date,
	2641
060727e by Thierry Bastian at 2009-06-10	2642	/QUrl/ 1 << QVariant::String,
8f427b2 by axis at 2009-04-24	2643
	2644	/QLocale/ 0,
	2645
	2646	/QRect/ 1 << QVariant::RectF,
	2647
	2648	/QRectF/ 1 << QVariant::Rect,
	2649
	2650	/QSize/ 1 << QVariant::SizeF,
	2651
	2652	/QSizeF/ 1 << QVariant::Size,
	2653
	2654	/QLine/ 1 << QVariant::LineF,
	2655
	2656	/QLineF/ 1 << QVariant::Line,
	2657
	2658	/QPoint/ 1 << QVariant::PointF,
	2659
	2660	/QPointF/ 1 << QVariant::Point,
	2661
	2662	/QRegExp/ 0,
	2663
ab2497c by Leonardo Sobral Cunha at 2010-02-23	2664	/QHash/ 0,
8f427b2 by axis at 2009-04-24	2665
ab2497c by Leonardo Sobral Cunha at 2010-02-23	2666	/QEasingCurve/ 0
8f427b2 by axis at 2009-04-24	2667	};
	2668
	2669	/*!
	2670	Returns true if the variant's type can be cast to the requested
	2671	type, \a t. Such casting is done automatically when calling the
	2672	toInt(), toBool(), ... methods.
	2673
	2674	The following casts are done automatically:
	2675
	2676	\table
	2677	\header \o Type \o Automatically Cast To
	2678	\row \o \l Bool \o \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
	2679	\row \o \l ByteArray \o \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
	2680	\row \o \l Char \o \l Bool, \l Int, \l UInt, \l LongLong, \l ULongLong
	2681	\row \o \l Color \o \l String
	2682	\row \o \l Date \o \l DateTime, \l String
	2683	\row \o \l DateTime \o \l Date, \l String, \l Time
	2684	\row \o \l Double \o \l Bool, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong
	2685	\row \o \l Font \o \l String
	2686	\row \o \l Int \o \l Bool, \l Char, \l Double, \l LongLong, \l String, \l UInt, \l ULongLong
	2687	\row \o \l KeySequence \o \l Int, \l String
	2688	\row \o \l List \o \l StringList (if the list's items can be converted to strings)
	2689	\row \o \l LongLong \o \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l String, \l UInt, \l ULongLong
	2690	\row \o \l Point \o PointF
	2691	\row \o \l Rect \o RectF
	2692	\row \o \l String \o \l Bool, \l ByteArray, \l Char, \l Color, \l Date, \l DateTime, \l Double,
	2693	\l Font, \l Int, \l KeySequence, \l LongLong, \l StringList, \l Time, \l UInt,
	2694	\l ULongLong
	2695	\row \o \l StringList \o \l List, \l String (if the list contains exactly one item)
	2696	\row \o \l Time \o \l String
	2697	\row \o \l UInt \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l ULongLong
	2698	\row \o \l ULongLong \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt
	2699	\endtable
	2700
	2701	\sa convert()
	2702	*/
	2703	bool QVariant::canConvert(Type t) const
	2704	{
728a7c2 by Thierry Bastian at 2009-04-27	2705	//we can treat floats as double
99d3a9c by Thierry Bastian at 2009-04-28	2706	//the reason for not doing it the "proper" way is that QMetaType::Float's value is 135,
728a7c2 by Thierry Bastian at 2009-04-27	2707	//which can't be handled by qCanConvertMatrix
99d3a9c by Thierry Bastian at 2009-04-28	2708	//In addition QVariant::Type doesn't have a Float value, so we're using QMetaType::Float
728a7c2 by Thierry Bastian at 2009-04-27	2709	const uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type);
99d3a9c by Thierry Bastian at 2009-04-28	2710	if (uint(t) == uint(QMetaType::Float)) t = QVariant::Double;
728a7c2 by Thierry Bastian at 2009-04-27	2711
	2712	if (currentType == uint(t))
8f427b2 by axis at 2009-04-24	2713	return true;
	2714
728a7c2 by Thierry Bastian at 2009-04-27	2715	if (currentType > QVariant::LastCoreType \|\| t > QVariant::LastCoreType) {
8f427b2 by axis at 2009-04-24	2716	switch (uint(t)) {
	2717	case QVariant::Int:
728a7c2 by Thierry Bastian at 2009-04-27	2718	return currentType == QVariant::KeySequence
	2719	\|\| currentType == QMetaType::ULong
	2720	\|\| currentType == QMetaType::Long
	2721	\|\| currentType == QMetaType::UShort
	2722	\|\| currentType == QMetaType::UChar
	2723	\|\| currentType == QMetaType::Char
	2724	\|\| currentType == QMetaType::Short;
8f427b2 by axis at 2009-04-24	2725	case QVariant::Image:
728a7c2 by Thierry Bastian at 2009-04-27	2726	return currentType == QVariant::Pixmap \|\| currentType == QVariant::Bitmap;
8f427b2 by axis at 2009-04-24	2727	case QVariant::Pixmap:
728a7c2 by Thierry Bastian at 2009-04-27	2728	return currentType == QVariant::Image \|\| currentType == QVariant::Bitmap
	2729	\|\| currentType == QVariant::Brush;
8f427b2 by axis at 2009-04-24	2730	case QVariant::Bitmap:
728a7c2 by Thierry Bastian at 2009-04-27	2731	return currentType == QVariant::Pixmap \|\| currentType == QVariant::Image;
8f427b2 by axis at 2009-04-24	2732	case QVariant::ByteArray:
728a7c2 by Thierry Bastian at 2009-04-27	2733	return currentType == QVariant::Color;
8f427b2 by axis at 2009-04-24	2734	case QVariant::String:
728a7c2 by Thierry Bastian at 2009-04-27	2735	return currentType == QVariant::KeySequence \|\| currentType == QVariant::Font
	2736	\|\| currentType == QVariant::Color;
8f427b2 by axis at 2009-04-24	2737	case QVariant::KeySequence:
728a7c2 by Thierry Bastian at 2009-04-27	2738	return currentType == QVariant::String \|\| currentType == QVariant::Int;
8f427b2 by axis at 2009-04-24	2739	case QVariant::Font:
728a7c2 by Thierry Bastian at 2009-04-27	2740	return currentType == QVariant::String;
8f427b2 by axis at 2009-04-24	2741	case QVariant::Color:
728a7c2 by Thierry Bastian at 2009-04-27	2742	return currentType == QVariant::String \|\| currentType == QVariant::ByteArray
	2743	\|\| currentType == QVariant::Brush;
8f427b2 by axis at 2009-04-24	2744	case QVariant::Brush:
728a7c2 by Thierry Bastian at 2009-04-27	2745	return currentType == QVariant::Color \|\| currentType == QVariant::Pixmap;
8f427b2 by axis at 2009-04-24	2746	case QMetaType::Long:
	2747	case QMetaType::Char:
	2748	case QMetaType::UChar:
	2749	case QMetaType::ULong:
	2750	case QMetaType::Short:
	2751	case QMetaType::UShort:
728a7c2 by Thierry Bastian at 2009-04-27	2752	return qCanConvertMatrix[QVariant::Int] & (1 << currentType) \|\| currentType == QVariant::Int;
8f427b2 by axis at 2009-04-24	2753	default:
	2754	return false;
	2755	}
	2756	}
	2757
728a7c2 by Thierry Bastian at 2009-04-27	2758	if(t == String && currentType == StringList)
8f427b2 by axis at 2009-04-24	2759	return v_cast<QStringList>(&d)->count() == 1;
	2760	else
728a7c2 by Thierry Bastian at 2009-04-27	2761	return qCanConvertMatrix[t] & (1 << currentType);
8f427b2 by axis at 2009-04-24	2762	}
	2763
	2764	/*!
	2765	Casts the variant to the requested type, \a t. If the cast cannot be
	2766	done, the variant is cleared. Returns true if the current type of
	2767	the variant was successfully cast; otherwise returns false.
	2768
	2769	\warning For historical reasons, converting a null QVariant results
	2770	in a null value of the desired type (e.g., an empty string for
	2771	QString) and a result of false.
	2772
	2773	\sa canConvert(), clear()
	2774	*/
	2775
	2776	bool QVariant::convert(Type t)
	2777	{
	2778	if (d.type == uint(t))
	2779	return true;
	2780
	2781	QVariant oldValue = *this;
	2782
	2783	clear();
	2784	if (!oldValue.canConvert(t))
	2785	return false;
	2786
	2787	create(t, 0);
	2788	if (oldValue.isNull())
	2789	return false;
	2790
	2791	bool isOk = true;
	2792	if (!handler->convert(&oldValue.d, t, data(), &isOk))
	2793	isOk = false;
	2794	d.is_null = !isOk;
	2795	return isOk;
	2796	}
	2797
	2798	/*!
	2799	\fn bool operator==(const QVariant &v1, const QVariant &v2)
	2800
	2801	\relates QVariant
	2802
	2803	Returns true if \a v1 and \a v2 are equal; otherwise returns false.
	2804
	2805	\warning This function doesn't support custom types registered
	2806	with qRegisterMetaType().
	2807	*/
	2808	/*!
	2809	\fn bool operator!=(const QVariant &v1, const QVariant &v2)
	2810
	2811	\relates QVariant
	2812
	2813	Returns false if \a v1 and \a v2 are equal; otherwise returns true.
	2814
	2815	\warning This function doesn't support custom types registered
	2816	with qRegisterMetaType().
	2817	*/
	2818
	2819	/*! \fn bool QVariant::operator==(const QVariant &v) const
	2820
	2821	Compares this QVariant with \a v and returns true if they are
	2822	equal; otherwise returns false.
	2823
	2824	In the case of custom types, their equalness operators are not called.
	2825	Instead the values' addresses are compared.
	2826	*/
	2827
	2828	/*!
	2829	\fn bool QVariant::operator!=(const QVariant &v) const
	2830
	2831	Compares this QVariant with \a v and returns true if they are not
	2832	equal; otherwise returns false.
	2833
	2834	\warning This function doesn't support custom types registered
	2835	with qRegisterMetaType().
	2836	*/
	2837
	2838	static bool qIsNumericType(uint tp)
	2839	{
	2840	return (tp >= QVariant::Bool && tp <= QVariant::Double)
	2841	\|\| (tp >= QMetaType::Long && tp <= QMetaType::Float);
	2842	}
	2843
	2844	static bool qIsFloatingPoint(uint tp)
	2845	{
	2846	return tp == QVariant::Double \|\| tp == QMetaType::Float;
	2847	}
	2848
	2849	/*! \internal
	2850	*/
	2851	bool QVariant::cmp(const QVariant &v) const
	2852	{
	2853	QVariant v2 = v;
	2854	if (d.type != v2.d.type) {
	2855	if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) {
	2856	if (qIsFloatingPoint(d.type) \|\| qIsFloatingPoint(v.d.type))
dc2771e by Thierry Bastian at 2009-08-17	2857	return qFuzzyCompare(toReal(), v.toReal());
8f427b2 by axis at 2009-04-24	2858	else
	2859	return toLongLong() == v.toLongLong();
	2860	}
	2861	if (!v2.canConvert(Type(d.type)) \|\| !v2.convert(Type(d.type)))
	2862	return false;
	2863	}
	2864	return handler->compare(&d, &v2.d);
	2865	}
	2866
	2867	/*! \internal
	2868	*/
	2869
	2870	const void *QVariant::constData() const
	2871	{
262ce9e by Thierry Bastian at 2009-03-26	2872	return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
8f427b2 by axis at 2009-04-24	2873	}
	2874
	2875	/*!
	2876	\fn const void* QVariant::data() const
	2877
	2878	\internal
	2879	*/
	2880
	2881	/! \internal /
	2882	void* QVariant::data()
	2883	{
	2884	detach();
262ce9e by Thierry Bastian at 2009-03-26	2885	return const_cast<void *>(constData());
8f427b2 by axis at 2009-04-24	2886	}
	2887
	2888
	2889	#ifdef QT3_SUPPORT
	2890	/*! \internal
	2891	*/
	2892	void *QVariant::castOrDetach(Type t)
	2893	{
	2894	if (d.type != uint(t)) {
	2895	if (!convert(t))
	2896	create(t, 0);
	2897	} else {
	2898	detach();
	2899	}
	2900	return data();
	2901	}
	2902	#endif
	2903
	2904	/*!
	2905	Returns true if this is a NULL variant, false otherwise.
	2906	*/
	2907	bool QVariant::isNull() const
	2908	{
	2909	return handler->isNull(&d);
	2910	}
	2911
	2912	#ifndef QT_NO_DEBUG_STREAM
	2913	QDebug operator<<(QDebug dbg, const QVariant &v)
	2914	{
	2915	#ifndef Q_BROKEN_DEBUG_STREAM
	2916	dbg.nospace() << "QVariant(" << v.typeName() << ", ";
	2917	QVariant::handler->debugStream(dbg, v);
	2918	dbg.nospace() << ')';
	2919	return dbg.space();
	2920	#else
	2921	qWarning("This compiler doesn't support streaming QVariant to QDebug");
	2922	return dbg;
	2923	Q_UNUSED(v);
	2924	#endif
	2925	}
	2926
	2927	QDebug operator<<(QDebug dbg, const QVariant::Type p)
	2928	{
	2929	#ifndef Q_BROKEN_DEBUG_STREAM
	2930	dbg.nospace() << "QVariant::" << QVariant::typeToName(p);
	2931	return dbg.space();
	2932	#else
	2933	qWarning("This compiler doesn't support streaming QVariant::Type to QDebug");
	2934	return dbg;
	2935	Q_UNUSED(p);
	2936	#endif
	2937	}
	2938	#endif
	2939
	2940	/*!
	2941	\fn int &QVariant::asInt()
	2942
	2943	Use toInt() instead.
	2944	*/
	2945
	2946	/*!
	2947	\fn uint &QVariant::asUInt()
	2948
	2949	Use toUInt() instead.
	2950	*/
	2951
	2952	/*!
	2953	\fn qlonglong &QVariant::asLongLong()
	2954
	2955	Use toLongLong() instead.
	2956	*/
	2957
	2958	/*!
	2959	\fn qulonglong &QVariant::asULongLong()
	2960
	2961	Use toULongLong() instead.
	2962	*/
	2963
	2964	/*!
	2965	\fn bool &QVariant::asBool()
	2966
	2967	Use toBool() instead.
	2968	*/
	2969
	2970	/*!
	2971	\fn double &QVariant::asDouble()
	2972
	2973	Use toDouble() instead.
	2974	*/
	2975
	2976	/*!
	2977	\fn QByteArray &QVariant::asByteArray()
	2978
	2979	Use toByteArray() instead.
	2980	*/
	2981
	2982	/*!
	2983	\fn QBitArray &QVariant::asBitArray()
	2984
	2985	Use toBitArray() instead.
	2986	*/
	2987
	2988	/*!
	2989	\fn QString &QVariant::asString()
	2990
	2991	Use toString() instead.
	2992	*/
	2993
	2994	/*!
	2995	\fn QStringList &QVariant::asStringList()
	2996
	2997	Use toStringList() instead.
	2998	*/
	2999
	3000	/*!
	3001	\fn QDate &QVariant::asDate()
	3002
	3003	Use toDate() instead.
	3004	*/
	3005
	3006	/*!
	3007	\fn QTime &QVariant::asTime()
	3008
	3009	Use toTime() instead.
	3010	*/
	3011
	3012	/*!
	3013	\fn QDateTime &QVariant::asDateTime()
	3014
	3015	Use toDateTime() instead.
	3016	*/
	3017
	3018	/*!
	3019	\fn QList<QVariant> &QVariant::asList()
	3020
	3021	Use toList() instead.
	3022	*/
	3023
	3024	/*!
	3025	\fn QMap<QString, QVariant> &QVariant::asMap()
	3026
	3027	Use toMap() instead.
	3028	*/
	3029
	3030	/*!
	3031	\fn QVariant::QVariant(bool b, int dummy)
	3032
	3033	Use the QVariant(bool) constructor instead.
	3034
	3035	*/
	3036
	3037	/*!
	3038	\fn const QByteArray QVariant::toCString() const
	3039
	3040	Use toByteArray() instead.
	3041	*/
	3042
	3043	/*!
	3044	\fn QByteArray &QVariant::asCString()
	3045
	3046	Use toByteArray() instead.
	3047	*/
	3048
	3049	/*!
	3050	\fn QPoint &QVariant::asPoint()
	3051
	3052	Use toPoint() instead.
	3053	*/
	3054
	3055	/*!
	3056	\fn QRect &QVariant::asRect()
	3057
	3058	Use toRect() instead.
	3059	*/
	3060
	3061	/*!
	3062	\fn QSize &QVariant::asSize()
	3063
	3064	Use toSize() instead.
	3065	*/
	3066
	3067	/*! \fn void QVariant::setValue(const T &value)
	3068
	3069	Stores a copy of \a value. If \c{T} is a type that QVariant
	3070	doesn't support, QMetaType is used to store the value. A compile
	3071	error will occur if QMetaType doesn't handle the type.
	3072
	3073	Example:
	3074
	3075	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 4
	3076
	3077	\sa value(), fromValue(), canConvert()
	3078	*/
	3079
	3080	/*! \fn T QVariant::value() const
	3081
	3082	Returns the stored value converted to the template type \c{T}.
	3083	Call canConvert() to find out whether a type can be converted.
	3084	If the value cannot be converted, \l{default-constructed value}
	3085	will be returned.
	3086
	3087	If the type \c{T} is supported by QVariant, this function behaves
	3088	exactly as toString(), toInt() etc.
	3089
	3090	Example:
	3091
	3092	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 5
	3093
	3094	\sa setValue(), fromValue(), canConvert()
	3095	*/
	3096
	3097	/*! \fn bool QVariant::canConvert() const
	3098
	3099	Returns true if the variant can be converted to the template type \c{T},
	3100	otherwise false.
	3101
	3102	Example:
	3103
	3104	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 6
	3105
	3106	\sa convert()
	3107	*/
	3108
	3109	/*! \fn static QVariant QVariant::fromValue(const T &value)
	3110
	3111	Returns a QVariant containing a copy of \a value. Behaves
	3112	exactly like setValue() otherwise.
	3113
	3114	Example:
	3115
	3116	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 7
	3117
	3118	\note If you are working with custom types, you should use
	3119	the Q_DECLARE_METATYPE() macro to register your custom type.
	3120
	3121	\sa setValue(), value()
	3122	*/
	3123
	3124	/*!
	3125	\fn QVariant qVariantFromValue(const T &value)
	3126	\relates QVariant
7b5e37c by Olivier Goffart at 2010-08-06	3127	\obsolete
8f427b2 by axis at 2009-04-24	3128
	3129	Returns a variant containing a copy of the given \a value
	3130	with template type \c{T}.
	3131
b9328bd by miniak at 2010-08-03	3132	This function is equivalent to QVariant::fromValue(\a value).
	3133
	3134	\note This function was provided as a workaround for MSVC 6
	3135	which did not support member template functions. It is advised
	3136	to use the other form in new code.
8f427b2 by axis at 2009-04-24	3137
	3138	For example, a QObject pointer can be stored in a variant with the
	3139	following code:
	3140
	3141	\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 8
	3142
	3143	\sa QVariant::fromValue()
	3144	*/
	3145
	3146	/*! \fn void qVariantSetValue(QVariant &variant, const T &value)
	3147	\relates QVariant
7b5e37c by Olivier Goffart at 2010-08-06	3148	\obsolete
8f427b2 by axis at 2009-04-24	3149
	3150	Sets the contents of the given \a variant to a copy of the
	3151	\a value with the specified template type \c{T}.
	3152
b9328bd by miniak at 2010-08-03	3153	This function is equivalent to QVariant::setValue(\a value).
	3154
	3155	\note This function was provided as a workaround for MSVC 6
	3156	which did not support member template functions. It is advised
	3157	to use the other form in new code.
8f427b2 by axis at 2009-04-24	3158
	3159	\sa QVariant::setValue()
	3160	*/
	3161
	3162	/*!
	3163	\fn T qvariant_cast(const QVariant &value)
	3164	\relates QVariant
	3165
	3166	Returns the given \a value converted to the template type \c{T}.
	3167
7b5e37c by Olivier Goffart at 2010-08-06	3168	This function is equivalent to QVariant::value().
8f427b2 by axis at 2009-04-24	3169
7b5e37c by Olivier Goffart at 2010-08-06	3170	\sa QVariant::value()
8f427b2 by axis at 2009-04-24	3171	*/
	3172
	3173	/*! \fn T qVariantValue(const QVariant &value)
	3174	\relates QVariant
7b5e37c by Olivier Goffart at 2010-08-06	3175	\obsolete
8f427b2 by axis at 2009-04-24	3176
	3177	Returns the given \a value converted to the template type \c{T}.
	3178
	3179	This function is equivalent to
b9328bd by miniak at 2010-08-03	3180	\l{QVariant::value()}{QVariant::value}<T>(\a value).
	3181
	3182	\note This function was provided as a workaround for MSVC 6
	3183	which did not support member template functions. It is advised
	3184	to use the other form in new code.
8f427b2 by axis at 2009-04-24	3185
	3186	\sa QVariant::value(), qvariant_cast()
	3187	*/
	3188
	3189	/*! \fn bool qVariantCanConvert(const QVariant &value)
	3190	\relates QVariant
7b5e37c by Olivier Goffart at 2010-08-06	3191	\obsolete
8f427b2 by axis at 2009-04-24	3192
	3193	Returns true if the given \a value can be converted to the
	3194	template type specified; otherwise returns false.
	3195
b9328bd by miniak at 2010-08-03	3196	This function is equivalent to QVariant::canConvert(\a value).
	3197
	3198	\note This function was provided as a workaround for MSVC 6
	3199	which did not support member template functions. It is advised
	3200	to use the other form in new code.
8f427b2 by axis at 2009-04-24	3201
	3202	\sa QVariant::canConvert()
	3203	*/
	3204
	3205	/*!
	3206	\typedef QVariantList
	3207	\relates QVariant
	3208
	3209	Synonym for QList<QVariant>.
	3210	*/
	3211
	3212	/*!
	3213	\typedef QVariantMap
	3214	\relates QVariant
	3215
	3216	Synonym for QMap<QString, QVariant>.
	3217	*/
	3218
	3219	/*!
	3220	\typedef QVariantHash
	3221	\relates QVariant
	3222	\since 4.5
	3223
	3224	Synonym for QHash<QString, QVariant>.
	3225	*/
	3226
	3227	/*!
	3228	\typedef QVariant::DataPtr
	3229	\internal
	3230	*/
	3231
	3232	/*!
	3233	\fn DataPtr &QVariant::data_ptr()
	3234	\internal
	3235	*/
	3236
	3237	QT_END_NAMESPACE