/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtCore module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "qvariant.h" | |
#include "qbitarray.h" | |
#include "qbytearray.h" | |
#include "qdatastream.h" | |
#include "qdebug.h" | |
#include "qmap.h" | |
#include "qdatetime.h" | |
#include "qeasingcurve.h" | |
#include "qlist.h" | |
#include "qstring.h" | |
#include "qstringlist.h" | |
#include "qurl.h" | |
#include "qlocale.h" | |
#include "private/qvariant_p.h" | |
#ifndef QT_NO_GEOM_VARIANT | |
#include "qsize.h" | |
#include "qpoint.h" | |
#include "qrect.h" | |
#include "qline.h" | |
#endif | |
#include <float.h> | |
QT_BEGIN_NAMESPACE | |
#ifndef DBL_DIG | |
# define DBL_DIG 10 | |
#endif | |
#ifndef FLT_DIG | |
# define FLT_DIG 6 | |
#endif | |
static void construct(QVariant::Private *x, const void *copy) | |
{ | |
x->is_shared = false; | |
switch (x->type) { | |
case QVariant::String: | |
v_construct<QString>(x, copy); | |
break; | |
case QVariant::Char: | |
v_construct<QChar>(x, copy); | |
break; | |
case QVariant::StringList: | |
v_construct<QStringList>(x, copy); | |
break; | |
case QVariant::Map: | |
v_construct<QVariantMap>(x, copy); | |
break; | |
case QVariant::Hash: | |
v_construct<QVariantHash>(x, copy); | |
break; | |
case QVariant::List: | |
v_construct<QVariantList>(x, copy); | |
break; | |
case QVariant::Date: | |
v_construct<QDate>(x, copy); | |
break; | |
case QVariant::Time: | |
v_construct<QTime>(x, copy); | |
break; | |
case QVariant::DateTime: | |
v_construct<QDateTime>(x, copy); | |
break; | |
case QVariant::ByteArray: | |
v_construct<QByteArray>(x, copy); | |
break; | |
case QVariant::BitArray: | |
v_construct<QBitArray>(x, copy); | |
break; | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Size: | |
v_construct<QSize>(x, copy); | |
break; | |
case QVariant::SizeF: | |
v_construct<QSizeF>(x, copy); | |
break; | |
case QVariant::Rect: | |
v_construct<QRect>(x, copy); | |
break; | |
case QVariant::LineF: | |
v_construct<QLineF>(x, copy); | |
break; | |
case QVariant::Line: | |
v_construct<QLine>(x, copy); | |
break; | |
case QVariant::RectF: | |
v_construct<QRectF>(x, copy); | |
break; | |
case QVariant::Point: | |
v_construct<QPoint>(x, copy); | |
break; | |
case QVariant::PointF: | |
v_construct<QPointF>(x, copy); | |
break; | |
#endif | |
case QVariant::Url: | |
v_construct<QUrl>(x, copy); | |
break; | |
case QVariant::Locale: | |
v_construct<QLocale>(x, copy); | |
break; | |
#ifndef QT_NO_REGEXP | |
case QVariant::RegExp: | |
v_construct<QRegExp>(x, copy); | |
break; | |
#endif | |
#ifndef QT_BOOTSTRAPPED | |
case QVariant::EasingCurve: | |
v_construct<QEasingCurve>(x, copy); | |
break; | |
#endif | |
case QVariant::Int: | |
x->data.i = copy ? *static_cast<const int *>(copy) : 0; | |
break; | |
case QVariant::UInt: | |
x->data.u = copy ? *static_cast<const uint *>(copy) : 0u; | |
break; | |
case QVariant::Bool: | |
x->data.b = copy ? *static_cast<const bool *>(copy) : false; | |
break; | |
case QVariant::Double: | |
x->data.d = copy ? *static_cast<const double*>(copy) : 0.0; | |
break; | |
case QMetaType::Float: | |
x->data.f = copy ? *static_cast<const float*>(copy) : 0.0f; | |
break; | |
case QMetaType::QObjectStar: | |
x->data.o = copy ? *static_cast<QObject *const*>(copy) : 0; | |
break; | |
case QVariant::LongLong: | |
x->data.ll = copy ? *static_cast<const qlonglong *>(copy) : Q_INT64_C(0); | |
break; | |
case QVariant::ULongLong: | |
x->data.ull = copy ? *static_cast<const qulonglong *>(copy) : Q_UINT64_C(0); | |
break; | |
case QVariant::Invalid: | |
case QVariant::UserType: | |
break; | |
default: | |
void *ptr = QMetaType::construct(x->type, copy); | |
if (!ptr) { | |
x->type = QVariant::Invalid; | |
} else { | |
x->is_shared = true; | |
x->data.shared = new QVariant::PrivateShared(ptr); | |
} | |
break; | |
} | |
x->is_null = !copy; | |
} | |
static void clear(QVariant::Private *d) | |
{ | |
switch (d->type) { | |
case QVariant::String: | |
v_clear<QString>(d); | |
break; | |
case QVariant::Char: | |
v_clear<QChar>(d); | |
break; | |
case QVariant::StringList: | |
v_clear<QStringList>(d); | |
break; | |
case QVariant::Map: | |
v_clear<QVariantMap>(d); | |
break; | |
case QVariant::Hash: | |
v_clear<QVariantHash>(d); | |
break; | |
case QVariant::List: | |
v_clear<QVariantList>(d); | |
break; | |
case QVariant::Date: | |
v_clear<QDate>(d); | |
break; | |
case QVariant::Time: | |
v_clear<QTime>(d); | |
break; | |
case QVariant::DateTime: | |
v_clear<QDateTime>(d); | |
break; | |
case QVariant::ByteArray: | |
v_clear<QByteArray>(d); | |
break; | |
case QVariant::BitArray: | |
v_clear<QBitArray>(d); | |
break; | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Point: | |
v_clear<QPoint>(d); | |
break; | |
case QVariant::PointF: | |
v_clear<QPointF>(d); | |
break; | |
case QVariant::Size: | |
v_clear<QSize>(d); | |
break; | |
case QVariant::SizeF: | |
v_clear<QSizeF>(d); | |
break; | |
case QVariant::Rect: | |
v_clear<QRect>(d); | |
break; | |
case QVariant::LineF: | |
v_clear<QLineF>(d); | |
break; | |
case QVariant::Line: | |
v_clear<QLine>(d); | |
break; | |
case QVariant::RectF: | |
v_clear<QRectF>(d); | |
break; | |
#endif | |
case QVariant::Url: | |
v_clear<QUrl>(d); | |
break; | |
case QVariant::Locale: | |
v_clear<QLocale>(d); | |
break; | |
#ifndef QT_NO_REGEXP | |
case QVariant::RegExp: | |
v_clear<QRegExp>(d); | |
break; | |
#endif | |
#ifndef QT_BOOTSTRAPPED | |
case QVariant::EasingCurve: | |
v_clear<QEasingCurve>(d); | |
break; | |
#endif | |
case QVariant::LongLong: | |
case QVariant::ULongLong: | |
case QVariant::Double: | |
case QMetaType::Float: | |
case QMetaType::QObjectStar: | |
break; | |
case QVariant::Invalid: | |
case QVariant::UserType: | |
case QVariant::Int: | |
case QVariant::UInt: | |
case QVariant::Bool: | |
break; | |
default: | |
QMetaType::destroy(d->type, d->data.shared->ptr); | |
delete d->data.shared; | |
break; | |
} | |
d->type = QVariant::Invalid; | |
d->is_null = true; | |
d->is_shared = false; | |
} | |
static bool isNull(const QVariant::Private *d) | |
{ | |
switch(d->type) { | |
case QVariant::String: | |
return v_cast<QString>(d)->isNull(); | |
case QVariant::Char: | |
return v_cast<QChar>(d)->isNull(); | |
case QVariant::Date: | |
return v_cast<QDate>(d)->isNull(); | |
case QVariant::Time: | |
return v_cast<QTime>(d)->isNull(); | |
case QVariant::DateTime: | |
return v_cast<QDateTime>(d)->isNull(); | |
case QVariant::ByteArray: | |
return v_cast<QByteArray>(d)->isNull(); | |
case QVariant::BitArray: | |
return v_cast<QBitArray>(d)->isNull(); | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Size: | |
return v_cast<QSize>(d)->isNull(); | |
case QVariant::SizeF: | |
return v_cast<QSizeF>(d)->isNull(); | |
case QVariant::Rect: | |
return v_cast<QRect>(d)->isNull(); | |
case QVariant::Line: | |
return v_cast<QLine>(d)->isNull(); | |
case QVariant::LineF: | |
return v_cast<QLineF>(d)->isNull(); | |
case QVariant::RectF: | |
return v_cast<QRectF>(d)->isNull(); | |
case QVariant::Point: | |
return v_cast<QPoint>(d)->isNull(); | |
case QVariant::PointF: | |
return v_cast<QPointF>(d)->isNull(); | |
#endif | |
#ifndef QT_BOOTSTRAPPED | |
case QVariant::EasingCurve: | |
#endif | |
case QVariant::Url: | |
case QVariant::Locale: | |
case QVariant::RegExp: | |
case QVariant::StringList: | |
case QVariant::Map: | |
case QVariant::Hash: | |
case QVariant::List: | |
case QVariant::Invalid: | |
case QVariant::UserType: | |
case QVariant::Int: | |
case QVariant::UInt: | |
case QVariant::LongLong: | |
case QVariant::ULongLong: | |
case QVariant::Bool: | |
case QVariant::Double: | |
case QMetaType::Float: | |
case QMetaType::QObjectStar: | |
break; | |
} | |
return d->is_null; | |
} | |
/* | |
\internal | |
\since 4.4 | |
We cannot use v_cast() for QMetaType's numeric types because they're smaller than QVariant::Private::Data, | |
which in turns makes v_cast() believe the value is stored in d->data.c. But | |
it's not, since we're a QMetaType type. | |
*/ | |
template<typename T> | |
inline bool compareNumericMetaType(const QVariant::Private *const a, const QVariant::Private *const b) | |
{ | |
return *static_cast<const T *>(a->data.shared->ptr) == *static_cast<const T *>(b->data.shared->ptr); | |
} | |
/*! | |
\internal | |
Compares \a a to \a b. The caller guarantees that \a a and \a b | |
are of the same type. | |
*/ | |
static bool compare(const QVariant::Private *a, const QVariant::Private *b) | |
{ | |
switch(a->type) { | |
case QVariant::List: | |
return *v_cast<QVariantList>(a) == *v_cast<QVariantList>(b); | |
case QVariant::Map: { | |
const QVariantMap *m1 = v_cast<QVariantMap>(a); | |
const QVariantMap *m2 = v_cast<QVariantMap>(b); | |
if (m1->count() != m2->count()) | |
return false; | |
QVariantMap::ConstIterator it = m1->constBegin(); | |
QVariantMap::ConstIterator it2 = m2->constBegin(); | |
while (it != m1->constEnd()) { | |
if (*it != *it2 || it.key() != it2.key()) | |
return false; | |
++it; | |
++it2; | |
} | |
return true; | |
} | |
case QVariant::Hash: | |
return *v_cast<QVariantHash>(a) == *v_cast<QVariantHash>(b); | |
case QVariant::String: | |
return *v_cast<QString>(a) == *v_cast<QString>(b); | |
case QVariant::Char: | |
return *v_cast<QChar>(a) == *v_cast<QChar>(b); | |
case QVariant::StringList: | |
return *v_cast<QStringList>(a) == *v_cast<QStringList>(b); | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Size: | |
return *v_cast<QSize>(a) == *v_cast<QSize>(b); | |
case QVariant::SizeF: | |
return *v_cast<QSizeF>(a) == *v_cast<QSizeF>(b); | |
case QVariant::Rect: | |
return *v_cast<QRect>(a) == *v_cast<QRect>(b); | |
case QVariant::Line: | |
return *v_cast<QLine>(a) == *v_cast<QLine>(b); | |
case QVariant::LineF: | |
return *v_cast<QLineF>(a) == *v_cast<QLineF>(b); | |
case QVariant::RectF: | |
return *v_cast<QRectF>(a) == *v_cast<QRectF>(b); | |
case QVariant::Point: | |
return *v_cast<QPoint>(a) == *v_cast<QPoint>(b); | |
case QVariant::PointF: | |
return *v_cast<QPointF>(a) == *v_cast<QPointF>(b); | |
#endif | |
case QVariant::Url: | |
return *v_cast<QUrl>(a) == *v_cast<QUrl>(b); | |
case QVariant::Locale: | |
return *v_cast<QLocale>(a) == *v_cast<QLocale>(b); | |
#ifndef QT_NO_REGEXP | |
case QVariant::RegExp: | |
return *v_cast<QRegExp>(a) == *v_cast<QRegExp>(b); | |
#endif | |
case QVariant::Int: | |
return a->data.i == b->data.i; | |
case QVariant::UInt: | |
return a->data.u == b->data.u; | |
case QVariant::LongLong: | |
return a->data.ll == b->data.ll; | |
case QVariant::ULongLong: | |
return a->data.ull == b->data.ull; | |
case QVariant::Bool: | |
return a->data.b == b->data.b; | |
case QVariant::Double: | |
return a->data.d == b->data.d; | |
case QMetaType::Float: | |
return a->data.f == b->data.f; | |
case QMetaType::QObjectStar: | |
return a->data.o == b->data.o; | |
case QVariant::Date: | |
return *v_cast<QDate>(a) == *v_cast<QDate>(b); | |
case QVariant::Time: | |
return *v_cast<QTime>(a) == *v_cast<QTime>(b); | |
case QVariant::DateTime: | |
return *v_cast<QDateTime>(a) == *v_cast<QDateTime>(b); | |
#ifndef QT_BOOTSTRAPPED | |
case QVariant::EasingCurve: | |
return *v_cast<QEasingCurve>(a) == *v_cast<QEasingCurve>(b); | |
#endif | |
case QVariant::ByteArray: | |
return *v_cast<QByteArray>(a) == *v_cast<QByteArray>(b); | |
case QVariant::BitArray: | |
return *v_cast<QBitArray>(a) == *v_cast<QBitArray>(b); | |
case QVariant::Invalid: | |
return true; | |
case QMetaType::Long: | |
return compareNumericMetaType<long>(a, b); | |
case QMetaType::ULong: | |
return compareNumericMetaType<ulong>(a, b); | |
case QMetaType::Short: | |
return compareNumericMetaType<short>(a, b); | |
case QMetaType::UShort: | |
return compareNumericMetaType<ushort>(a, b); | |
case QMetaType::UChar: | |
return compareNumericMetaType<uchar>(a, b); | |
case QMetaType::Char: | |
return compareNumericMetaType<char>(a, b); | |
default: | |
break; | |
} | |
if (!QMetaType::isRegistered(a->type)) | |
qFatal("QVariant::compare: type %d unknown to QVariant.", a->type); | |
const void *a_ptr = a->is_shared ? a->data.shared->ptr : &(a->data.ptr); | |
const void *b_ptr = b->is_shared ? b->data.shared->ptr : &(b->data.ptr); | |
/* The reason we cannot place this test in a case branch above for the types | |
* QMetaType::VoidStar, QMetaType::QObjectStar and so forth, is that it wouldn't include | |
* user defined pointer types. */ | |
const char *const typeName = QMetaType::typeName(a->type); | |
uint typeNameLen = qstrlen(typeName); | |
if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*') | |
return *static_cast<void *const *>(a_ptr) == *static_cast<void *const *>(b_ptr); | |
if (a->is_null && b->is_null) | |
return true; | |
return a_ptr == b_ptr; | |
} | |
/*! | |
\internal | |
*/ | |
static qlonglong qMetaTypeNumber(const QVariant::Private *d) | |
{ | |
switch (d->type) { | |
case QMetaType::Int: | |
return d->data.i; | |
case QMetaType::LongLong: | |
return d->data.ll; | |
case QMetaType::Char: | |
return qlonglong(*static_cast<signed char *>(d->data.shared->ptr)); | |
case QMetaType::Short: | |
return qlonglong(*static_cast<short *>(d->data.shared->ptr)); | |
case QMetaType::Long: | |
return qlonglong(*static_cast<long *>(d->data.shared->ptr)); | |
case QMetaType::Float: | |
return qRound64(d->data.f); | |
case QVariant::Double: | |
return qRound64(d->data.d); | |
} | |
Q_ASSERT(false); | |
return 0; | |
} | |
static qulonglong qMetaTypeUNumber(const QVariant::Private *d) | |
{ | |
switch (d->type) { | |
case QVariant::UInt: | |
return d->data.u; | |
case QVariant::ULongLong: | |
return d->data.ull; | |
case QMetaType::UChar: | |
return qulonglong(*static_cast<unsigned char *>(d->data.shared->ptr)); | |
case QMetaType::UShort: | |
return qulonglong(*static_cast<ushort *>(d->data.shared->ptr)); | |
case QMetaType::ULong: | |
return qulonglong(*static_cast<ulong *>(d->data.shared->ptr)); | |
} | |
Q_ASSERT(false); | |
return 0; | |
} | |
static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) | |
{ | |
*ok = true; | |
switch (uint(d->type)) { | |
case QVariant::String: | |
return v_cast<QString>(d)->toLongLong(ok); | |
case QVariant::Char: | |
return v_cast<QChar>(d)->unicode(); | |
case QVariant::ByteArray: | |
return v_cast<QByteArray>(d)->toLongLong(ok); | |
case QVariant::Bool: | |
return qlonglong(d->data.b); | |
case QVariant::Double: | |
case QVariant::Int: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
case QMetaType::Float: | |
case QMetaType::LongLong: | |
return qMetaTypeNumber(d); | |
case QVariant::ULongLong: | |
case QVariant::UInt: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
return qlonglong(qMetaTypeUNumber(d)); | |
} | |
*ok = false; | |
return Q_INT64_C(0); | |
} | |
static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) | |
{ | |
*ok = true; | |
switch (uint(d->type)) { | |
case QVariant::String: | |
return v_cast<QString>(d)->toULongLong(ok); | |
case QVariant::Char: | |
return v_cast<QChar>(d)->unicode(); | |
case QVariant::ByteArray: | |
return v_cast<QByteArray>(d)->toULongLong(ok); | |
case QVariant::Bool: | |
return qulonglong(d->data.b); | |
case QVariant::Double: | |
case QVariant::Int: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
case QMetaType::Float: | |
case QMetaType::LongLong: | |
return qulonglong(qMetaTypeNumber(d)); | |
case QVariant::ULongLong: | |
case QVariant::UInt: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
return qMetaTypeUNumber(d); | |
} | |
*ok = false; | |
return Q_UINT64_C(0); | |
} | |
template<typename TInput, typename LiteralWrapper> | |
inline bool qt_convertToBool(const QVariant::Private *const d) | |
{ | |
TInput str = v_cast<TInput>(d)->toLower(); | |
return !(str == LiteralWrapper("0") || str == LiteralWrapper("false") || str.isEmpty()); | |
} | |
/*! | |
\internal | |
Converts \a d to type \a t, which is placed in \a result. | |
*/ | |
static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, bool *ok) | |
{ | |
Q_ASSERT(d->type != uint(t)); | |
Q_ASSERT(result); | |
bool dummy; | |
if (!ok) | |
ok = &dummy; | |
switch (uint(t)) { | |
case QVariant::Url: | |
switch (d->type) { | |
case QVariant::String: | |
*static_cast<QUrl *>(result) = QUrl(*v_cast<QString>(d)); | |
break; | |
default: | |
return false; | |
} | |
break; | |
case QVariant::String: { | |
QString *str = static_cast<QString *>(result); | |
switch (d->type) { | |
case QVariant::Char: | |
*str = QString(*v_cast<QChar>(d)); | |
break; | |
case QMetaType::Char: | |
case QMetaType::UChar: | |
*str = QChar::fromAscii(*static_cast<char *>(d->data.shared->ptr)); | |
break; | |
case QMetaType::Short: | |
case QMetaType::Long: | |
case QVariant::Int: | |
case QVariant::LongLong: | |
*str = QString::number(qMetaTypeNumber(d)); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
*str = QString::number(qMetaTypeUNumber(d)); | |
break; | |
case QMetaType::Float: | |
*str = QString::number(d->data.f, 'g', FLT_DIG); | |
break; | |
case QVariant::Double: | |
*str = QString::number(d->data.d, 'g', DBL_DIG); | |
break; | |
#if !defined(QT_NO_DATESTRING) | |
case QVariant::Date: | |
*str = v_cast<QDate>(d)->toString(Qt::ISODate); | |
break; | |
case QVariant::Time: | |
*str = v_cast<QTime>(d)->toString(Qt::ISODate); | |
break; | |
case QVariant::DateTime: | |
*str = v_cast<QDateTime>(d)->toString(Qt::ISODate); | |
break; | |
#endif | |
case QVariant::Bool: | |
*str = QLatin1String(d->data.b ? "true" : "false"); | |
break; | |
case QVariant::ByteArray: | |
*str = QString::fromAscii(v_cast<QByteArray>(d)->constData()); | |
break; | |
case QVariant::StringList: | |
if (v_cast<QStringList>(d)->count() == 1) | |
*str = v_cast<QStringList>(d)->at(0); | |
break; | |
case QVariant::Url: | |
*str = v_cast<QUrl>(d)->toString(); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
case QVariant::Char: { | |
QChar *c = static_cast<QChar *>(result); | |
switch (d->type) { | |
case QVariant::Int: | |
case QVariant::LongLong: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
case QMetaType::Float: | |
*c = QChar(ushort(qMetaTypeNumber(d))); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
*c = QChar(ushort(qMetaTypeUNumber(d))); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Size: { | |
QSize *s = static_cast<QSize *>(result); | |
switch (d->type) { | |
case QVariant::SizeF: | |
*s = v_cast<QSizeF>(d)->toSize(); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
case QVariant::SizeF: { | |
QSizeF *s = static_cast<QSizeF *>(result); | |
switch (d->type) { | |
case QVariant::Size: | |
*s = QSizeF(*(v_cast<QSize>(d))); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
case QVariant::Line: { | |
QLine *s = static_cast<QLine *>(result); | |
switch (d->type) { | |
case QVariant::LineF: | |
*s = v_cast<QLineF>(d)->toLine(); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
case QVariant::LineF: { | |
QLineF *s = static_cast<QLineF *>(result); | |
switch (d->type) { | |
case QVariant::Line: | |
*s = QLineF(*(v_cast<QLine>(d))); | |
break; | |
default: | |
return false; | |
} | |
break; | |
} | |
#endif | |
case QVariant::StringList: | |
if (d->type == QVariant::List) { | |
QStringList *slst = static_cast<QStringList *>(result); | |
const QVariantList *list = v_cast<QVariantList >(d); | |
for (int i = 0; i < list->size(); ++i) | |
slst->append(list->at(i).toString()); | |
} else if (d->type == QVariant::String) { | |
QStringList *slst = static_cast<QStringList *>(result); | |
*slst = QStringList(*v_cast<QString>(d)); | |
} else { | |
return false; | |
} | |
break; | |
case QVariant::Date: { | |
QDate *dt = static_cast<QDate *>(result); | |
if (d->type == QVariant::DateTime) | |
*dt = v_cast<QDateTime>(d)->date(); | |
#ifndef QT_NO_DATESTRING | |
else if (d->type == QVariant::String) | |
*dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate); | |
#endif | |
else | |
return false; | |
return dt->isValid(); | |
} | |
case QVariant::Time: { | |
QTime *t = static_cast<QTime *>(result); | |
switch (d->type) { | |
case QVariant::DateTime: | |
*t = v_cast<QDateTime>(d)->time(); | |
break; | |
#ifndef QT_NO_DATESTRING | |
case QVariant::String: | |
*t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate); | |
break; | |
#endif | |
default: | |
return false; | |
} | |
return t->isValid(); | |
} | |
case QVariant::DateTime: { | |
QDateTime *dt = static_cast<QDateTime *>(result); | |
switch (d->type) { | |
#ifndef QT_NO_DATESTRING | |
case QVariant::String: | |
*dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate); | |
break; | |
#endif | |
case QVariant::Date: | |
*dt = QDateTime(*v_cast<QDate>(d)); | |
break; | |
default: | |
return false; | |
} | |
return dt->isValid(); | |
} | |
case QVariant::ByteArray: { | |
QByteArray *ba = static_cast<QByteArray *>(result); | |
switch (d->type) { | |
case QVariant::String: | |
*ba = v_cast<QString>(d)->toAscii(); | |
break; | |
case QVariant::Double: | |
*ba = QByteArray::number(d->data.d, 'g', DBL_DIG); | |
break; | |
case QMetaType::Float: | |
*ba = QByteArray::number(d->data.f, 'g', FLT_DIG); | |
break; | |
case QMetaType::Char: | |
case QMetaType::UChar: | |
*ba = QByteArray(1, *static_cast<char *>(d->data.shared->ptr)); | |
break; | |
case QVariant::Int: | |
case QVariant::LongLong: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
*ba = QByteArray::number(qMetaTypeNumber(d)); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
*ba = QByteArray::number(qMetaTypeUNumber(d)); | |
break; | |
case QVariant::Bool: | |
*ba = QByteArray(d->data.b ? "true" : "false"); | |
break; | |
default: | |
return false; | |
} | |
} | |
break; | |
case QMetaType::Short: | |
*static_cast<short *>(result) = short(qConvertToNumber(d, ok)); | |
return *ok; | |
case QMetaType::Long: | |
*static_cast<long *>(result) = long(qConvertToNumber(d, ok)); | |
return *ok; | |
case QMetaType::UShort: | |
*static_cast<ushort *>(result) = ushort(qConvertToUnsignedNumber(d, ok)); | |
return *ok; | |
case QMetaType::ULong: | |
*static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok)); | |
return *ok; | |
case QVariant::Int: | |
*static_cast<int *>(result) = int(qConvertToNumber(d, ok)); | |
return *ok; | |
case QVariant::UInt: | |
*static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok)); | |
return *ok; | |
case QVariant::LongLong: | |
*static_cast<qlonglong *>(result) = qConvertToNumber(d, ok); | |
return *ok; | |
case QVariant::ULongLong: { | |
*static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok); | |
return *ok; | |
} | |
case QMetaType::UChar: { | |
*static_cast<uchar *>(result) = qConvertToUnsignedNumber(d, ok); | |
return *ok; | |
} | |
case QVariant::Bool: { | |
bool *b = static_cast<bool *>(result); | |
switch(d->type) { | |
case QVariant::ByteArray: | |
*b = qt_convertToBool<QByteArray, QByteArray>(d); | |
break; | |
case QVariant::String: | |
*b = qt_convertToBool<QString, QLatin1String>(d); | |
break; | |
case QVariant::Char: | |
*b = !v_cast<QChar>(d)->isNull(); | |
break; | |
case QVariant::Double: | |
case QVariant::Int: | |
case QVariant::LongLong: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
case QMetaType::Float: | |
*b = qMetaTypeNumber(d) != Q_INT64_C(0); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
*b = qMetaTypeUNumber(d) != Q_UINT64_C(0); | |
break; | |
default: | |
*b = false; | |
return false; | |
} | |
break; | |
} | |
case QVariant::Double: { | |
double *f = static_cast<double *>(result); | |
switch (d->type) { | |
case QVariant::String: | |
*f = v_cast<QString>(d)->toDouble(ok); | |
break; | |
case QVariant::ByteArray: | |
*f = v_cast<QByteArray>(d)->toDouble(ok); | |
break; | |
case QVariant::Bool: | |
*f = double(d->data.b); | |
break; | |
case QMetaType::Float: | |
*f = double(d->data.f); | |
break; | |
case QVariant::LongLong: | |
case QVariant::Int: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
*f = double(qMetaTypeNumber(d)); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
#if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET) | |
*f = (double)(qlonglong)qMetaTypeUNumber(d); | |
#else | |
*f = double(qMetaTypeUNumber(d)); | |
#endif | |
break; | |
default: | |
*f = 0.0; | |
return false; | |
} | |
break; | |
} | |
case QMetaType::Float: { | |
float *f = static_cast<float *>(result); | |
switch (d->type) { | |
case QVariant::String: | |
*f = v_cast<QString>(d)->toFloat(ok); | |
break; | |
case QVariant::ByteArray: | |
*f = v_cast<QByteArray>(d)->toFloat(ok); | |
break; | |
case QVariant::Bool: | |
*f = float(d->data.b); | |
break; | |
case QVariant::Double: | |
*f = float(d->data.d); | |
break; | |
case QVariant::LongLong: | |
case QVariant::Int: | |
case QMetaType::Char: | |
case QMetaType::Short: | |
case QMetaType::Long: | |
*f = float(qMetaTypeNumber(d)); | |
break; | |
case QVariant::UInt: | |
case QVariant::ULongLong: | |
case QMetaType::UChar: | |
case QMetaType::UShort: | |
case QMetaType::ULong: | |
#if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET) | |
*f = (float)(qlonglong)qMetaTypeUNumber(d); | |
#else | |
*f = float(qMetaTypeUNumber(d)); | |
#endif | |
break; | |
default: | |
*f = 0.0f; | |
return false; | |
} | |
break; | |
} | |
case QVariant::List: | |
if (d->type == QVariant::StringList) { | |
QVariantList *lst = static_cast<QVariantList *>(result); | |
const QStringList *slist = v_cast<QStringList>(d); | |
for (int i = 0; i < slist->size(); ++i) | |
lst->append(QVariant(slist->at(i))); | |
} else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) { | |
*static_cast<QVariantList *>(result) = | |
*static_cast<QList<QVariant> *>(d->data.shared->ptr); | |
} else { | |
return false; | |
} | |
break; | |
case QVariant::Map: | |
if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) { | |
*static_cast<QVariantMap *>(result) = | |
*static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr); | |
} else { | |
return false; | |
} | |
break; | |
case QVariant::Hash: | |
if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) { | |
*static_cast<QVariantHash *>(result) = | |
*static_cast<QHash<QString, QVariant> *>(d->data.shared->ptr); | |
} else { | |
return false; | |
} | |
break; | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Rect: | |
if (d->type == QVariant::RectF) | |
*static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect(); | |
else | |
return false; | |
break; | |
case QVariant::RectF: | |
if (d->type == QVariant::Rect) | |
*static_cast<QRectF *>(result) = *v_cast<QRect>(d); | |
else | |
return false; | |
break; | |
case QVariant::PointF: | |
if (d->type == QVariant::Point) | |
*static_cast<QPointF *>(result) = *v_cast<QPoint>(d); | |
else | |
return false; | |
break; | |
case QVariant::Point: | |
if (d->type == QVariant::PointF) | |
*static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint(); | |
else | |
return false; | |
break; | |
case QMetaType::Char: | |
{ | |
*static_cast<qint8 *>(result) = qint8(qConvertToNumber(d, ok)); | |
return *ok; | |
} | |
#endif | |
default: | |
return false; | |
} | |
return true; | |
} | |
#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM) | |
static void streamDebug(QDebug dbg, const QVariant &v) | |
{ | |
switch (v.userType()) { | |
case QVariant::Int: | |
dbg.nospace() << v.toInt(); | |
break; | |
case QVariant::UInt: | |
dbg.nospace() << v.toUInt(); | |
break; | |
case QVariant::LongLong: | |
dbg.nospace() << v.toLongLong(); | |
break; | |
case QVariant::ULongLong: | |
dbg.nospace() << v.toULongLong(); | |
break; | |
case QMetaType::Float: | |
dbg.nospace() << v.toFloat(); | |
break; | |
case QMetaType::QObjectStar: | |
dbg.nospace() << qVariantValue<QObject *>(v); | |
break; | |
case QVariant::Double: | |
dbg.nospace() << v.toDouble(); | |
break; | |
case QVariant::Bool: | |
dbg.nospace() << v.toBool(); | |
break; | |
case QVariant::String: | |
dbg.nospace() << v.toString(); | |
break; | |
case QVariant::Char: | |
dbg.nospace() << v.toChar(); | |
break; | |
case QVariant::StringList: | |
dbg.nospace() << v.toStringList(); | |
break; | |
case QVariant::Map: | |
dbg.nospace() << v.toMap(); | |
break; | |
case QVariant::Hash: | |
dbg.nospace() << v.toHash(); | |
break; | |
case QVariant::List: | |
dbg.nospace() << v.toList(); | |
break; | |
case QVariant::Date: | |
dbg.nospace() << v.toDate(); | |
break; | |
case QVariant::Time: | |
dbg.nospace() << v.toTime(); | |
break; | |
case QVariant::DateTime: | |
dbg.nospace() << v.toDateTime(); | |
break; | |
#ifndef QT_BOOTSTRAPPED | |
case QVariant::EasingCurve: | |
dbg.nospace() << v.toEasingCurve(); | |
break; | |
#endif | |
case QVariant::ByteArray: | |
dbg.nospace() << v.toByteArray(); | |
break; | |
case QVariant::Url: | |
dbg.nospace() << v.toUrl(); | |
break; | |
#ifndef QT_NO_GEOM_VARIANT | |
case QVariant::Point: | |
dbg.nospace() << v.toPoint(); | |
break; | |
case QVariant::PointF: | |
dbg.nospace() << v.toPointF(); | |
break; | |
case QVariant::Rect: | |
dbg.nospace() << v.toRect(); | |
break; | |
case QVariant::Size: | |
dbg.nospace() << v.toSize(); | |
break; | |
case QVariant::SizeF: | |
dbg.nospace() << v.toSizeF(); | |
break; | |
case QVariant::Line: | |
dbg.nospace() << v.toLine(); | |
break; | |
case QVariant::LineF: | |
dbg.nospace() << v.toLineF(); | |
break; | |
case QVariant::RectF: | |
dbg.nospace() << v.toRectF(); | |
break; | |
#endif | |
case QVariant::BitArray: | |
//dbg.nospace() << v.toBitArray(); | |
break; | |
default: | |
break; | |
} | |
} | |
#endif | |
const QVariant::Handler qt_kernel_variant_handler = { | |
construct, | |
clear, | |
isNull, | |
#ifndef QT_NO_DATASTREAM | |
0, | |
0, | |
#endif | |
compare, | |
convert, | |
0, | |
#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM) | |
streamDebug | |
#else | |
0 | |
#endif | |
}; | |
Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler() | |
{ | |
return &qt_kernel_variant_handler; | |
} | |
const QVariant::Handler *QVariant::handler = &qt_kernel_variant_handler; | |
/*! | |
\class QVariant | |
\brief The QVariant class acts like a union for the most common Qt data types. | |
\ingroup objectmodel | |
\ingroup shared | |
Because C++ forbids unions from including types that have | |
non-default constructors or destructors, most interesting Qt | |
classes cannot be used in unions. Without QVariant, this would be | |
a problem for QObject::property() and for database work, etc. | |
A QVariant object holds a single value of a single type() at a | |
time. (Some type()s are multi-valued, for example a string list.) | |
You can find out what type, T, the variant holds, convert it to a | |
different type using convert(), get its value using one of the | |
toT() functions (e.g., toSize()) and check whether the type can | |
be converted to a particular type using canConvert(). | |
The methods named toT() (e.g., toInt(), toString()) are const. If | |
you ask for the stored type, they return a copy of the stored | |
object. If you ask for a type that can be generated from the | |
stored type, toT() copies and converts and leaves the object | |
itself unchanged. If you ask for a type that cannot be generated | |
from the stored type, the result depends on the type; see the | |
function documentation for details. | |
Here is some example code to demonstrate the use of QVariant: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 0 | |
You can even store QList<QVariant> and QMap<QString, QVariant> | |
values in a variant, so you can easily construct arbitrarily | |
complex data structures of arbitrary types. This is very powerful | |
and versatile, but may prove less memory and speed efficient than | |
storing specific types in standard data structures. | |
QVariant also supports the notion of null values, where you can | |
have a defined type with no value set. However, note that QVariant | |
types can only be cast when they have had a value set. | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 1 | |
QVariant can be extended to support other types than those | |
mentioned in the \l Type enum. See the \l QMetaType documentation | |
for details. | |
\section1 A Note on GUI Types | |
Because QVariant is part of the QtCore library, it cannot provide | |
conversion functions to data types defined in QtGui, such as | |
QColor, QImage, and QPixmap. In other words, there is no \c | |
toColor() function. Instead, you can use the QVariant::value() or | |
the qVariantValue() template function. For example: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 2 | |
The inverse conversion (e.g., from QColor to QVariant) is | |
automatic for all data types supported by QVariant, including | |
GUI-related types: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 3 | |
\section1 Using canConvert() and convert() Consecutively | |
When using canConvert() and convert() consecutively, it is possible for | |
canConvert() to return true, but convert() to return false. This | |
is typically because canConvert() only reports the general ability of | |
QVariant to convert between types given suitable data; it is still | |
possible to supply data which cannot actually be converted. | |
For example, canConvert() would return true when called on a variant | |
containing a string because, in principle, QVariant is able to convert | |
strings of numbers to integers. | |
However, if the string contains non-numeric characters, it cannot be | |
converted to an integer, and any attempt to convert it will fail. | |
Hence, it is important to have both functions return true for a | |
successful conversion. | |
\sa QMetaType | |
*/ | |
/*! | |
\enum QVariant::Type | |
This enum type defines the types of variable that a QVariant can | |
contain. | |
\value Invalid no type | |
\value BitArray a QBitArray | |
\value Bitmap a QBitmap | |
\value Bool a bool | |
\value Brush a QBrush | |
\value ByteArray a QByteArray | |
\value Char a QChar | |
\value Color a QColor | |
\value Cursor a QCursor | |
\value Date a QDate | |
\value DateTime a QDateTime | |
\value Double a double | |
\value EasingCurve a QEasingCurve | |
\value Font a QFont | |
\value Hash a QVariantHash | |
\value Icon a QIcon | |
\value Image a QImage | |
\value Int an int | |
\value KeySequence a QKeySequence | |
\value Line a QLine | |
\value LineF a QLineF | |
\value List a QVariantList | |
\value Locale a QLocale | |
\value LongLong a \l qlonglong | |
\value Map a QVariantMap | |
\value Matrix a QMatrix | |
\value Transform a QTransform | |
\value Matrix4x4 a QMatrix4x4 | |
\value Palette a QPalette | |
\value Pen a QPen | |
\value Pixmap a QPixmap | |
\value Point a QPoint | |
\value PointArray a QPointArray | |
\value PointF a QPointF | |
\value Polygon a QPolygon | |
\value Quaternion a QQuaternion | |
\value Rect a QRect | |
\value RectF a QRectF | |
\value RegExp a QRegExp | |
\value Region a QRegion | |
\value Size a QSize | |
\value SizeF a QSizeF | |
\value SizePolicy a QSizePolicy | |
\value String a QString | |
\value StringList a QStringList | |
\value TextFormat a QTextFormat | |
\value TextLength a QTextLength | |
\value Time a QTime | |
\value UInt a \l uint | |
\value ULongLong a \l qulonglong | |
\value Url a QUrl | |
\value Vector2D a QVector2D | |
\value Vector3D a QVector3D | |
\value Vector4D a QVector4D | |
\value UserType Base value for user-defined types. | |
\omitvalue CString | |
\omitvalue ColorGroup | |
\omitvalue IconSet | |
\omitvalue LastGuiType | |
\omitvalue LastCoreType | |
\omitvalue LastType | |
*/ | |
/*! | |
\fn QVariant::QVariant() | |
Constructs an invalid variant. | |
*/ | |
/*! | |
\fn QVariant::QVariant(int typeOrUserType, const void *copy) | |
Constructs variant of type \a typeOrUserType, and initializes with | |
\a copy if \a copy is not 0. | |
Note that you have to pass the address of the variable you want stored. | |
Usually, you never have to use this constructor, use qVariantFromValue() | |
instead to construct variants from the pointer types represented by | |
\c QMetaType::VoidStar, \c QMetaType::QObjectStar and | |
\c QMetaType::QWidgetStar. | |
\sa qVariantFromValue(), Type | |
*/ | |
/*! | |
\fn QVariant::QVariant(Type type) | |
Constructs a null variant of type \a type. | |
*/ | |
/*! | |
\fn QVariant::create(int type, const void *copy) | |
\internal | |
Constructs a variant private of type \a type, and initializes with \a copy if | |
\a copy is not 0. | |
*/ | |
void QVariant::create(int type, const void *copy) | |
{ | |
d.type = type; | |
handler->construct(&d, copy); | |
} | |
/*! | |
\fn QVariant::~QVariant() | |
Destroys the QVariant and the contained object. | |
Note that subclasses that reimplement clear() should reimplement | |
the destructor to call clear(). This destructor calls clear(), but | |
because it is the destructor, QVariant::clear() is called rather | |
than a subclass's clear(). | |
*/ | |
QVariant::~QVariant() | |
{ | |
if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char && d.type < UserType)) | |
handler->clear(&d); | |
} | |
/*! | |
\fn QVariant::QVariant(const QVariant &p) | |
Constructs a copy of the variant, \a p, passed as the argument to | |
this constructor. | |
*/ | |
QVariant::QVariant(const QVariant &p) | |
: d(p.d) | |
{ | |
if (d.is_shared) { | |
d.data.shared->ref.ref(); | |
} else if (p.d.type > Char && p.d.type < QVariant::UserType) { | |
handler->construct(&d, p.constData()); | |
d.is_null = p.d.is_null; | |
} | |
} | |
#ifndef QT_NO_DATASTREAM | |
/*! | |
Reads the variant from the data stream, \a s. | |
*/ | |
QVariant::QVariant(QDataStream &s) | |
{ | |
d.is_null = true; | |
s >> *this; | |
} | |
#endif //QT_NO_DATASTREAM | |
/*! | |
\fn QVariant::QVariant(const QString &val) | |
Constructs a new variant with a string value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QLatin1String &val) | |
Constructs a new variant with a string value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const char *val) | |
Constructs a new variant with a string value of \a val. | |
The variant creates a deep copy of \a val, using the encoding | |
set by QTextCodec::setCodecForCStrings(). | |
Note that \a val is converted to a QString for storing in the | |
variant and QVariant::type() will return QMetaType::QString for | |
the variant. | |
You can disable this operator by defining \c | |
QT_NO_CAST_FROM_ASCII when you compile your applications. | |
\sa QTextCodec::setCodecForCStrings() | |
*/ | |
#ifndef QT_NO_CAST_FROM_ASCII | |
QVariant::QVariant(const char *val) | |
{ | |
QString s = QString::fromAscii(val); | |
create(String, &s); | |
} | |
#endif | |
/*! | |
\fn QVariant::QVariant(const QStringList &val) | |
Constructs a new variant with a string list value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QMap<QString, QVariant> &val) | |
Constructs a new variant with a map of QVariants, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QHash<QString, QVariant> &val) | |
Constructs a new variant with a hash of QVariants, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QDate &val) | |
Constructs a new variant with a date value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QTime &val) | |
Constructs a new variant with a time value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QDateTime &val) | |
Constructs a new variant with a date/time value, \a val. | |
*/ | |
/*! | |
\since 4.7 | |
\fn QVariant::QVariant(const QEasingCurve &val) | |
Constructs a new variant with an easing curve value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QByteArray &val) | |
Constructs a new variant with a bytearray value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QBitArray &val) | |
Constructs a new variant with a bitarray value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QPoint &val) | |
Constructs a new variant with a point value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QPointF &val) | |
Constructs a new variant with a point value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QRectF &val) | |
Constructs a new variant with a rect value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QLineF &val) | |
Constructs a new variant with a line value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QLine &val) | |
Constructs a new variant with a line value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QRect &val) | |
Constructs a new variant with a rect value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QSize &val) | |
Constructs a new variant with a size value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QSizeF &val) | |
Constructs a new variant with a size value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QUrl &val) | |
Constructs a new variant with a url value of \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(int val) | |
Constructs a new variant with an integer value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(uint val) | |
Constructs a new variant with an unsigned integer value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(qlonglong val) | |
Constructs a new variant with a long long integer value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(qulonglong val) | |
Constructs a new variant with an unsigned long long integer value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(bool val) | |
Constructs a new variant with a boolean value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(double val) | |
Constructs a new variant with a floating point value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(float val) | |
Constructs a new variant with a floating point value, \a val. | |
\since 4.6 | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QList<QVariant> &val) | |
Constructs a new variant with a list value, \a val. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QChar &c) | |
Constructs a new variant with a char value, \a c. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QLocale &l) | |
Constructs a new variant with a locale value, \a l. | |
*/ | |
/*! | |
\fn QVariant::QVariant(const QRegExp ®Exp) | |
Constructs a new variant with the regexp value \a regExp. | |
*/ | |
/*! \since 4.2 | |
\fn QVariant::QVariant(Qt::GlobalColor color) | |
Constructs a new variant of type QVariant::Color and initializes | |
it with \a color. | |
This is a convenience constructor that allows \c{QVariant(Qt::blue);} | |
to create a valid QVariant storing a QColor. | |
Note: This constructor will assert if the application does not link | |
to the Qt GUI library. | |
*/ | |
QVariant::QVariant(Type type) | |
{ create(type, 0); } | |
QVariant::QVariant(int typeOrUserType, const void *copy) | |
{ create(typeOrUserType, copy); d.is_null = false; } | |
/*! \internal | |
flags is true if it is a pointer type | |
*/ | |
QVariant::QVariant(int typeOrUserType, const void *copy, uint flags) | |
{ | |
if (flags) { //type is a pointer type | |
d.type = typeOrUserType; | |
d.data.ptr = *reinterpret_cast<void *const*>(copy); | |
d.is_null = false; | |
} else { | |
create(typeOrUserType, copy); | |
d.is_null = false; | |
} | |
} | |
QVariant::QVariant(int val) | |
{ d.is_null = false; d.type = Int; d.data.i = val; } | |
QVariant::QVariant(uint val) | |
{ d.is_null = false; d.type = UInt; d.data.u = val; } | |
QVariant::QVariant(qlonglong val) | |
{ d.is_null = false; d.type = LongLong; d.data.ll = val; } | |
QVariant::QVariant(qulonglong val) | |
{ d.is_null = false; d.type = ULongLong; d.data.ull = val; } | |
QVariant::QVariant(bool val) | |
{ d.is_null = false; d.type = Bool; d.data.b = val; } | |
QVariant::QVariant(double val) | |
{ d.is_null = false; d.type = Double; d.data.d = val; } | |
QVariant::QVariant(const QByteArray &val) | |
{ d.is_null = false; d.type = ByteArray; v_construct<QByteArray>(&d, val); } | |
QVariant::QVariant(const QBitArray &val) | |
{ d.is_null = false; d.type = BitArray; v_construct<QBitArray>(&d, val); } | |
QVariant::QVariant(const QString &val) | |
{ d.is_null = false; d.type = String; v_construct<QString>(&d, val); } | |
QVariant::QVariant(const QChar &val) | |
{ d.is_null = false; d.type = Char; v_construct<QChar>(&d, val); } | |
QVariant::QVariant(const QLatin1String &val) | |
{ QString str(val); d.is_null = false; d.type = String; v_construct<QString>(&d, str); } | |
QVariant::QVariant(const QStringList &val) | |
{ d.is_null = false; d.type = StringList; v_construct<QStringList>(&d, val); } | |
QVariant::QVariant(const QDate &val) | |
{ d.is_null = false; d.type = Date; v_construct<QDate>(&d, val); } | |
QVariant::QVariant(const QTime &val) | |
{ d.is_null = false; d.type = Time; v_construct<QTime>(&d, val); } | |
QVariant::QVariant(const QDateTime &val) | |
{ d.is_null = false; d.type = DateTime; v_construct<QDateTime>(&d, val); } | |
#ifndef QT_BOOTSTRAPPED | |
QVariant::QVariant(const QEasingCurve &val) | |
{ d.is_null = false; d.type = EasingCurve; v_construct<QEasingCurve>(&d, val); } | |
#endif | |
QVariant::QVariant(const QList<QVariant> &list) | |
{ d.is_null = false; d.type = List; v_construct<QVariantList>(&d, list); } | |
QVariant::QVariant(const QMap<QString, QVariant> &map) | |
{ d.is_null = false; d.type = Map; v_construct<QVariantMap>(&d, map); } | |
QVariant::QVariant(const QHash<QString, QVariant> &hash) | |
{ d.is_null = false; d.type = Hash; v_construct<QVariantHash>(&d, hash); } | |
#ifndef QT_NO_GEOM_VARIANT | |
QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct<QPoint>(&d, pt); } | |
QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct<QPointF>(&d, pt); } | |
QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct<QRectF>(&d, r); } | |
QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct<QLineF>(&d, l); } | |
QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct<QLine>(&d, l); } | |
QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct<QRect>(&d, r); } | |
QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct<QSize>(&d, s); } | |
QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct<QSizeF>(&d, s); } | |
#endif | |
QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct<QUrl>(&d, u); } | |
QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct<QLocale>(&d, l); } | |
#ifndef QT_NO_REGEXP | |
QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct<QRegExp>(&d, regExp); } | |
#endif | |
QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); } | |
/*! | |
Returns the storage type of the value stored in the variant. | |
Although this function is declared as returning QVariant::Type, | |
the return value should be interpreted as QMetaType::Type. In | |
particular, QVariant::UserType is returned here only if the value | |
is equal or greater than QMetaType::User. | |
Note that return values in the ranges QVariant::Char through | |
QVariant::RegExp and QVariant::Font through QVariant::Transform | |
correspond to the values in the ranges QMetaType::QChar through | |
QMetaType::QRegExp and QMetaType::QFont through QMetaType::QQuaternion. | |
Pay particular attention when working with char and QChar | |
variants. Note that there is no QVariant constructor specifically | |
for type char, but there is one for QChar. For a variant of type | |
QChar, this function returns QVariant::Char, which is the same as | |
QMetaType::QChar, but for a variant of type \c char, this function | |
returns QMetaType::Char, which is \e not the same as | |
QVariant::Char. | |
Also note that the types \c void*, \c long, \c short, \c unsigned | |
\c long, \c unsigned \c short, \c unsigned \c char, \c float, \c | |
QObject*, and \c QWidget* are represented in QMetaType::Type but | |
not in QVariant::Type, and they can be returned by this function. | |
However, they are considered to be user defined types when tested | |
against QVariant::Type. | |
To test whether an instance of QVariant contains a data type that | |
is compatible with the data type you are interested in, use | |
canConvert(). | |
*/ | |
QVariant::Type QVariant::type() const | |
{ | |
return d.type >= QMetaType::User ? UserType : static_cast<Type>(d.type); | |
} | |
/*! | |
Returns the storage type of the value stored in the variant. For | |
non-user types, this is the same as type(). | |
\sa type() | |
*/ | |
int QVariant::userType() const | |
{ | |
return d.type; | |
} | |
/*! | |
Assigns the value of the variant \a variant to this variant. | |
*/ | |
QVariant& QVariant::operator=(const QVariant &variant) | |
{ | |
if (this == &variant) | |
return *this; | |
clear(); | |
if (variant.d.is_shared) { | |
variant.d.data.shared->ref.ref(); | |
d = variant.d; | |
} else if (variant.d.type > Char && variant.d.type < UserType) { | |
d.type = variant.d.type; | |
handler->construct(&d, variant.constData()); | |
d.is_null = variant.d.is_null; | |
} else { | |
d = variant.d; | |
} | |
return *this; | |
} | |
/*! | |
\fn void QVariant::detach() | |
\internal | |
*/ | |
void QVariant::detach() | |
{ | |
if (!d.is_shared || d.data.shared->ref == 1) | |
return; | |
Private dd; | |
dd.type = d.type; | |
handler->construct(&dd, constData()); | |
if (!d.data.shared->ref.deref()) | |
handler->clear(&d); | |
d.data.shared = dd.data.shared; | |
} | |
/*! | |
\fn bool QVariant::isDetached() const | |
\internal | |
*/ | |
// ### Qt 5: change typeName()(and froends= to return a QString. Suggestion from Harald. | |
/*! | |
Returns the name of the type stored in the variant. The returned | |
strings describe the C++ datatype used to store the data: for | |
example, "QFont", "QString", or "QVariantList". An Invalid | |
variant returns 0. | |
*/ | |
const char *QVariant::typeName() const | |
{ | |
return typeToName(Type(d.type)); | |
} | |
/*! | |
Convert this variant to type Invalid and free up any resources | |
used. | |
*/ | |
void QVariant::clear() | |
{ | |
if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type < UserType && d.type > Char)) | |
handler->clear(&d); | |
d.type = Invalid; | |
d.is_null = true; | |
d.is_shared = false; | |
} | |
/*! | |
Converts the enum representation of the storage type, \a typ, to | |
its string representation. | |
Returns a null pointer if the type is QVariant::Invalid or doesn't exist. | |
*/ | |
const char *QVariant::typeToName(Type typ) | |
{ | |
if (typ == Invalid) | |
return 0; | |
if (typ == UserType) | |
return "UserType"; | |
return QMetaType::typeName(typ); | |
} | |
/*! | |
Converts the string representation of the storage type given in \a | |
name, to its enum representation. | |
If the string representation cannot be converted to any enum | |
representation, the variant is set to \c Invalid. | |
*/ | |
QVariant::Type QVariant::nameToType(const char *name) | |
{ | |
if (!name || !*name) | |
return Invalid; | |
if (strcmp(name, "Q3CString") == 0) | |
return ByteArray; | |
if (strcmp(name, "Q_LLONG") == 0) | |
return LongLong; | |
if (strcmp(name, "Q_ULLONG") == 0) | |
return ULongLong; | |
if (strcmp(name, "QIconSet") == 0) | |
return Icon; | |
if (strcmp(name, "UserType") == 0) | |
return UserType; | |
int metaType = QMetaType::type(name); | |
return metaType <= int(LastGuiType) ? QVariant::Type(metaType) : UserType; | |
} | |
#ifndef QT_NO_DATASTREAM | |
enum { MapFromThreeCount = 36 }; | |
static const ushort map_from_three[MapFromThreeCount] = | |
{ | |
QVariant::Invalid, | |
QVariant::Map, | |
QVariant::List, | |
QVariant::String, | |
QVariant::StringList, | |
QVariant::Font, | |
QVariant::Pixmap, | |
QVariant::Brush, | |
QVariant::Rect, | |
QVariant::Size, | |
QVariant::Color, | |
QVariant::Palette, | |
63, // ColorGroup | |
QVariant::Icon, | |
QVariant::Point, | |
QVariant::Image, | |
QVariant::Int, | |
QVariant::UInt, | |
QVariant::Bool, | |
QVariant::Double, | |
QVariant::ByteArray, | |
QVariant::Polygon, | |
QVariant::Region, | |
QVariant::Bitmap, | |
QVariant::Cursor, | |
QVariant::SizePolicy, | |
QVariant::Date, | |
QVariant::Time, | |
QVariant::DateTime, | |
QVariant::ByteArray, | |
QVariant::BitArray, | |
QVariant::KeySequence, | |
QVariant::Pen, | |
QVariant::LongLong, | |
QVariant::ULongLong, | |
QVariant::EasingCurve | |
}; | |
/*! | |
Internal function for loading a variant from stream \a s. Use the | |
stream operators instead. | |
\internal | |
*/ | |
void QVariant::load(QDataStream &s) | |
{ | |
clear(); | |
quint32 u; | |
s >> u; | |
if (s.version() < QDataStream::Qt_4_0) { | |
if (u >= MapFromThreeCount) | |
return; | |
u = map_from_three[u]; | |
} | |
qint8 is_null = false; | |
if (s.version() >= QDataStream::Qt_4_2) | |
s >> is_null; | |
if (u == QVariant::UserType) { | |
QByteArray name; | |
s >> name; | |
u = QMetaType::type(name); | |
if (!u) { | |
s.setStatus(QDataStream::ReadCorruptData); | |
return; | |
} | |
} | |
create(static_cast<int>(u), 0); | |
d.is_null = is_null; | |
if (!isValid()) { | |
// Since we wrote something, we should read something | |
QString x; | |
s >> x; | |
d.is_null = true; | |
return; | |
} | |
// const cast is safe since we operate on a newly constructed variant | |
if (!QMetaType::load(s, d.type, const_cast<void *>(constData()))) { | |
s.setStatus(QDataStream::ReadCorruptData); | |
qWarning("QVariant::load: unable to load type %d.", d.type); | |
} | |
} | |
/*! | |
Internal function for saving a variant to the stream \a s. Use the | |
stream operators instead. | |
\internal | |
*/ | |
void QVariant::save(QDataStream &s) const | |
{ | |
quint32 tp = type(); | |
if (s.version() < QDataStream::Qt_4_0) { | |
int i; | |
for (i = MapFromThreeCount - 1; i >= 0; i--) { | |
if (map_from_three[i] == tp) { | |
tp = i; | |
break; | |
} | |
} | |
if (i == -1) { | |
s << QVariant(); | |
return; | |
} | |
} | |
s << tp; | |
if (s.version() >= QDataStream::Qt_4_2) | |
s << qint8(d.is_null); | |
if (tp == QVariant::UserType) { | |
s << QMetaType::typeName(userType()); | |
} | |
if (!isValid()) { | |
s << QString(); | |
return; | |
} | |
if (!QMetaType::save(s, d.type, constData())) { | |
Q_ASSERT_X(false, "QVariant::save", "Invalid type to save"); | |
qWarning("QVariant::save: unable to save type %d.", d.type); | |
} | |
} | |
/*! | |
\since 4.4 | |
Reads a variant \a p from the stream \a s. | |
\sa \link datastreamformat.html Format of the QDataStream | |
operators \endlink | |
*/ | |
QDataStream& operator>>(QDataStream &s, QVariant &p) | |
{ | |
p.load(s); | |
return s; | |
} | |
/*! | |
Writes a variant \a p to the stream \a s. | |
\sa \link datastreamformat.html Format of the QDataStream | |
operators \endlink | |
*/ | |
QDataStream& operator<<(QDataStream &s, const QVariant &p) | |
{ | |
p.save(s); | |
return s; | |
} | |
/*! | |
Reads a variant type \a p in enum representation from the stream \a s. | |
*/ | |
QDataStream& operator>>(QDataStream &s, QVariant::Type &p) | |
{ | |
quint32 u; | |
s >> u; | |
p = (QVariant::Type)u; | |
return s; | |
} | |
/*! | |
Writes a variant type \a p to the stream \a s. | |
*/ | |
QDataStream& operator<<(QDataStream &s, const QVariant::Type p) | |
{ | |
s << static_cast<quint32>(p); | |
return s; | |
} | |
#endif //QT_NO_DATASTREAM | |
/*! | |
\fn bool QVariant::isValid() const | |
Returns true if the storage type of this variant is not | |
QVariant::Invalid; otherwise returns false. | |
*/ | |
template <typename T> | |
inline T qVariantToHelper(const QVariant::Private &d, QVariant::Type t, | |
const QVariant::Handler *handler, T * = 0) | |
{ | |
if (d.type == t) | |
return *v_cast<T>(&d); | |
T ret; | |
handler->convert(&d, t, &ret, 0); | |
return ret; | |
} | |
/*! | |
\fn QStringList QVariant::toStringList() const | |
Returns the variant as a QStringList if the variant has type() | |
StringList, \l String, or \l List of a type that can be converted | |
to QString; otherwise returns an empty list. | |
\sa canConvert(), convert() | |
*/ | |
QStringList QVariant::toStringList() const | |
{ | |
return qVariantToHelper<QStringList>(d, StringList, handler); | |
} | |
/*! | |
Returns the variant as a QString if the variant has type() \l | |
String, \l Bool, \l ByteArray, \l Char, \l Date, \l DateTime, \l | |
Double, \l Int, \l LongLong, \l StringList, \l Time, \l UInt, or | |
\l ULongLong; otherwise returns an empty string. | |
\sa canConvert(), convert() | |
*/ | |
QString QVariant::toString() const | |
{ | |
return qVariantToHelper<QString>(d, String, handler); | |
} | |
/*! | |
Returns the variant as a QMap<QString, QVariant> if the variant | |
has type() \l Map; otherwise returns an empty map. | |
\sa canConvert(), convert() | |
*/ | |
QVariantMap QVariant::toMap() const | |
{ | |
return qVariantToHelper<QVariantMap>(d, Map, handler); | |
} | |
/*! | |
Returns the variant as a QHash<QString, QVariant> if the variant | |
has type() \l Hash; otherwise returns an empty map. | |
\sa canConvert(), convert() | |
*/ | |
QVariantHash QVariant::toHash() const | |
{ | |
return qVariantToHelper<QVariantHash>(d, Hash, handler); | |
} | |
/*! | |
\fn QDate QVariant::toDate() const | |
Returns the variant as a QDate if the variant has type() \l Date, | |
\l DateTime, or \l String; otherwise returns an invalid date. | |
If the type() is \l String, an invalid date will be returned if the | |
string cannot be parsed as a Qt::ISODate format date. | |
\sa canConvert(), convert() | |
*/ | |
QDate QVariant::toDate() const | |
{ | |
return qVariantToHelper<QDate>(d, Date, handler); | |
} | |
/*! | |
\fn QTime QVariant::toTime() const | |
Returns the variant as a QTime if the variant has type() \l Time, | |
\l DateTime, or \l String; otherwise returns an invalid time. | |
If the type() is \l String, an invalid time will be returned if | |
the string cannot be parsed as a Qt::ISODate format time. | |
\sa canConvert(), convert() | |
*/ | |
QTime QVariant::toTime() const | |
{ | |
return qVariantToHelper<QTime>(d, Time, handler); | |
} | |
/*! | |
\fn QDateTime QVariant::toDateTime() const | |
Returns the variant as a QDateTime if the variant has type() \l | |
DateTime, \l Date, or \l String; otherwise returns an invalid | |
date/time. | |
If the type() is \l String, an invalid date/time will be returned | |
if the string cannot be parsed as a Qt::ISODate format date/time. | |
\sa canConvert(), convert() | |
*/ | |
QDateTime QVariant::toDateTime() const | |
{ | |
return qVariantToHelper<QDateTime>(d, DateTime, handler); | |
} | |
/*! | |
\since 4.7 | |
\fn QEasingCurve QVariant::toEasingCurve() const | |
Returns the variant as a QEasingCurve if the variant has type() \l | |
EasingCurve; otherwise returns a default easing curve. | |
\sa canConvert(), convert() | |
*/ | |
#ifndef QT_BOOTSTRAPPED | |
QEasingCurve QVariant::toEasingCurve() const | |
{ | |
return qVariantToHelper<QEasingCurve>(d, EasingCurve, handler); | |
} | |
#endif | |
/*! | |
\fn QByteArray QVariant::toByteArray() const | |
Returns the variant as a QByteArray if the variant has type() \l | |
ByteArray or \l String (converted using QString::fromAscii()); | |
otherwise returns an empty byte array. | |
\sa canConvert(), convert() | |
*/ | |
QByteArray QVariant::toByteArray() const | |
{ | |
return qVariantToHelper<QByteArray>(d, ByteArray, handler); | |
} | |
#ifndef QT_NO_GEOM_VARIANT | |
/*! | |
\fn QPoint QVariant::toPoint() const | |
Returns the variant as a QPoint if the variant has type() | |
\l Point or \l PointF; otherwise returns a null QPoint. | |
\sa canConvert(), convert() | |
*/ | |
QPoint QVariant::toPoint() const | |
{ | |
return qVariantToHelper<QPoint>(d, Point, handler); | |
} | |
/*! | |
\fn QRect QVariant::toRect() const | |
Returns the variant as a QRect if the variant has type() \l Rect; | |
otherwise returns an invalid QRect. | |
\sa canConvert(), convert() | |
*/ | |
QRect QVariant::toRect() const | |
{ | |
return qVariantToHelper<QRect>(d, Rect, handler); | |
} | |
/*! | |
\fn QSize QVariant::toSize() const | |
Returns the variant as a QSize if the variant has type() \l Size; | |
otherwise returns an invalid QSize. | |
\sa canConvert(), convert() | |
*/ | |
QSize QVariant::toSize() const | |
{ | |
return qVariantToHelper<QSize>(d, Size, handler); | |
} | |
/*! | |
\fn QSizeF QVariant::toSizeF() const | |
Returns the variant as a QSizeF if the variant has type() \l | |
SizeF; otherwise returns an invalid QSizeF. | |
\sa canConvert(), convert() | |
*/ | |
QSizeF QVariant::toSizeF() const | |
{ | |
return qVariantToHelper<QSizeF>(d, SizeF, handler); | |
} | |
/*! | |
\fn QRectF QVariant::toRectF() const | |
Returns the variant as a QRectF if the variant has type() \l Rect | |
or \l RectF; otherwise returns an invalid QRectF. | |
\sa canConvert(), convert() | |
*/ | |
QRectF QVariant::toRectF() const | |
{ | |
return qVariantToHelper<QRectF>(d, RectF, handler); | |
} | |
/*! | |
\fn QLineF QVariant::toLineF() const | |
Returns the variant as a QLineF if the variant has type() \l | |
LineF; otherwise returns an invalid QLineF. | |
\sa canConvert(), convert() | |
*/ | |
QLineF QVariant::toLineF() const | |
{ | |
return qVariantToHelper<QLineF>(d, LineF, handler); | |
} | |
/*! | |
\fn QLine QVariant::toLine() const | |
Returns the variant as a QLine if the variant has type() \l Line; | |
otherwise returns an invalid QLine. | |
\sa canConvert(), convert() | |
*/ | |
QLine QVariant::toLine() const | |
{ | |
return qVariantToHelper<QLine>(d, Line, handler); | |
} | |
/*! | |
\fn QPointF QVariant::toPointF() const | |
Returns the variant as a QPointF if the variant has type() \l | |
Point or \l PointF; otherwise returns a null QPointF. | |
\sa canConvert(), convert() | |
*/ | |
QPointF QVariant::toPointF() const | |
{ | |
return qVariantToHelper<QPointF>(d, PointF, handler); | |
} | |
#endif // QT_NO_GEOM_VARIANT | |
/*! | |
\fn QUrl QVariant::toUrl() const | |
Returns the variant as a QUrl if the variant has type() | |
\l Url; otherwise returns an invalid QUrl. | |
\sa canConvert(), convert() | |
*/ | |
QUrl QVariant::toUrl() const | |
{ | |
return qVariantToHelper<QUrl>(d, Url, handler); | |
} | |
/*! | |
\fn QLocale QVariant::toLocale() const | |
Returns the variant as a QLocale if the variant has type() | |
\l Locale; otherwise returns an invalid QLocale. | |
\sa canConvert(), convert() | |
*/ | |
QLocale QVariant::toLocale() const | |
{ | |
return qVariantToHelper<QLocale>(d, Locale, handler); | |
} | |
/*! | |
\fn QRegExp QVariant::toRegExp() const | |
\since 4.1 | |
Returns the variant as a QRegExp if the variant has type() \l | |
RegExp; otherwise returns an empty QRegExp. | |
\sa canConvert(), convert() | |
*/ | |
#ifndef QT_NO_REGEXP | |
QRegExp QVariant::toRegExp() const | |
{ | |
return qVariantToHelper<QRegExp>(d, RegExp, handler); | |
} | |
#endif | |
/*! | |
\fn QChar QVariant::toChar() const | |
Returns the variant as a QChar if the variant has type() \l Char, | |
\l Int, or \l UInt; otherwise returns an invalid QChar. | |
\sa canConvert(), convert() | |
*/ | |
QChar QVariant::toChar() const | |
{ | |
return qVariantToHelper<QChar>(d, Char, handler); | |
} | |
/*! | |
Returns the variant as a QBitArray if the variant has type() | |
\l BitArray; otherwise returns an empty bit array. | |
\sa canConvert(), convert() | |
*/ | |
QBitArray QVariant::toBitArray() const | |
{ | |
return qVariantToHelper<QBitArray>(d, BitArray, handler); | |
} | |
template <typename T> | |
inline T qNumVariantToHelper(const QVariant::Private &d, | |
const QVariant::Handler *handler, bool *ok, const T& val) | |
{ | |
uint t = qMetaTypeId<T>(); | |
if (ok) | |
*ok = true; | |
if (d.type == t) | |
return val; | |
T ret; | |
if (!handler->convert(&d, QVariant::Type(t), &ret, ok) && ok) | |
*ok = false; | |
return ret; | |
} | |
/*! | |
Returns the variant as an int if the variant has type() \l Int, | |
\l Bool, \l ByteArray, \l Char, \l Double, \l LongLong, \l | |
String, \l UInt, or \l ULongLong; otherwise returns 0. | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to an int; otherwise \c{*}\a{ok} is set to false. | |
\bold{Warning:} If the value is convertible to a \l LongLong but is too | |
large to be represented in an int, the resulting arithmetic overflow will | |
not be reflected in \a ok. A simple workaround is to use QString::toInt(). | |
Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code. | |
\sa canConvert(), convert() | |
*/ | |
int QVariant::toInt(bool *ok) const | |
{ | |
return qNumVariantToHelper<int>(d, handler, ok, d.data.i); | |
} | |
/*! | |
Returns the variant as an unsigned int if the variant has type() | |
\l UInt, \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l | |
LongLong, \l String, or \l ULongLong; otherwise returns 0. | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to an unsigned int; otherwise \c{*}\a{ok} is set to false. | |
\bold{Warning:} If the value is convertible to a \l ULongLong but is too | |
large to be represented in an unsigned int, the resulting arithmetic overflow will | |
not be reflected in \a ok. A simple workaround is to use QString::toUInt(). | |
Fixing this bug has been postponed to Qt 5 in order to avoid breaking existing code. | |
\sa canConvert(), convert() | |
*/ | |
uint QVariant::toUInt(bool *ok) const | |
{ | |
return qNumVariantToHelper<uint>(d, handler, ok, d.data.u); | |
} | |
/*! | |
Returns the variant as a long long int if the variant has type() | |
\l LongLong, \l Bool, \l ByteArray, \l Char, \l Double, \l Int, | |
\l String, \l UInt, or \l ULongLong; otherwise returns 0. | |
If \a ok is non-null: \c{*}\c{ok} is set to true if the value could be | |
converted to an int; otherwise \c{*}\c{ok} is set to false. | |
\sa canConvert(), convert() | |
*/ | |
qlonglong QVariant::toLongLong(bool *ok) const | |
{ | |
return qNumVariantToHelper<qlonglong>(d, handler, ok, d.data.ll); | |
} | |
/*! | |
Returns the variant as as an unsigned long long int if the | |
variant has type() \l ULongLong, \l Bool, \l ByteArray, \l Char, | |
\l Double, \l Int, \l LongLong, \l String, or \l UInt; otherwise | |
returns 0. | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to an int; otherwise \c{*}\a{ok} is set to false. | |
\sa canConvert(), convert() | |
*/ | |
qulonglong QVariant::toULongLong(bool *ok) const | |
{ | |
return qNumVariantToHelper<qulonglong>(d, handler, ok, d.data.ull); | |
} | |
/*! | |
Returns the variant as a bool if the variant has type() Bool. | |
Returns true if the variant has type() \l Bool, \l Char, \l Double, | |
\l Int, \l LongLong, \l UInt, or \l ULongLong and the value is | |
non-zero, or if the variant has type \l String or \l ByteArray and | |
its lower-case content is not empty, "0" or "false"; otherwise | |
returns false. | |
\sa canConvert(), convert() | |
*/ | |
bool QVariant::toBool() const | |
{ | |
if (d.type == Bool) | |
return d.data.b; | |
bool res = false; | |
handler->convert(&d, Bool, &res, 0); | |
return res; | |
} | |
/*! | |
Returns the variant as a double if the variant has type() \l | |
Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l | |
UInt, or \l ULongLong; otherwise returns 0.0. | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to a double; otherwise \c{*}\a{ok} is set to false. | |
\sa canConvert(), convert() | |
*/ | |
double QVariant::toDouble(bool *ok) const | |
{ | |
return qNumVariantToHelper<double>(d, handler, ok, d.data.d); | |
} | |
/*! | |
Returns the variant as a float if the variant has type() \l | |
Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l | |
UInt, or \l ULongLong; otherwise returns 0.0. | |
\since 4.6 | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to a double; otherwise \c{*}\a{ok} is set to false. | |
\sa canConvert(), convert() | |
*/ | |
float QVariant::toFloat(bool *ok) const | |
{ | |
return qNumVariantToHelper<float>(d, handler, ok, d.data.f); | |
} | |
/*! | |
Returns the variant as a qreal if the variant has type() \l | |
Double, \l QMetaType::Float, \l Bool, \l ByteArray, \l Int, \l LongLong, \l String, \l | |
UInt, or \l ULongLong; otherwise returns 0.0. | |
\since 4.6 | |
If \a ok is non-null: \c{*}\a{ok} is set to true if the value could be | |
converted to a double; otherwise \c{*}\a{ok} is set to false. | |
\sa canConvert(), convert() | |
*/ | |
qreal QVariant::toReal(bool *ok) const | |
{ | |
return qNumVariantToHelper<qreal>(d, handler, ok, d.data.real); | |
} | |
/*! | |
Returns the variant as a QVariantList if the variant has type() | |
\l List or \l StringList; otherwise returns an empty list. | |
\sa canConvert(), convert() | |
*/ | |
QVariantList QVariant::toList() const | |
{ | |
return qVariantToHelper<QVariantList>(d, List, handler); | |
} | |
/*! \fn QVariant::canCast(Type t) const | |
Use canConvert() instead. | |
*/ | |
/*! \fn QVariant::cast(Type t) | |
Use convert() instead. | |
*/ | |
static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] = | |
{ | |
/*Invalid*/ 0, | |
/*Bool*/ 1 << QVariant::Double | 1 << QVariant::Int | 1 << QVariant::UInt | |
| 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::ByteArray | |
| 1 << QVariant::String | 1 << QVariant::Char, | |
/*Int*/ 1 << QVariant::UInt | 1 << QVariant::String | 1 << QVariant::Double | |
| 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | |
| 1 << QVariant::Char | 1 << QVariant::ByteArray, | |
/*UInt*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double | |
| 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | |
| 1 << QVariant::Char | 1 << QVariant::ByteArray, | |
/*LLong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double | |
| 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::ULongLong | |
| 1 << QVariant::Char | 1 << QVariant::ByteArray, | |
/*ULlong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double | |
| 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong | |
| 1 << QVariant::Char | 1 << QVariant::ByteArray, | |
/*double*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::ULongLong | |
| 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong | |
| 1 << QVariant::ByteArray, | |
/*QChar*/ 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::LongLong | |
| 1 << QVariant::ULongLong, | |
/*QMap*/ 0, | |
/*QList*/ 1 << QVariant::StringList, | |
/*QString*/ 1 << QVariant::StringList | 1 << QVariant::ByteArray | 1 << QVariant::Int | |
| 1 << QVariant::UInt | 1 << QVariant::Bool | 1 << QVariant::Double | |
| 1 << QVariant::Date | 1 << QVariant::Time | 1 << QVariant::DateTime | |
| 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::Char | |
| 1 << QVariant::Url, | |
/*QStringList*/ 1 << QVariant::List | 1 << QVariant::String, | |
/*QByteArray*/ 1 << QVariant::String | 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::Bool | |
| 1 << QVariant::Double | 1 << QVariant::LongLong | 1 << QVariant::ULongLong, | |
/*QBitArray*/ 0, | |
/*QDate*/ 1 << QVariant::String | 1 << QVariant::DateTime, | |
/*QTime*/ 1 << QVariant::String | 1 << QVariant::DateTime, | |
/*QDateTime*/ 1 << QVariant::String | 1 << QVariant::Date, | |
/*QUrl*/ 1 << QVariant::String, | |
/*QLocale*/ 0, | |
/*QRect*/ 1 << QVariant::RectF, | |
/*QRectF*/ 1 << QVariant::Rect, | |
/*QSize*/ 1 << QVariant::SizeF, | |
/*QSizeF*/ 1 << QVariant::Size, | |
/*QLine*/ 1 << QVariant::LineF, | |
/*QLineF*/ 1 << QVariant::Line, | |
/*QPoint*/ 1 << QVariant::PointF, | |
/*QPointF*/ 1 << QVariant::Point, | |
/*QRegExp*/ 0, | |
/*QHash*/ 0, | |
/*QEasingCurve*/ 0 | |
}; | |
/*! | |
Returns true if the variant's type can be cast to the requested | |
type, \a t. Such casting is done automatically when calling the | |
toInt(), toBool(), ... methods. | |
The following casts are done automatically: | |
\table | |
\header \o Type \o Automatically Cast To | |
\row \o \l Bool \o \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong | |
\row \o \l ByteArray \o \l Double, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong | |
\row \o \l Char \o \l Bool, \l Int, \l UInt, \l LongLong, \l ULongLong | |
\row \o \l Color \o \l String | |
\row \o \l Date \o \l DateTime, \l String | |
\row \o \l DateTime \o \l Date, \l String, \l Time | |
\row \o \l Double \o \l Bool, \l Int, \l LongLong, \l String, \l UInt, \l ULongLong | |
\row \o \l Font \o \l String | |
\row \o \l Int \o \l Bool, \l Char, \l Double, \l LongLong, \l String, \l UInt, \l ULongLong | |
\row \o \l KeySequence \o \l Int, \l String | |
\row \o \l List \o \l StringList (if the list's items can be converted to strings) | |
\row \o \l LongLong \o \l Bool, \l ByteArray, \l Char, \l Double, \l Int, \l String, \l UInt, \l ULongLong | |
\row \o \l Point \o PointF | |
\row \o \l Rect \o RectF | |
\row \o \l String \o \l Bool, \l ByteArray, \l Char, \l Color, \l Date, \l DateTime, \l Double, | |
\l Font, \l Int, \l KeySequence, \l LongLong, \l StringList, \l Time, \l UInt, | |
\l ULongLong | |
\row \o \l StringList \o \l List, \l String (if the list contains exactly one item) | |
\row \o \l Time \o \l String | |
\row \o \l UInt \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l ULongLong | |
\row \o \l ULongLong \o \l Bool, \l Char, \l Double, \l Int, \l LongLong, \l String, \l UInt | |
\endtable | |
\sa convert() | |
*/ | |
bool QVariant::canConvert(Type t) const | |
{ | |
//we can treat floats as double | |
//the reason for not doing it the "proper" way is that QMetaType::Float's value is 135, | |
//which can't be handled by qCanConvertMatrix | |
//In addition QVariant::Type doesn't have a Float value, so we're using QMetaType::Float | |
const uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type); | |
if (uint(t) == uint(QMetaType::Float)) t = QVariant::Double; | |
if (currentType == uint(t)) | |
return true; | |
if (currentType > QVariant::LastCoreType || t > QVariant::LastCoreType) { | |
switch (uint(t)) { | |
case QVariant::Int: | |
return currentType == QVariant::KeySequence | |
|| currentType == QMetaType::ULong | |
|| currentType == QMetaType::Long | |
|| currentType == QMetaType::UShort | |
|| currentType == QMetaType::UChar | |
|| currentType == QMetaType::Char | |
|| currentType == QMetaType::Short; | |
case QVariant::Image: | |
return currentType == QVariant::Pixmap || currentType == QVariant::Bitmap; | |
case QVariant::Pixmap: | |
return currentType == QVariant::Image || currentType == QVariant::Bitmap | |
|| currentType == QVariant::Brush; | |
case QVariant::Bitmap: | |
return currentType == QVariant::Pixmap || currentType == QVariant::Image; | |
case QVariant::ByteArray: | |
return currentType == QVariant::Color; | |
case QVariant::String: | |
return currentType == QVariant::KeySequence || currentType == QVariant::Font | |
|| currentType == QVariant::Color; | |
case QVariant::KeySequence: | |
return currentType == QVariant::String || currentType == QVariant::Int; | |
case QVariant::Font: | |
return currentType == QVariant::String; | |
case QVariant::Color: | |
return currentType == QVariant::String || currentType == QVariant::ByteArray | |
|| currentType == QVariant::Brush; | |
case QVariant::Brush: | |
return currentType == QVariant::Color || currentType == QVariant::Pixmap; | |
case QMetaType::Long: | |
case QMetaType::Char: | |
case QMetaType::UChar: | |
case QMetaType::ULong: | |
case QMetaType::Short: | |
case QMetaType::UShort: | |
return qCanConvertMatrix[QVariant::Int] & (1 << currentType) || currentType == QVariant::Int; | |
default: | |
return false; | |
} | |
} | |
if(t == String && currentType == StringList) | |
return v_cast<QStringList>(&d)->count() == 1; | |
else | |
return qCanConvertMatrix[t] & (1 << currentType); | |
} | |
/*! | |
Casts the variant to the requested type, \a t. If the cast cannot be | |
done, the variant is cleared. Returns true if the current type of | |
the variant was successfully cast; otherwise returns false. | |
\warning For historical reasons, converting a null QVariant results | |
in a null value of the desired type (e.g., an empty string for | |
QString) and a result of false. | |
\sa canConvert(), clear() | |
*/ | |
bool QVariant::convert(Type t) | |
{ | |
if (d.type == uint(t)) | |
return true; | |
QVariant oldValue = *this; | |
clear(); | |
if (!oldValue.canConvert(t)) | |
return false; | |
create(t, 0); | |
if (oldValue.isNull()) | |
return false; | |
bool isOk = true; | |
if (!handler->convert(&oldValue.d, t, data(), &isOk)) | |
isOk = false; | |
d.is_null = !isOk; | |
return isOk; | |
} | |
/*! | |
\fn bool operator==(const QVariant &v1, const QVariant &v2) | |
\relates QVariant | |
Returns true if \a v1 and \a v2 are equal; otherwise returns false. | |
\warning This function doesn't support custom types registered | |
with qRegisterMetaType(). | |
*/ | |
/*! | |
\fn bool operator!=(const QVariant &v1, const QVariant &v2) | |
\relates QVariant | |
Returns false if \a v1 and \a v2 are equal; otherwise returns true. | |
\warning This function doesn't support custom types registered | |
with qRegisterMetaType(). | |
*/ | |
/*! \fn bool QVariant::operator==(const QVariant &v) const | |
Compares this QVariant with \a v and returns true if they are | |
equal; otherwise returns false. | |
In the case of custom types, their equalness operators are not called. | |
Instead the values' addresses are compared. | |
*/ | |
/*! | |
\fn bool QVariant::operator!=(const QVariant &v) const | |
Compares this QVariant with \a v and returns true if they are not | |
equal; otherwise returns false. | |
\warning This function doesn't support custom types registered | |
with qRegisterMetaType(). | |
*/ | |
static bool qIsNumericType(uint tp) | |
{ | |
return (tp >= QVariant::Bool && tp <= QVariant::Double) | |
|| (tp >= QMetaType::Long && tp <= QMetaType::Float); | |
} | |
static bool qIsFloatingPoint(uint tp) | |
{ | |
return tp == QVariant::Double || tp == QMetaType::Float; | |
} | |
/*! \internal | |
*/ | |
bool QVariant::cmp(const QVariant &v) const | |
{ | |
QVariant v2 = v; | |
if (d.type != v2.d.type) { | |
if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) { | |
if (qIsFloatingPoint(d.type) || qIsFloatingPoint(v.d.type)) | |
return qFuzzyCompare(toReal(), v.toReal()); | |
else | |
return toLongLong() == v.toLongLong(); | |
} | |
if (!v2.canConvert(Type(d.type)) || !v2.convert(Type(d.type))) | |
return false; | |
} | |
return handler->compare(&d, &v2.d); | |
} | |
/*! \internal | |
*/ | |
const void *QVariant::constData() const | |
{ | |
return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr); | |
} | |
/*! | |
\fn const void* QVariant::data() const | |
\internal | |
*/ | |
/*! \internal */ | |
void* QVariant::data() | |
{ | |
detach(); | |
return const_cast<void *>(constData()); | |
} | |
#ifdef QT3_SUPPORT | |
/*! \internal | |
*/ | |
void *QVariant::castOrDetach(Type t) | |
{ | |
if (d.type != uint(t)) { | |
if (!convert(t)) | |
create(t, 0); | |
} else { | |
detach(); | |
} | |
return data(); | |
} | |
#endif | |
/*! | |
Returns true if this is a NULL variant, false otherwise. | |
*/ | |
bool QVariant::isNull() const | |
{ | |
return handler->isNull(&d); | |
} | |
#ifndef QT_NO_DEBUG_STREAM | |
QDebug operator<<(QDebug dbg, const QVariant &v) | |
{ | |
#ifndef Q_BROKEN_DEBUG_STREAM | |
dbg.nospace() << "QVariant(" << v.typeName() << ", "; | |
QVariant::handler->debugStream(dbg, v); | |
dbg.nospace() << ')'; | |
return dbg.space(); | |
#else | |
qWarning("This compiler doesn't support streaming QVariant to QDebug"); | |
return dbg; | |
Q_UNUSED(v); | |
#endif | |
} | |
QDebug operator<<(QDebug dbg, const QVariant::Type p) | |
{ | |
#ifndef Q_BROKEN_DEBUG_STREAM | |
dbg.nospace() << "QVariant::" << QVariant::typeToName(p); | |
return dbg.space(); | |
#else | |
qWarning("This compiler doesn't support streaming QVariant::Type to QDebug"); | |
return dbg; | |
Q_UNUSED(p); | |
#endif | |
} | |
#endif | |
/*! | |
\fn int &QVariant::asInt() | |
Use toInt() instead. | |
*/ | |
/*! | |
\fn uint &QVariant::asUInt() | |
Use toUInt() instead. | |
*/ | |
/*! | |
\fn qlonglong &QVariant::asLongLong() | |
Use toLongLong() instead. | |
*/ | |
/*! | |
\fn qulonglong &QVariant::asULongLong() | |
Use toULongLong() instead. | |
*/ | |
/*! | |
\fn bool &QVariant::asBool() | |
Use toBool() instead. | |
*/ | |
/*! | |
\fn double &QVariant::asDouble() | |
Use toDouble() instead. | |
*/ | |
/*! | |
\fn QByteArray &QVariant::asByteArray() | |
Use toByteArray() instead. | |
*/ | |
/*! | |
\fn QBitArray &QVariant::asBitArray() | |
Use toBitArray() instead. | |
*/ | |
/*! | |
\fn QString &QVariant::asString() | |
Use toString() instead. | |
*/ | |
/*! | |
\fn QStringList &QVariant::asStringList() | |
Use toStringList() instead. | |
*/ | |
/*! | |
\fn QDate &QVariant::asDate() | |
Use toDate() instead. | |
*/ | |
/*! | |
\fn QTime &QVariant::asTime() | |
Use toTime() instead. | |
*/ | |
/*! | |
\fn QDateTime &QVariant::asDateTime() | |
Use toDateTime() instead. | |
*/ | |
/*! | |
\fn QList<QVariant> &QVariant::asList() | |
Use toList() instead. | |
*/ | |
/*! | |
\fn QMap<QString, QVariant> &QVariant::asMap() | |
Use toMap() instead. | |
*/ | |
/*! | |
\fn QVariant::QVariant(bool b, int dummy) | |
Use the QVariant(bool) constructor instead. | |
*/ | |
/*! | |
\fn const QByteArray QVariant::toCString() const | |
Use toByteArray() instead. | |
*/ | |
/*! | |
\fn QByteArray &QVariant::asCString() | |
Use toByteArray() instead. | |
*/ | |
/*! | |
\fn QPoint &QVariant::asPoint() | |
Use toPoint() instead. | |
*/ | |
/*! | |
\fn QRect &QVariant::asRect() | |
Use toRect() instead. | |
*/ | |
/*! | |
\fn QSize &QVariant::asSize() | |
Use toSize() instead. | |
*/ | |
/*! \fn void QVariant::setValue(const T &value) | |
Stores a copy of \a value. If \c{T} is a type that QVariant | |
doesn't support, QMetaType is used to store the value. A compile | |
error will occur if QMetaType doesn't handle the type. | |
Example: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 4 | |
\warning This function is not available with MSVC 6. Use | |
qVariantSetValue() instead if you need to support that version of | |
the compiler. | |
\sa value(), fromValue(), canConvert() | |
*/ | |
/*! \fn T QVariant::value() const | |
Returns the stored value converted to the template type \c{T}. | |
Call canConvert() to find out whether a type can be converted. | |
If the value cannot be converted, \l{default-constructed value} | |
will be returned. | |
If the type \c{T} is supported by QVariant, this function behaves | |
exactly as toString(), toInt() etc. | |
Example: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 5 | |
\warning This function is not available with MSVC 6. Use | |
qVariantValue() or qvariant_cast() instead if you need to support | |
that version of the compiler. | |
\sa setValue(), fromValue(), canConvert() | |
*/ | |
/*! \fn bool QVariant::canConvert() const | |
Returns true if the variant can be converted to the template type \c{T}, | |
otherwise false. | |
Example: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 6 | |
\warning This function is not available with MSVC 6. Use | |
qVariantCanConvert() instead if you need to support that version | |
of the compiler. | |
\sa convert() | |
*/ | |
/*! \fn static QVariant QVariant::fromValue(const T &value) | |
Returns a QVariant containing a copy of \a value. Behaves | |
exactly like setValue() otherwise. | |
Example: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 7 | |
\note If you are working with custom types, you should use | |
the Q_DECLARE_METATYPE() macro to register your custom type. | |
\warning This function is not available with MSVC 6. Use | |
qVariantFromValue() instead if you need to support that version | |
of the compiler. | |
\sa setValue(), value() | |
*/ | |
/*! | |
\fn QVariant qVariantFromValue(const T &value) | |
\relates QVariant | |
Returns a variant containing a copy of the given \a value | |
with template type \c{T}. | |
This function is equivalent to QVariant::fromValue(\a value). It | |
is provided as a work-around for MSVC 6, which doesn't support | |
member template functions. | |
For example, a QObject pointer can be stored in a variant with the | |
following code: | |
\snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 8 | |
\sa QVariant::fromValue() | |
*/ | |
/*! \fn void qVariantSetValue(QVariant &variant, const T &value) | |
\relates QVariant | |
Sets the contents of the given \a variant to a copy of the | |
\a value with the specified template type \c{T}. | |
This function is equivalent to QVariant::setValue(\a value). It | |
is provided as a work-around for MSVC 6, which doesn't support | |
member template functions. | |
\sa QVariant::setValue() | |
*/ | |
/*! | |
\fn T qvariant_cast(const QVariant &value) | |
\relates QVariant | |
Returns the given \a value converted to the template type \c{T}. | |
This function is equivalent to qVariantValue(). | |
\sa qVariantValue(), QVariant::value() | |
*/ | |
/*! \fn T qVariantValue(const QVariant &value) | |
\relates QVariant | |
Returns the given \a value converted to the template type \c{T}. | |
This function is equivalent to | |
\l{QVariant::value()}{QVariant::value}<T>(\a value). It is | |
provided as a work-around for MSVC 6, which doesn't support | |
member template functions. | |
\sa QVariant::value(), qvariant_cast() | |
*/ | |
/*! \fn bool qVariantCanConvert(const QVariant &value) | |
\relates QVariant | |
Returns true if the given \a value can be converted to the | |
template type specified; otherwise returns false. | |
This function is equivalent to QVariant::canConvert(\a value). It | |
is provided as a work-around for MSVC 6, which doesn't support | |
member template functions. | |
\sa QVariant::canConvert() | |
*/ | |
/*! | |
\typedef QVariantList | |
\relates QVariant | |
Synonym for QList<QVariant>. | |
*/ | |
/*! | |
\typedef QVariantMap | |
\relates QVariant | |
Synonym for QMap<QString, QVariant>. | |
*/ | |
/*! | |
\typedef QVariantHash | |
\relates QVariant | |
\since 4.5 | |
Synonym for QHash<QString, QVariant>. | |
*/ | |
/*! | |
\typedef QVariant::DataPtr | |
\internal | |
*/ | |
/*! | |
\fn DataPtr &QVariant::data_ptr() | |
\internal | |
*/ | |
QT_END_NAMESPACE |