1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtCore module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    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"

    49 #include "qlist.h"

    50 #include "qstring.h"

    51 #include "qstringlist.h"

    52 #include "qurl.h"

    53 #include "qlocale.h"

    54 #include "private/qvariant_p.h"

    55 

    56 #ifndef QT_NO_GEOM_VARIANT

    57 #include "qsize.h"

    58 #include "qpoint.h"

    59 #include "qrect.h"

    60 #include "qline.h"

    61 #endif

    62 

    63 #include <float.h>

    64 

    65 QT_BEGIN_NAMESPACE

    66 

    67 #ifndef DBL_DIG

    68 #  define DBL_DIG 10

    69 #endif

    70 #ifndef FLT_DIG

    71 #  define FLT_DIG 6

    72 #endif

    73 

    74 static void construct(QVariant::Private *x, const void *copy)

    75 {

    76     x->is_shared = false;

    77 

    78     switch (x->type) {

    79     case QVariant::String:

    80         v_construct<QString>(x, copy);

    81         break;

    82     case QVariant::Char:

    83         v_construct<QChar>(x, copy);

    84         break;

    85     case QVariant::StringList:

    86         v_construct<QStringList>(x, copy);

    87         break;

    88     case QVariant::Map:

    89         v_construct<QVariantMap>(x, copy);

    90         break;

    91     case QVariant::Hash:

    92         v_construct<QVariantHash>(x, copy);

    93         break;

    94     case QVariant::List:

    95         v_construct<QVariantList>(x, copy);

    96         break;

    97     case QVariant::Date:

    98         v_construct<QDate>(x, copy);

    99         break;

   100     case QVariant::Time:

   101         v_construct<QTime>(x, copy);

   102         break;

   103     case QVariant::DateTime:

   104         v_construct<QDateTime>(x, copy);

   105         break;

   106     case QVariant::ByteArray:

   107         v_construct<QByteArray>(x, copy);

   108         break;

   109     case QVariant::BitArray:

   110         v_construct<QBitArray>(x, copy);

   111         break;

   112 #ifndef QT_NO_GEOM_VARIANT

   113     case QVariant::Size:

   114         v_construct<QSize>(x, copy);

   115         break;

   116     case QVariant::SizeF:

   117         v_construct<QSizeF>(x, copy);

   118         break;

   119     case QVariant::Rect:

   120         v_construct<QRect>(x, copy);

   121         break;

   122     case QVariant::LineF:

   123         v_construct<QLineF>(x, copy);

   124         break;

   125     case QVariant::Line:

   126         v_construct<QLine>(x, copy);

   127         break;

   128     case QVariant::RectF:

   129         v_construct<QRectF>(x, copy);

   130         break;

   131     case QVariant::Point:

   132         v_construct<QPoint>(x, copy);

   133         break;

   134     case QVariant::PointF:

   135         v_construct<QPointF>(x, copy);

   136         break;

   137 #endif

   138     case QVariant::Url:

   139         v_construct<QUrl>(x, copy);

   140         break;

   141     case QVariant::Locale:

   142         v_construct<QLocale>(x, copy);

   143         break;

   144 #ifndef QT_NO_REGEXP

   145     case QVariant::RegExp:

   146         v_construct<QRegExp>(x, copy);

   147         break;

   148 #endif

   149     case QVariant::Int:

   150         x->data.i = copy ? *static_cast<const int *>(copy) : 0;

   151         break;

   152     case QVariant::UInt:

   153         x->data.u = copy ? *static_cast<const uint *>(copy) : 0u;

   154         break;

   155     case QVariant::Bool:

   156         x->data.b = copy ? *static_cast<const bool *>(copy) : false;

   157         break;

   158     case QVariant::Double:

   159         x->data.d = copy ? *static_cast<const double*>(copy) : 0.0;

   160         break;

   161     case QMetaType::Float:

   162         x->data.f = copy ? *static_cast<const float*>(copy) : 0.0f;

   163         break;

   164     case QMetaType::QObjectStar:

   165         x->data.o = copy ? *static_cast<QObject *const*>(copy) : 0;

   166         break;

   167     case QVariant::LongLong:

   168         x->data.ll = copy ? *static_cast<const qlonglong *>(copy) : Q_INT64_C(0);

   169         break;

   170     case QVariant::ULongLong:

   171         x->data.ull = copy ? *static_cast<const qulonglong *>(copy) : Q_UINT64_C(0);

   172         break;

   173     case QVariant::Invalid:

   174     case QVariant::UserType:

   175         break;

   176     default:

   177         void *ptr = QMetaType::construct(x->type, copy);

   178         if (!ptr) {

   179             x->type = QVariant::Invalid;

   180         } else {

   181             x->is_shared = true;

   182             x->data.shared = new QVariant::PrivateShared(ptr);

   183         }

   184         break;

   185     }

   186     x->is_null = !copy;

   187 }

   188 

   189 static void clear(QVariant::Private *d)

   190 {

   191     switch (d->type) {

   192     case QVariant::String:

   193         v_clear<QString>(d);

   194         break;

   195     case QVariant::Char:

   196         v_clear<QChar>(d);

   197         break;

   198     case QVariant::StringList:

   199         v_clear<QStringList>(d);

   200         break;

   201     case QVariant::Map:

   202         v_clear<QVariantMap>(d);

   203         break;

   204     case QVariant::Hash:

   205         v_clear<QVariantHash>(d);

   206         break;

   207     case QVariant::List:

   208         v_clear<QVariantList>(d);

   209         break;

   210     case QVariant::Date:

   211         v_clear<QDate>(d);

   212         break;

   213     case QVariant::Time:

   214         v_clear<QTime>(d);

   215         break;

   216     case QVariant::DateTime:

   217         v_clear<QDateTime>(d);

   218         break;

   219     case QVariant::ByteArray:

   220         v_clear<QByteArray>(d);

   221         break;

   222     case QVariant::BitArray:

   223         v_clear<QBitArray>(d);

   224         break;

   225 #ifndef QT_NO_GEOM_VARIANT

   226     case QVariant::Point:

   227         v_clear<QPoint>(d);

   228         break;

   229     case QVariant::PointF:

   230         v_clear<QPointF>(d);

   231         break;

   232     case QVariant::Size:

   233         v_clear<QSize>(d);

   234         break;

   235     case QVariant::SizeF:

   236         v_clear<QSizeF>(d);

   237         break;

   238     case QVariant::Rect:

   239         v_clear<QRect>(d);

   240         break;

   241     case QVariant::LineF:

   242         v_clear<QLineF>(d);

   243         break;

   244     case QVariant::Line:

   245         v_clear<QLine>(d);

   246         break;

   247     case QVariant::RectF:

   248         v_clear<QRectF>(d);

   249         break;

   250 #endif

   251     case QVariant::Url:

   252         v_clear<QUrl>(d);

   253         break;

   254     case QVariant::Locale:

   255         v_clear<QLocale>(d);

   256         break;

   257 #ifndef QT_NO_REGEXP

   258     case QVariant::RegExp:

   259         v_clear<QRegExp>(d);

   260         break;

   261 #endif

   262     case QVariant::LongLong:

   263     case QVariant::ULongLong:

   264     case QVariant::Double:

   265     case QMetaType::Float:

   266     case QMetaType::QObjectStar:

   267         break;

   268     case QVariant::Invalid:

   269     case QVariant::UserType:

   270     case QVariant::Int:

   271     case QVariant::UInt:

   272     case QVariant::Bool:

   273         break;

   274     default:

   275         QMetaType::destroy(d->type, d->data.shared->ptr);

   276         delete d->data.shared;

   277         break;

   278     }

   279 

   280     d->type = QVariant::Invalid;

   281     d->is_null = true;

   282     d->is_shared = false;

   283 }

   284 

   285 static bool isNull(const QVariant::Private *d)

   286 {

   287     switch(d->type) {

   288     case QVariant::String:

   289         return v_cast<QString>(d)->isNull();

   290     case QVariant::Char:

   291         return v_cast<QChar>(d)->isNull();

   292     case QVariant::Date:

   293         return v_cast<QDate>(d)->isNull();

   294     case QVariant::Time:

   295         return v_cast<QTime>(d)->isNull();

   296     case QVariant::DateTime:

   297         return v_cast<QDateTime>(d)->isNull();

   298     case QVariant::ByteArray:

   299         return v_cast<QByteArray>(d)->isNull();

   300     case QVariant::BitArray:

   301         return v_cast<QBitArray>(d)->isNull();

   302 #ifndef QT_NO_GEOM_VARIANT

   303     case QVariant::Size:

   304         return v_cast<QSize>(d)->isNull();

   305     case QVariant::SizeF:

   306         return v_cast<QSizeF>(d)->isNull();

   307     case QVariant::Rect:

   308         return v_cast<QRect>(d)->isNull();

   309     case QVariant::Line:

   310         return v_cast<QLine>(d)->isNull();

   311     case QVariant::LineF:

   312         return v_cast<QLineF>(d)->isNull();

   313     case QVariant::RectF:

   314         return v_cast<QRectF>(d)->isNull();

   315     case QVariant::Point:

   316         return v_cast<QPoint>(d)->isNull();

   317     case QVariant::PointF:

   318         return v_cast<QPointF>(d)->isNull();

   319 #endif

   320     case QVariant::Url:

   321     case QVariant::Locale:

   322     case QVariant::RegExp:

   323     case QVariant::StringList:

   324     case QVariant::Map:

   325     case QVariant::Hash:

   326     case QVariant::List:

   327     case QVariant::Invalid:

   328     case QVariant::UserType:

   329     case QVariant::Int:

   330     case QVariant::UInt:

   331     case QVariant::LongLong:

   332     case QVariant::ULongLong:

   333     case QVariant::Bool:

   334     case QVariant::Double:

   335     case QMetaType::Float:

   336     case QMetaType::QObjectStar:

   337         break;

   338     }

   339     return d->is_null;

   340 }

   341 

   342 /*

   343   \internal

   344   \since 4.4

   345 

   346   We cannot use v_cast() for QMetaType's numeric types because they're smaller than QVariant::Private::Data,

   347   which in turns makes v_cast() believe the value is stored in d->data.c. But

   348   it's not, since we're a QMetaType type.

   349  */

   350 template<typename T>

   351 inline bool compareNumericMetaType(const QVariant::Private *const a, const QVariant::Private *const b)

   352 {

   353     return *static_cast<const T *>(a->data.shared->ptr) == *static_cast<const T *>(b->data.shared->ptr);

   354 }

   355 

   356 /*!

   357   \internal

   358 

   359   Compares \a a to \a b. The caller guarantees that \a a and \a b

   360   are of the same type.

   361  */

   362 static bool compare(const QVariant::Private *a, const QVariant::Private *b)

   363 {

   364     switch(a->type) {

   365     case QVariant::List:

   366         return *v_cast<QVariantList>(a) == *v_cast<QVariantList>(b);

   367     case QVariant::Map: {

   368         const QVariantMap *m1 = v_cast<QVariantMap>(a);

   369         const QVariantMap *m2 = v_cast<QVariantMap>(b);

   370         if (m1->count() != m2->count())

   371             return false;

   372         QVariantMap::ConstIterator it = m1->constBegin();

   373         QVariantMap::ConstIterator it2 = m2->constBegin();

   374         while (it != m1->constEnd()) {

   375             if (*it != *it2 || it.key() != it2.key())

   376                 return false;

   377             ++it;

   378             ++it2;

   379         }

   380         return true;

   381     }

   382     case QVariant::Hash:

   383         return *v_cast<QVariantHash>(a) == *v_cast<QVariantHash>(b);

   384     case QVariant::String:

   385         return *v_cast<QString>(a) == *v_cast<QString>(b);

   386     case QVariant::Char:

   387         return *v_cast<QChar>(a) == *v_cast<QChar>(b);

   388     case QVariant::StringList:

   389         return *v_cast<QStringList>(a) == *v_cast<QStringList>(b);

   390 #ifndef QT_NO_GEOM_VARIANT

   391     case QVariant::Size:

   392         return *v_cast<QSize>(a) == *v_cast<QSize>(b);

   393     case QVariant::SizeF:

   394         return *v_cast<QSizeF>(a) == *v_cast<QSizeF>(b);

   395     case QVariant::Rect:

   396         return *v_cast<QRect>(a) == *v_cast<QRect>(b);

   397     case QVariant::Line:

   398         return *v_cast<QLine>(a) == *v_cast<QLine>(b);

   399     case QVariant::LineF:

   400         return *v_cast<QLineF>(a) == *v_cast<QLineF>(b);

   401     case QVariant::RectF:

   402         return *v_cast<QRectF>(a) == *v_cast<QRectF>(b);

   403     case QVariant::Point:

   404         return *v_cast<QPoint>(a) == *v_cast<QPoint>(b);

   405     case QVariant::PointF:

   406         return *v_cast<QPointF>(a) == *v_cast<QPointF>(b);

   407 #endif

   408     case QVariant::Url:

   409         return *v_cast<QUrl>(a) == *v_cast<QUrl>(b);

   410     case QVariant::Locale:

   411         return *v_cast<QLocale>(a) == *v_cast<QLocale>(b);

   412 #ifndef QT_NO_REGEXP

   413     case QVariant::RegExp:

   414         return *v_cast<QRegExp>(a) == *v_cast<QRegExp>(b);

   415 #endif

   416     case QVariant::Int:

   417         return a->data.i == b->data.i;

   418     case QVariant::UInt:

   419         return a->data.u == b->data.u;

   420     case QVariant::LongLong:

   421         return a->data.ll == b->data.ll;

   422     case QVariant::ULongLong:

   423         return a->data.ull == b->data.ull;

   424     case QVariant::Bool:

   425         return a->data.b == b->data.b;

   426     case QVariant::Double:

   427         return a->data.d == b->data.d;

   428     case QMetaType::Float:

   429         return a->data.f == b->data.f;

   430     case QMetaType::QObjectStar:

   431         return a->data.o == b->data.o;

   432     case QVariant::Date:

   433         return *v_cast<QDate>(a) == *v_cast<QDate>(b);

   434     case QVariant::Time:

   435         return *v_cast<QTime>(a) == *v_cast<QTime>(b);

   436     case QVariant::DateTime:

   437         return *v_cast<QDateTime>(a) == *v_cast<QDateTime>(b);

   438     case QVariant::ByteArray:

   439         return *v_cast<QByteArray>(a) == *v_cast<QByteArray>(b);

   440     case QVariant::BitArray:

   441         return *v_cast<QBitArray>(a) == *v_cast<QBitArray>(b);

   442     case QVariant::Invalid:

   443         return true;

   444     case QMetaType::Long:

   445         return compareNumericMetaType<long>(a, b);

   446     case QMetaType::ULong:

   447         return compareNumericMetaType<ulong>(a, b);

   448     case QMetaType::Short:

   449         return compareNumericMetaType<short>(a, b);

   450     case QMetaType::UShort:

   451         return compareNumericMetaType<ushort>(a, b);

   452     case QMetaType::UChar:

   453         return compareNumericMetaType<uchar>(a, b);

   454     case QMetaType::Char:

   455         return compareNumericMetaType<char>(a, b);

   456     default:

   457         break;

   458     }

   459     if (!QMetaType::isRegistered(a->type))

   460         qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);

   461 

   462     const void *a_ptr = a->is_shared ? a->data.shared->ptr : &(a->data.ptr);

   463     const void *b_ptr = b->is_shared ? b->data.shared->ptr : &(b->data.ptr);

   464 

   465     /* The reason we cannot place this test in a case branch above for the types

   466      * QMetaType::VoidStar, QMetaType::QObjectStar and so forth, is that it wouldn't include

   467      * user defined pointer types. */

   468     const char *const typeName = QMetaType::typeName(a->type);

   469     if (typeName[qstrlen(typeName) - 1] == '*')

   470         return *static_cast<void *const *>(a_ptr) == *static_cast<void *const *>(b_ptr);

   471 

   472     return a_ptr == b_ptr;

   473 }

   474 

   475 /*!

   476   \internal

   477  */

   478 static qlonglong qMetaTypeNumber(const QVariant::Private *d)

   479 {

   480     switch (d->type) {

   481     case QMetaType::Int:

   482         return d->data.i;

   483     case QMetaType::LongLong:

   484         return d->data.ll;

   485     case QMetaType::Char:

   486         return qlonglong(*static_cast<signed char *>(d->data.shared->ptr));

   487     case QMetaType::Short:

   488         return qlonglong(*static_cast<short *>(d->data.shared->ptr));

   489     case QMetaType::Long:

   490         return qlonglong(*static_cast<long *>(d->data.shared->ptr));

   491     case QMetaType::Float:

   492         return qRound64(d->data.f);

   493     case QVariant::Double:

   494         return qRound64(d->data.d);

   495     }

   496     Q_ASSERT(false);

   497     return 0;

   498 }

   499 

   500 static qulonglong qMetaTypeUNumber(const QVariant::Private *d)

   501 {

   502     switch (d->type) {

   503     case QVariant::UInt:

   504         return d->data.u;

   505     case QVariant::ULongLong:

   506         return d->data.ull;

   507     case QMetaType::UChar:

   508         return qulonglong(*static_cast<unsigned char *>(d->data.shared->ptr));

   509     case QMetaType::UShort:

   510         return qulonglong(*static_cast<ushort *>(d->data.shared->ptr));

   511     case QMetaType::ULong:

   512         return qulonglong(*static_cast<ulong *>(d->data.shared->ptr));

   513     }

   514     Q_ASSERT(false);

   515     return 0;

   516 }

   517 

   518 static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)

   519 {

   520     *ok = true;

   521 

   522     switch (uint(d->type)) {

   523     case QVariant::String:

   524         return v_cast<QString>(d)->toLongLong(ok);

   525     case QVariant::Char:

   526         return v_cast<QChar>(d)->unicode();

   527     case QVariant::ByteArray:

   528         return v_cast<QByteArray>(d)->toLongLong(ok);

   529     case QVariant::Bool:

   530         return qlonglong(d->data.b);

   531     case QVariant::Double:

   532     case QVariant::Int:

   533     case QMetaType::Char:

   534     case QMetaType::Short:

   535     case QMetaType::Long:

   536     case QMetaType::Float:

   537     case QMetaType::LongLong:

   538         return qMetaTypeNumber(d);

   539     case QVariant::ULongLong:

   540     case QVariant::UInt:

   541     case QMetaType::UChar:

   542     case QMetaType::UShort:

   543     case QMetaType::ULong:

   544         return qlonglong(qMetaTypeUNumber(d));

   545     }

   546 

   547     *ok = false;

   548     return Q_INT64_C(0);

   549 }

   550 

   551 static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)

   552 {

   553     *ok = true;

   554 

   555     switch (uint(d->type)) {

   556     case QVariant::String:

   557         return v_cast<QString>(d)->toULongLong(ok);

   558     case QVariant::Char:

   559         return v_cast<QChar>(d)->unicode();

   560     case QVariant::ByteArray:

   561         return v_cast<QByteArray>(d)->toULongLong(ok);

   562     case QVariant::Bool:

   563         return qulonglong(d->data.b);

   564     case QVariant::Double:

   565     case QVariant::Int:

   566     case QMetaType::Char:

   567     case QMetaType::Short:

   568     case QMetaType::Long:

   569     case QMetaType::Float:

   570     case QMetaType::LongLong:

   571         return qulonglong(qMetaTypeNumber(d));

   572     case QVariant::ULongLong:

   573     case QVariant::UInt:

   574     case QMetaType::UChar:

   575     case QMetaType::UShort:

   576     case QMetaType::ULong:

   577         return qMetaTypeUNumber(d);

   578     }

   579 

   580     *ok = false;

   581     return Q_UINT64_C(0);

   582 }

   583 

   584 template<typename TInput, typename LiteralWrapper>

   585 inline bool qt_convertToBool(const QVariant::Private *const d)

   586 {

   587     TInput str = v_cast<TInput>(d)->toLower();

   588     return !(str == LiteralWrapper("0") || str == LiteralWrapper("false") || str.isEmpty());

   589 }

   590 

   591 /*!

   592  \internal

   593 

   594  Converts \a d to type \a t, which is placed in \a result.

   595  */

   596 static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, bool *ok)

   597 {

   598     Q_ASSERT(d->type != uint(t));

   599     Q_ASSERT(result);

   600 

   601     bool dummy;

   602     if (!ok)

   603         ok = &dummy;

   604 

   605     switch (uint(t)) {

   606     case QVariant::Url:

   607         switch (d->type) {

   608         case QVariant::String:

   609             *static_cast<QUrl *>(result) = QUrl(*v_cast<QString>(d));

   610             break;

   611         default:

   612             return false;

   613         }

   614         break;

   615     case QVariant::String: {

   616         QString *str = static_cast<QString *>(result);

   617         switch (d->type) {

   618         case QVariant::Char:

   619             *str = QString(*v_cast<QChar>(d));

   620             break;

   621         case QMetaType::Char:

   622         case QMetaType::UChar:

   623             *str = QChar::fromAscii(*static_cast<char *>(d->data.shared->ptr));

   624             break;

   625         case QMetaType::Short:

   626         case QMetaType::Long:

   627         case QVariant::Int:

   628         case QVariant::LongLong:

   629             *str = QString::number(qMetaTypeNumber(d));

   630             break;

   631         case QVariant::UInt:

   632         case QVariant::ULongLong:

   633         case QMetaType::UShort:

   634         case QMetaType::ULong:

   635             *str = QString::number(qMetaTypeUNumber(d));

   636             break;

   637         case QMetaType::Float:

   638             *str = QString::number(d->data.f, 'g', FLT_DIG);

   639             break;

   640         case QVariant::Double:

   641             *str = QString::number(d->data.d, 'g', DBL_DIG);

   642             break;

   643 #if !defined(QT_NO_DATESTRING)

   644         case QVariant::Date:

   645             *str = v_cast<QDate>(d)->toString(Qt::ISODate);

   646             break;

   647         case QVariant::Time:

   648             *str = v_cast<QTime>(d)->toString(Qt::ISODate);

   649             break;

   650         case QVariant::DateTime:

   651             *str = v_cast<QDateTime>(d)->toString(Qt::ISODate);

   652             break;

   653 #endif

   654         case QVariant::Bool:

   655             *str = QLatin1String(d->data.b ? "true" : "false");

   656             break;

   657         case QVariant::ByteArray:

   658             *str = QString::fromAscii(v_cast<QByteArray>(d)->constData());

   659             break;

   660         case QVariant::StringList:

   661             if (v_cast<QStringList>(d)->count() == 1)

   662                 *str = v_cast<QStringList>(d)->at(0);

   663             break;

   664         case QVariant::Url:

   665             *str = v_cast<QUrl>(d)->toString();

   666             break;

   667         default:

   668             return false;

   669         }

   670         break;

   671     }

   672     case QVariant::Char: {

   673         QChar *c = static_cast<QChar *>(result);

   674         switch (d->type) {

   675         case QVariant::Int:

   676         case QVariant::LongLong:

   677         case QMetaType::Char:

   678         case QMetaType::Short:

   679         case QMetaType::Long:

   680         case QMetaType::Float:

   681             *c = QChar(ushort(qMetaTypeNumber(d)));

   682             break;

   683         case QVariant::UInt:

   684         case QVariant::ULongLong:

   685         case QMetaType::UChar:

   686         case QMetaType::UShort:

   687         case QMetaType::ULong:

   688             *c = QChar(ushort(qMetaTypeUNumber(d)));

   689             break;

   690         default:

   691             return false;

   692         }

   693         break;

   694     }

   695 #ifndef QT_NO_GEOM_VARIANT

   696     case QVariant::Size: {

   697         QSize *s = static_cast<QSize *>(result);

   698         switch (d->type) {

   699         case QVariant::SizeF:

   700             *s = v_cast<QSizeF>(d)->toSize();

   701             break;

   702         default:

   703             return false;

   704         }

   705         break;

   706     }

   707 

   708     case QVariant::SizeF: {

   709         QSizeF *s = static_cast<QSizeF *>(result);

   710         switch (d->type) {

   711         case QVariant::Size:

   712             *s = QSizeF(*(v_cast<QSize>(d)));

   713             break;

   714         default:

   715             return false;

   716         }

   717         break;

   718     }

   719 

   720     case QVariant::Line: {

   721         QLine *s = static_cast<QLine *>(result);

   722         switch (d->type) {

   723         case QVariant::LineF:

   724             *s = v_cast<QLineF>(d)->toLine();

   725             break;

   726         default:

   727             return false;

   728         }

   729         break;

   730     }

   731 

   732     case QVariant::LineF: {

   733         QLineF *s = static_cast<QLineF *>(result);

   734         switch (d->type) {

   735         case QVariant::Line:

   736             *s = QLineF(*(v_cast<QLine>(d)));

   737             break;

   738         default:

   739             return false;

   740         }

   741         break;

   742     }

   743 #endif

   744     case QVariant::StringList:

   745         if (d->type == QVariant::List) {

   746             QStringList *slst = static_cast<QStringList *>(result);

   747             const QVariantList *list = v_cast<QVariantList >(d);

   748             for (int i = 0; i < list->size(); ++i)

   749                 slst->append(list->at(i).toString());

   750         } else if (d->type == QVariant::String) {

   751             QStringList *slst = static_cast<QStringList *>(result);

   752             *slst = QStringList(*v_cast<QString>(d));

   753         } else {

   754             return false;

   755         }

   756         break;

   757     case QVariant::Date: {

   758         QDate *dt = static_cast<QDate *>(result);

   759         if (d->type == QVariant::DateTime)

   760             *dt = v_cast<QDateTime>(d)->date();

   761 #ifndef QT_NO_DATESTRING

   762         else if (d->type == QVariant::String)

   763             *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);

   764 #endif

   765         else

   766             return false;

   767 

   768         return dt->isValid();

   769     }

   770     case QVariant::Time: {

   771         QTime *t = static_cast<QTime *>(result);

   772         switch (d->type) {

   773         case QVariant::DateTime:

   774             *t = v_cast<QDateTime>(d)->time();

   775             break;

   776 #ifndef QT_NO_DATESTRING

   777         case QVariant::String:

   778             *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);

   779             break;

   780 #endif

   781         default:

   782             return false;

   783         }

   784         return t->isValid();

   785     }

   786     case QVariant::DateTime: {

   787         QDateTime *dt = static_cast<QDateTime *>(result);

   788         switch (d->type) {

   789 #ifndef QT_NO_DATESTRING

   790         case QVariant::String:

   791             *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);

   792             break;

   793 #endif

   794         case QVariant::Date:

   795             *dt = QDateTime(*v_cast<QDate>(d));

   796             break;

   797         default:

   798             return false;

   799         }

   800         return dt->isValid();

   801     }

   802     case QVariant::ByteArray: {

   803         QByteArray *ba = static_cast<QByteArray *>(result);

   804         switch (d->type) {

   805         case QVariant::String:

   806             *ba = v_cast<QString>(d)->toAscii();

   807             break;

   808         case QVariant::Double:

   809             *ba = QByteArray::number(d->data.d, 'g', DBL_DIG);

   810             break;

   811         case QMetaType::Float:

   812             *ba = QByteArray::number(d->data.f, 'g', FLT_DIG);

   813             break;

   814         case QMetaType::Char:

   815         case QMetaType::UChar:

   816             *ba = QByteArray(1, *static_cast<char *>(d->data.shared->ptr));

   817             break;

   818         case QVariant::Int:

   819         case QVariant::LongLong:

   820         case QMetaType::Short:

   821         case QMetaType::Long:

   822             *ba = QByteArray::number(qMetaTypeNumber(d));

   823             break;

   824         case QVariant::UInt:

   825         case QVariant::ULongLong:

   826         case QMetaType::UShort:

   827         case QMetaType::ULong:

   828             *ba = QByteArray::number(qMetaTypeUNumber(d));

   829             break;

   830         case QVariant::Bool:

   831             *ba = QByteArray(d->data.b ? "true" : "false");

   832             break;

   833         default:

   834             return false;

   835         }

   836     }

   837     break;

   838     case QMetaType::Short:

   839         *static_cast<short *>(result) = short(qConvertToNumber(d, ok));

   840         return *ok;

   841     case QMetaType::Long:

   842         *static_cast<long *>(result) = long(qConvertToNumber(d, ok));

   843         return *ok;

   844     case QMetaType::UShort:

   845         *static_cast<ushort *>(result) = ushort(qConvertToUnsignedNumber(d, ok));

   846         return *ok;

   847     case QMetaType::ULong:

   848         *static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok));

   849         return *ok;

   850     case QVariant::Int:

   851         *static_cast<int *>(result) = int(qConvertToNumber(d, ok));

   852         return *ok;

   853     case QVariant::UInt:

   854         *static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok));

   855         return *ok;

   856     case QVariant::LongLong:

   857         *static_cast<qlonglong *>(result) = qConvertToNumber(d, ok);

   858         return *ok;

   859     case QVariant::ULongLong: {

   860         *static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok);

   861         return *ok;

   862     }

   863     case QMetaType::UChar: {

   864         *static_cast<uchar *>(result) = qConvertToUnsignedNumber(d, ok);

   865         return *ok;

   866     }

   867     case QVariant::Bool: {

   868         bool *b = static_cast<bool *>(result);

   869         switch(d->type) {

   870         case QVariant::ByteArray:

   871             *b = qt_convertToBool<QByteArray, QByteArray>(d);

   872             break;

   873         case QVariant::String:

   874             *b = qt_convertToBool<QString, QLatin1String>(d);

   875             break;

   876         case QVariant::Char:

   877             *b = !v_cast<QChar>(d)->isNull();

   878             break;

   879         case QVariant::Double:

   880         case QVariant::Int:

   881         case QVariant::LongLong:

   882         case QMetaType::Char:

   883         case QMetaType::Short:

   884         case QMetaType::Long:

   885         case QMetaType::Float:

   886             *b = qMetaTypeNumber(d) != Q_INT64_C(0);

   887             break;

   888         case QVariant::UInt:

   889         case QVariant::ULongLong:

   890         case QMetaType::UChar:

   891         case QMetaType::UShort:

   892         case QMetaType::ULong:

   893             *b = qMetaTypeUNumber(d) != Q_UINT64_C(0);

   894             break;

   895         default:

   896             *b = false;

   897             return false;

   898         }

   899         break;

   900     }

   901     case QVariant::Double: {

   902         double *f = static_cast<double *>(result);

   903         switch (d->type) {

   904         case QVariant::String:

   905             *f = v_cast<QString>(d)->toDouble(ok);

   906             break;

   907         case QVariant::ByteArray:

   908             *f = v_cast<QByteArray>(d)->toDouble(ok);

   909             break;

   910         case QVariant::Bool:

   911             *f = double(d->data.b);

   912             break;

   913         case QMetaType::Float:

   914             *f = double(d->data.f);

   915             break;

   916         case QVariant::LongLong:

   917         case QVariant::Int:

   918         case QMetaType::Char:

   919         case QMetaType::Short:

   920         case QMetaType::Long:

   921             *f = double(qMetaTypeNumber(d));

   922             break;

   923         case QVariant::UInt:

   924         case QVariant::ULongLong:

   925         case QMetaType::UChar:

   926         case QMetaType::UShort:

   927         case QMetaType::ULong:

   928 #if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET)

   929             *f = (double)(qlonglong)qMetaTypeUNumber(d);

   930 #else

   931             *f = double(qMetaTypeUNumber(d));

   932 #endif

   933             break;

   934         default:

   935             *f = 0.0;

   936             return false;

   937         }

   938         break;

   939     }

   940     case QMetaType::Float: {

   941         float *f = static_cast<float *>(result);

   942         switch (d->type) {

   943         case QVariant::String:

   944             *f = v_cast<QString>(d)->toFloat(ok);

   945             break;

   946         case QVariant::ByteArray:

   947             *f = v_cast<QByteArray>(d)->toFloat(ok);

   948             break;

   949         case QVariant::Bool:

   950             *f = float(d->data.b);

   951             break;

   952         case QVariant::Double:

   953             *f = float(d->data.d);

   954             break;

   955         case QVariant::LongLong:

   956         case QVariant::Int:

   957         case QMetaType::Char:

   958         case QMetaType::Short:

   959         case QMetaType::Long:

   960             *f = float(qMetaTypeNumber(d));

   961             break;

   962         case QVariant::UInt:

   963         case QVariant::ULongLong:

   964         case QMetaType::UChar:

   965         case QMetaType::UShort:

   966         case QMetaType::ULong:

   967 #if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET)

   968             *f = (float)(qlonglong)qMetaTypeUNumber(d);

   969 #else

   970             *f = float(qMetaTypeUNumber(d));

   971 #endif

   972             break;

   973         default:

   974             *f = 0.0f;

   975             return false;

   976         }

   977         break;

   978     }

   979     case QVariant::List:

   980         if (d->type == QVariant::StringList) {

   981             QVariantList *lst = static_cast<QVariantList *>(result);

   982             const QStringList *slist = v_cast<QStringList>(d);

   983             for (int i = 0; i < slist->size(); ++i)

   984                 lst->append(QVariant(slist->at(i)));

   985         } else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {

   986             *static_cast<QVariantList *>(result) =

   987                 *static_cast<QList<QVariant> *>(d->data.shared->ptr);

   988         } else {

   989             return false;

   990         }

   991         break;

   992     case QVariant::Map:

   993         if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {

   994             *static_cast<QVariantMap *>(result) =

   995                 *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);

   996         } else {

   997             return false;

   998         }

   999         break;

  1000     case QVariant::Hash:

  1001         if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) {

  1002             *static_cast<QVariantHash *>(result) =

  1003                 *static_cast<QHash<QString, QVariant> *>(d->data.shared->ptr);

  1004         } else {

  1005             return false;

  1006         }

  1007         break;

  1008 #ifndef QT_NO_GEOM_VARIANT

  1009     case QVariant::Rect:

  1010         if (d->type == QVariant::RectF)

  1011             *static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect();

  1012         else

  1013             return false;

  1014         break;

  1015     case QVariant::RectF:

  1016         if (d->type == QVariant::Rect)

  1017             *static_cast<QRectF *>(result) = *v_cast<QRect>(d);

  1018         else

  1019             return false;

  1020         break;

  1021     case QVariant::PointF:

  1022         if (d->type == QVariant::Point)

  1023             *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);

  1024         else

  1025             return false;

  1026         break;

  1027     case QVariant::Point:

  1028         if (d->type == QVariant::PointF)

  1029             *static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint();

  1030         else

  1031             return false;

  1032         break;

  1033     case QMetaType::Char:

  1034     {

  1035         *static_cast<qint8 *>(result) = qint8(qConvertToNumber(d, ok));

  1036         return *ok;

  1037     }

  1038 #endif

  1039     default:

  1040         return false;

  1041     }

  1042     return true;

  1043 }

  1044 

  1045 #if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)

  1046 static void streamDebug(QDebug dbg, const QVariant &v)

  1047 {

  1048     switch (v.userType()) {

  1049     case QVariant::Int:

  1050         dbg.nospace() << v.toInt();

  1051         break;

  1052     case QVariant::UInt:

  1053         dbg.nospace() << v.toUInt();

  1054         break;

  1055     case QVariant::LongLong:

  1056         dbg.nospace() << v.toLongLong();

  1057         break;

  1058     case QVariant::ULongLong:

  1059         dbg.nospace() << v.toULongLong();

  1060         break;

  1061     case QMetaType::Float:

  1062         dbg.nospace() << v.toFloat();

  1063         break;

  1064     case QMetaType::QObjectStar:

  1065         dbg.nospace() << qVariantValue<QObject *>(v);

  1066         break;

  1067     case QVariant::Double:

  1068         dbg.nospace() << v.toDouble();

  1069         break;

  1070     case QVariant::Bool:

  1071         dbg.nospace() << v.toBool();

  1072         break;

  1073     case QVariant::String:

  1074         dbg.nospace() << v.toString();

  1075         break;

  1076     case QVariant::Char:

  1077         dbg.nospace() << v.toChar();

  1078         break;

  1079     case QVariant::StringList:

  1080         dbg.nospace() << v.toStringList();

  1081         break;

  1082     case QVariant::Map:

  1083         dbg.nospace() << v.toMap();

  1084         break;

  1085     case QVariant::Hash:

  1086         dbg.nospace() << v.toHash();

  1087         break;

  1088     case QVariant::List:

  1089         dbg.nospace() << v.toList();

  1090         break;

  1091     case QVariant::Date:

  1092         dbg.nospace() << v.toDate();

  1093         break;

  1094     case QVariant::Time:

  1095         dbg.nospace() << v.toTime();

  1096         break;

  1097     case QVariant::DateTime:

  1098         dbg.nospace() << v.toDateTime();

  1099         break;

  1100     case QVariant::ByteArray:

  1101         dbg.nospace() << v.toByteArray();

  1102         break;

  1103     case QVariant::Url:

  1104         dbg.nospace() << v.toUrl();

  1105         break;

  1106 #ifndef QT_NO_GEOM_VARIANT

  1107     case QVariant::Point:

  1108         dbg.nospace() << v.toPoint();

  1109         break;

  1110     case QVariant::PointF:

  1111         dbg.nospace() << v.toPointF();

  1112         break;

  1113     case QVariant::Rect:

  1114         dbg.nospace() << v.toRect();

  1115         break;

  1116     case QVariant::Size:

  1117         dbg.nospace() << v.toSize();

  1118         break;

  1119     case QVariant::SizeF:

  1120         dbg.nospace() << v.toSizeF();

  1121         break;

  1122     case QVariant::Line:

  1123         dbg.nospace() << v.toLine();

  1124         break;

  1125     case QVariant::LineF:

  1126         dbg.nospace() << v.toLineF();

  1127         break;

  1128     case QVariant::RectF:

  1129         dbg.nospace() << v.toRectF();

  1130         break;

  1131 #endif

  1132     case QVariant::BitArray:

  1133         //dbg.nospace() << v.toBitArray();

  1134         break;