src/corelib/kernel/qvariant.cpp

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