/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this

** file. Please review the following information to ensure the GNU Lesser

** General Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

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

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

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

**

** GNU General Public License Usage

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

** Public License version 3.0 as published by the Free Software Foundation

** and appearing in the file LICENSE.GPL included in the packaging of this

** file. Please review the following information to ensure the GNU General

** Public License version 3.0 requirements will be met:

** http://www.gnu.org/copyleft/gpl.html.

**

** Other Usage

** Alternatively, this file may be used in accordance with the terms and

** conditions contained in a signed written agreement between you and Nokia.

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qvariant.h"

#include "qbitarray.h"

#include "qbytearray.h"

#include "qdatastream.h"

#include "qdebug.h"

#include "qmap.h"

#include "qdatetime.h"

#include "qeasingcurve.h"

#include "qlist.h"

#include "qstring.h"

#include "qstringlist.h"

#include "qurl.h"

#include "qlocale.h"

#include "private/qvariant_p.h"

#ifndef QT_NO_GEOM_VARIANT

#include "qsize.h"

#include "qpoint.h"

#include "qrect.h"

#include "qline.h"

#endif

#include <float.h>

QT_BEGIN_NAMESPACE

#ifndef DBL_DIG

#  define DBL_DIG 10

#endif

#ifndef FLT_DIG

#  define FLT_DIG 6

#endif

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

{

    x->is_shared = false;

    switch (x->type) {

    case QVariant::String:

        v_construct<QString>(x, copy);

        break;

    case QVariant::Char:

        v_construct<QChar>(x, copy);

        break;

    case QVariant::StringList:

        v_construct<QStringList>(x, copy);

        break;

    case QVariant::Map:

        v_construct<QVariantMap>(x, copy);

        break;

    case QVariant::Hash:

        v_construct<QVariantHash>(x, copy);

        break;

    case QVariant::List:

        v_construct<QVariantList>(x, copy);

        break;

    case QVariant::Date:

        v_construct<QDate>(x, copy);

        break;

    case QVariant::Time:

        v_construct<QTime>(x, copy);

        break;

    case QVariant::DateTime:

        v_construct<QDateTime>(x, copy);

        break;

    case QVariant::ByteArray:

        v_construct<QByteArray>(x, copy);

        break;

    case QVariant::BitArray:

        v_construct<QBitArray>(x, copy);

        break;

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Size:

        v_construct<QSize>(x, copy);

        break;

    case QVariant::SizeF:

        v_construct<QSizeF>(x, copy);

        break;

    case QVariant::Rect:

        v_construct<QRect>(x, copy);

        break;

    case QVariant::LineF:

        v_construct<QLineF>(x, copy);

        break;

    case QVariant::Line:

        v_construct<QLine>(x, copy);

        break;

    case QVariant::RectF:

        v_construct<QRectF>(x, copy);

        break;

    case QVariant::Point:

        v_construct<QPoint>(x, copy);

        break;

    case QVariant::PointF:

        v_construct<QPointF>(x, copy);

        break;

#endif

    case QVariant::Url:

        v_construct<QUrl>(x, copy);

        break;

    case QVariant::Locale:

        v_construct<QLocale>(x, copy);

        break;

#ifndef QT_NO_REGEXP

    case QVariant::RegExp:

        v_construct<QRegExp>(x, copy);

        break;

#endif

#ifndef QT_BOOTSTRAPPED

    case QVariant::EasingCurve:

        v_construct<QEasingCurve>(x, copy);

        break;

#endif

    case QVariant::Int:

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

        break;

    case QVariant::UInt:

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

        break;

    case QVariant::Bool:

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

        break;

    case QVariant::Double:

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

        break;

    case QMetaType::Float:

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

        break;

    case QMetaType::QObjectStar:

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

        break;

    case QVariant::LongLong:

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

        break;

    case QVariant::ULongLong:

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

        break;

    case QVariant::Invalid:

    case QVariant::UserType:

        break;

    default:

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

        if (!ptr) {

            x->type = QVariant::Invalid;

        } else {

            x->is_shared = true;

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

        }

        break;

    }

    x->is_null = !copy;

}

static void clear(QVariant::Private *d)

{

    switch (d->type) {

    case QVariant::String:

        v_clear<QString>(d);

        break;

    case QVariant::Char:

        v_clear<QChar>(d);

        break;

    case QVariant::StringList:

        v_clear<QStringList>(d);

        break;

    case QVariant::Map:

        v_clear<QVariantMap>(d);

        break;

    case QVariant::Hash:

        v_clear<QVariantHash>(d);

        break;

    case QVariant::List:

        v_clear<QVariantList>(d);

        break;

    case QVariant::Date:

        v_clear<QDate>(d);

        break;

    case QVariant::Time:

        v_clear<QTime>(d);

        break;

    case QVariant::DateTime:

        v_clear<QDateTime>(d);

        break;

    case QVariant::ByteArray:

        v_clear<QByteArray>(d);

        break;

    case QVariant::BitArray:

        v_clear<QBitArray>(d);

        break;

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Point:

        v_clear<QPoint>(d);

        break;

    case QVariant::PointF:

        v_clear<QPointF>(d);

        break;

    case QVariant::Size:

        v_clear<QSize>(d);

        break;

    case QVariant::SizeF:

        v_clear<QSizeF>(d);

        break;

    case QVariant::Rect:

        v_clear<QRect>(d);

        break;

    case QVariant::LineF:

        v_clear<QLineF>(d);

        break;

    case QVariant::Line:

        v_clear<QLine>(d);

        break;

    case QVariant::RectF:

        v_clear<QRectF>(d);

        break;

#endif

    case QVariant::Url:

        v_clear<QUrl>(d);

        break;

    case QVariant::Locale:

        v_clear<QLocale>(d);

        break;

#ifndef QT_NO_REGEXP

    case QVariant::RegExp:

        v_clear<QRegExp>(d);

        break;

#endif

#ifndef QT_BOOTSTRAPPED

    case QVariant::EasingCurve:

        v_clear<QEasingCurve>(d);

        break;

#endif

    case QVariant::LongLong:

    case QVariant::ULongLong:

    case QVariant::Double:

    case QMetaType::Float:

    case QMetaType::QObjectStar:

        break;

    case QVariant::Invalid:

    case QVariant::UserType:

    case QVariant::Int:

    case QVariant::UInt:

    case QVariant::Bool:

        break;

    default:

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

        delete d->data.shared;

        break;

    }

    d->type = QVariant::Invalid;

    d->is_null = true;

    d->is_shared = false;

}

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

{

    switch(d->type) {

    case QVariant::String:

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

    case QVariant::Char:

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

    case QVariant::Date:

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

    case QVariant::Time:

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

    case QVariant::DateTime:

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

    case QVariant::ByteArray:

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

    case QVariant::BitArray:

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

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Size:

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

    case QVariant::SizeF:

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

    case QVariant::Rect:

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

    case QVariant::Line:

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

    case QVariant::LineF:

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

    case QVariant::RectF:

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

    case QVariant::Point:

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

    case QVariant::PointF:

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

#endif

#ifndef QT_BOOTSTRAPPED

    case QVariant::EasingCurve:

#endif

    case QVariant::Url:

    case QVariant::Locale:

    case QVariant::RegExp:

    case QVariant::StringList:

    case QVariant::Map:

    case QVariant::Hash:

    case QVariant::List:

    case QVariant::Invalid:

    case QVariant::UserType:

    case QVariant::Int:

    case QVariant::UInt:

    case QVariant::LongLong:

    case QVariant::ULongLong:

    case QVariant::Bool:

    case QVariant::Double:

    case QMetaType::Float:

    case QMetaType::QObjectStar:

        break;

    }

    return d->is_null;

}

/*

  \internal

  \since 4.4

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

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

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

 */

template<typename T>

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

{

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

}

/*!

  \internal

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

  are of the same type.

 */

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

{

    switch(a->type) {

    case QVariant::List:

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

    case QVariant::Map: {

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

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

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

            return false;

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

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

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

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

                return false;

            ++it;

            ++it2;

        }

        return true;

    }

    case QVariant::Hash:

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

    case QVariant::String:

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

    case QVariant::Char:

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

    case QVariant::StringList:

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

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Size:

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

    case QVariant::SizeF:

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

    case QVariant::Rect:

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

    case QVariant::Line:

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

    case QVariant::LineF:

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

    case QVariant::RectF:

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

    case QVariant::Point:

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

    case QVariant::PointF:

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

#endif

    case QVariant::Url:

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

    case QVariant::Locale:

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

#ifndef QT_NO_REGEXP

    case QVariant::RegExp:

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

#endif

    case QVariant::Int:

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

    case QVariant::UInt:

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

    case QVariant::LongLong:

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

    case QVariant::ULongLong:

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

    case QVariant::Bool:

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

    case QVariant::Double:

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

    case QMetaType::Float:

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

    case QMetaType::QObjectStar:

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

    case QVariant::Date:

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

    case QVariant::Time:

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

    case QVariant::DateTime:

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

#ifndef QT_BOOTSTRAPPED

    case QVariant::EasingCurve:

        return *v_cast<QEasingCurve>(a) == *v_cast<QEasingCurve>(b);

#endif

    case QVariant::ByteArray:

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

    case QVariant::BitArray:

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

    case QVariant::Invalid:

        return true;

    case QMetaType::Long:

        return compareNumericMetaType<long>(a, b);

    case QMetaType::ULong:

        return compareNumericMetaType<ulong>(a, b);

    case QMetaType::Short:

        return compareNumericMetaType<short>(a, b);

    case QMetaType::UShort:

        return compareNumericMetaType<ushort>(a, b);

    case QMetaType::UChar:

        return compareNumericMetaType<uchar>(a, b);

    case QMetaType::Char:

        return compareNumericMetaType<char>(a, b);

    default:

        break;

    }

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

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

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

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

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

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

     * user defined pointer types. */

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

    uint typeNameLen = qstrlen(typeName);

    if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*')

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

    if (a->is_null && b->is_null)

        return true;

    return a_ptr == b_ptr;

}

/*!

  \internal

 */

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

{

    switch (d->type) {

    case QMetaType::Int:

        return d->data.i;

    case QMetaType::LongLong:

        return d->data.ll;

    case QMetaType::Char:

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

    case QMetaType::Short:

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

    case QMetaType::Long:

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

    case QMetaType::Float:

        return qRound64(d->data.f);

    case QVariant::Double:

        return qRound64(d->data.d);

    }

    Q_ASSERT(false);

    return 0;

}

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

{

    switch (d->type) {

    case QVariant::UInt:

        return d->data.u;

    case QVariant::ULongLong:

        return d->data.ull;

    case QMetaType::UChar:

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

    case QMetaType::UShort:

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

    case QMetaType::ULong:

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

    }

    Q_ASSERT(false);

    return 0;

}

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

{

    *ok = true;

    switch (uint(d->type)) {

    case QVariant::String:

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

    case QVariant::Char:

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

    case QVariant::ByteArray:

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

    case QVariant::Bool:

        return qlonglong(d->data.b);

    case QVariant::Double:

    case QVariant::Int:

    case QMetaType::Char:

    case QMetaType::Short:

    case QMetaType::Long:

    case QMetaType::Float:

    case QMetaType::LongLong:

        return qMetaTypeNumber(d);

    case QVariant::ULongLong:

    case QVariant::UInt:

    case QMetaType::UChar:

    case QMetaType::UShort:

    case QMetaType::ULong:

        return qlonglong(qMetaTypeUNumber(d));

    }

    *ok = false;

    return Q_INT64_C(0);

}

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

{

    *ok = true;

    switch (uint(d->type)) {

    case QVariant::String:

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

    case QVariant::Char:

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

    case QVariant::ByteArray:

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

    case QVariant::Bool:

        return qulonglong(d->data.b);

    case QVariant::Double:

    case QVariant::Int:

    case QMetaType::Char:

    case QMetaType::Short:

    case QMetaType::Long:

    case QMetaType::Float:

    case QMetaType::LongLong:

        return qulonglong(qMetaTypeNumber(d));

    case QVariant::ULongLong:

    case QVariant::UInt:

    case QMetaType::UChar:

    case QMetaType::UShort:

    case QMetaType::ULong:

        return qMetaTypeUNumber(d);

    }

    *ok = false;

    return Q_UINT64_C(0);

}

template<typename TInput, typename LiteralWrapper>

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

{

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

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

}

/*!

 \internal

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

 */

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

{

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

    Q_ASSERT(result);

    bool dummy;

    if (!ok)

        ok = &dummy;

    switch (uint(t)) {

    case QVariant::Url:

        switch (d->type) {

        case QVariant::String:

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

            break;

        default:

            return false;

        }

        break;

    case QVariant::String: {

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

        switch (d->type) {

        case QVariant::Char:

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

            break;

        case QMetaType::Char:

        case QMetaType::UChar:

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

            break;

        case QMetaType::Short:

        case QMetaType::Long:

        case QVariant::Int:

        case QVariant::LongLong:

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

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UShort:

        case QMetaType::ULong:

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

            break;

        case QMetaType::Float:

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

            break;

        case QVariant::Double:

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

            break;

#if !defined(QT_NO_DATESTRING)

        case QVariant::Date:

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

            break;

        case QVariant::Time:

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

            break;

        case QVariant::DateTime:

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

            break;

#endif

        case QVariant::Bool:

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

            break;

        case QVariant::ByteArray:

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

            break;

        case QVariant::StringList:

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

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

            break;

        case QVariant::Url:

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

            break;

        default:

            return false;

        }

        break;

    }

    case QVariant::Char: {

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

        switch (d->type) {

        case QVariant::Int:

        case QVariant::LongLong:

        case QMetaType::Char:

        case QMetaType::Short:

        case QMetaType::Long:

        case QMetaType::Float:

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

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UChar:

        case QMetaType::UShort:

        case QMetaType::ULong:

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

            break;

        default:

            return false;

        }

        break;

    }

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Size: {

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

        switch (d->type) {

        case QVariant::SizeF:

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

            break;

        default:

            return false;

        }

        break;

    }

    case QVariant::SizeF: {

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

        switch (d->type) {

        case QVariant::Size:

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

            break;

        default:

            return false;

        }

        break;

    }

    case QVariant::Line: {

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

        switch (d->type) {

        case QVariant::LineF:

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

            break;

        default:

            return false;

        }

        break;

    }

    case QVariant::LineF: {

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

        switch (d->type) {

        case QVariant::Line:

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

            break;

        default:

            return false;

        }

        break;

    }

#endif

    case QVariant::StringList:

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

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

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

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

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

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

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

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

        } else {

            return false;

        }

        break;

    case QVariant::Date: {

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

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

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

#ifndef QT_NO_DATESTRING

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

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

#endif

        else

            return false;

        return dt->isValid();

    }

    case QVariant::Time: {

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

        switch (d->type) {

        case QVariant::DateTime:

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

            break;

#ifndef QT_NO_DATESTRING

        case QVariant::String:

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

            break;

#endif

        default:

            return false;

        }

        return t->isValid();

    }

    case QVariant::DateTime: {

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

        switch (d->type) {

#ifndef QT_NO_DATESTRING

        case QVariant::String:

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

            break;

#endif

        case QVariant::Date:

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

            break;

        default:

            return false;

        }

        return dt->isValid();

    }

    case QVariant::ByteArray: {

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

        switch (d->type) {

        case QVariant::String:

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

            break;

        case QVariant::Double:

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

            break;

        case QMetaType::Float:

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

            break;

        case QMetaType::Char:

        case QMetaType::UChar:

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

            break;

        case QVariant::Int:

        case QVariant::LongLong:

        case QMetaType::Short:

        case QMetaType::Long:

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

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UShort:

        case QMetaType::ULong:

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

            break;

        case QVariant::Bool:

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

            break;

        default:

            return false;

        }

    }

    break;

    case QMetaType::Short:

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

        return *ok;

    case QMetaType::Long:

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

        return *ok;

    case QMetaType::UShort:

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

        return *ok;

    case QMetaType::ULong:

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

        return *ok;

    case QVariant::Int:

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

        return *ok;

    case QVariant::UInt:

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

        return *ok;

    case QVariant::LongLong:

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

        return *ok;

    case QVariant::ULongLong: {

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

        return *ok;

    }

    case QMetaType::UChar: {

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

        return *ok;

    }

    case QVariant::Bool: {

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

        switch(d->type) {

        case QVariant::ByteArray:

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

            break;

        case QVariant::String:

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

            break;

        case QVariant::Char:

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

            break;

        case QVariant::Double:

        case QVariant::Int:

        case QVariant::LongLong:

        case QMetaType::Char:

        case QMetaType::Short:

        case QMetaType::Long:

        case QMetaType::Float:

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

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UChar:

        case QMetaType::UShort:

        case QMetaType::ULong:

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

            break;

        default:

            *b = false;

            return false;

        }

        break;

    }

    case QVariant::Double: {

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

        switch (d->type) {

        case QVariant::String:

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

            break;

        case QVariant::ByteArray:

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

            break;

        case QVariant::Bool:

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

            break;

        case QMetaType::Float:

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

            break;

        case QVariant::LongLong:

        case QVariant::Int:

        case QMetaType::Char:

        case QMetaType::Short:

        case QMetaType::Long:

            *f = double(qMetaTypeNumber(d));

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UChar:

        case QMetaType::UShort:

        case QMetaType::ULong:

            *f = double(qMetaTypeUNumber(d));

            break;

        default:

            *f = 0.0;

            return false;

        }

        break;

    }

    case QMetaType::Float: {

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

        switch (d->type) {

        case QVariant::String:

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

            break;

        case QVariant::ByteArray:

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

            break;

        case QVariant::Bool:

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

            break;

        case QVariant::Double:

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

            break;

        case QVariant::LongLong:

        case QVariant::Int:

        case QMetaType::Char:

        case QMetaType::Short:

        case QMetaType::Long:

            *f = float(qMetaTypeNumber(d));

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

        case QMetaType::UChar:

        case QMetaType::UShort:

        case QMetaType::ULong:

            *f = float(qMetaTypeUNumber(d));

            break;

        default:

            *f = 0.0f;

            return false;

        }

        break;

    }

    case QVariant::List:

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

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

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

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

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

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

            *static_cast<QVariantList *>(result) =

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

        } else {

            return false;

        }

        break;

    case QVariant::Map:

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

            *static_cast<QVariantMap *>(result) =

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

        } else {

            return false;

        }

        break;

    case QVariant::Hash:

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

            *static_cast<QVariantHash *>(result) =

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

        } else {

            return false;

        }

        break;

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Rect:

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

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

        else

            return false;

        break;

    case QVariant::RectF:

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

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

        else

            return false;

        break;

    case QVariant::PointF:

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

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

        else

            return false;

        break;

    case QVariant::Point:

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

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

        else

            return false;

        break;

    case QMetaType::Char:

    {

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

        return *ok;

    }

#endif

    default:

        return false;

    }

    return true;

}

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

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

{

    switch (v.userType()) {

    case QVariant::Int:

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

        break;

    case QVariant::UInt:

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

        break;

    case QVariant::LongLong:

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

        break;

    case QVariant::ULongLong:

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

        break;

    case QMetaType::Float:

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

        break;

    case QMetaType::QObjectStar:

        dbg.nospace() << qvariant_cast<QObject *>(v);

        break;

    case QVariant::Double:

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

        break;

    case QVariant::Bool:

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

        break;

    case QVariant::String:

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

        break;

    case QVariant::Char:

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

        break;

    case QVariant::StringList:

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

        break;

    case QVariant::Map:

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

        break;

    case QVariant::Hash:

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

        break;

    case QVariant::List:

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

        break;

    case QVariant::Date:

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

        break;

    case QVariant::Time:

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

        break;

    case QVariant::DateTime:

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

        break;

#ifndef QT_BOOTSTRAPPED

    case QVariant::EasingCurve:

        dbg.nospace() << v.toEasingCurve();

        break;

#endif

    case QVariant::ByteArray:

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

        break;

    case QVariant::Url:

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

        break;

#ifndef QT_NO_GEOM_VARIANT

    case QVariant::Point:

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

        break;

    case QVariant::PointF:

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

        break;

    case QVariant::Rect:

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

        break;

    case QVariant::Size:

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

        break;

    case QVariant::SizeF:

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

        break;

    case QVariant::Line:

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

        break;

    case QVariant::LineF:

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

        break;

    case QVariant::RectF:

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

        break;

#endif

    case QVariant::BitArray:

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

        break;

    default:

        break;

    }

}

#endif

const QVariant::Handler qt_kernel_variant_handler = {

    construct,

    clear,

    isNull,

#ifndef QT_NO_DATASTREAM

    0,

    0,

#endif

    compare,

    convert,

    0,

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

    streamDebug

#else

    0

#endif

};

Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler()

{

    return &qt_kernel_variant_handler;

}

const QVariant::Handler *QVariant::handler = &qt_kernel_variant_handler;

/*!

    \class QVariant

    \brief The QVariant class acts like a union for the most common Qt data types.

    \ingroup objectmodel

    \ingroup shared

    Because C++ forbids unions from including types that have

    non-default constructors or destructors, most interesting Qt

    classes cannot be used in unions. Without QVariant, this would be

    a problem for QObject::property() and for database work, etc.

    A QVariant object holds a single value of a single type() at a

    time. (Some type()s are multi-valued, for example a string list.)

    You can find out what type, T, the variant holds, convert it to a

    different type using convert(), get its value using one of the

    toT() functions (e.g., toSize()) and check whether the type can

    be converted to a particular type using canConvert().

    The methods named toT() (e.g., toInt(), toString()) are const. If

    you ask for the stored type, they return a copy of the stored

    object. If you ask for a type that can be generated from the

    stored type, toT() copies and converts and leaves the object

    itself unchanged. If you ask for a type that cannot be generated

    from the stored type, the result depends on the type; see the

    function documentation for details.

    Here is some example code to demonstrate the use of QVariant:

    \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 0

    You can even store QList<QVariant> and QMap<QString, QVariant>

    values in a variant, so you can easily construct arbitrarily

    complex data structures of arbitrary types. This is very powerful

    and versatile, but may prove less memory and speed efficient than

    storing specific types in standard data structures.

    QVariant also supports the notion of null values, where you can

    have a defined type with no value set. However, note that QVariant

    types can only be cast when they have had a value set.

    \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 1

    QVariant can be extended to support other types than those

    mentioned in the \l Type enum. See the \l QMetaType documentation

    for details.

    \section1 A Note on GUI Types

    Because QVariant is part of the QtCore library, it cannot provide

    conversion functions to data types defined in QtGui, such as

    QColor, QImage, and QPixmap. In other words, there is no \c

    toColor() function. Instead, you can use the QVariant::value() or

    the qvariant_cast() template function. For example:

    \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 2

    The inverse conversion (e.g., from QColor to QVariant) is

    automatic for all data types supported by QVariant, including

    GUI-related types:

    \snippet doc/src/snippets/code/src_corelib_kernel_qvariant.cpp 3

    \section1 Using canConvert() and convert() Consecutively

    When using canConvert() and convert() consecutively, it is possible for

    canConvert() to return true, but convert() to return false. This

    is typically because canConvert() only reports the general ability of

    QVariant to convert between types given suitable data; it is still

    possible to supply data which cannot actually be converted.

    For example, canConvert() would return true when called on a variant

    containing a string because, in principle, QVariant is able to convert

    strings of numbers to integers.

    However, if the string contains non-numeric characters, it cannot be

    converted to an integer, and any attempt to convert it will fail.

    Hence, it is important to have both functions return true for a

    successful conversion.

    \sa QMetaType

*/

/*!

    \enum QVariant::Type

    This enum type defines the types of variable that a QVariant can

    contain.

    \value Invalid  no type

    \value BitArray  a QBitArray

    \value Bitmap  a QBitmap

    \value Bool  a bool

    \value Brush  a QBrush

    \value ByteArray  a QByteArray

    \value Char  a QChar

    \value Color  a QColor

    \value Cursor  a QCursor

    \value Date  a QDate

    \value DateTime  a QDateTime

    \value Double  a double

    \value EasingCurve a QEasingCurve

    \value Font  a QFont

    \value Hash a QVariantHash

    \value Icon  a QIcon

    \value Image  a QImage

    \value Int  an int

    \value KeySequence  a QKeySequence

    \value Line  a QLine

    \value LineF  a QLineF

    \value List  a QVariantList

    \value Locale  a QLocale

    \value LongLong a \l qlonglong

    \value Map  a QVariantMap

    \value Matrix  a QMatrix

    \value Transform  a QTransform

    \value Matrix4x4  a QMatrix4x4

    \value Palette  a QPalette

    \value Pen  a QPen

    \value Pixmap  a QPixmap

    \value Point  a QPoint

    \value PointArray  a QPointArray

    \value PointF  a QPointF

    \value Polygon a QPolygon

    \value Quaternion  a QQuaternion

    \value Rect  a QRect

    \value RectF  a QRectF

    \value RegExp  a QRegExp

    \value Region  a QRegion

    \value Size  a QSize

    \value SizeF  a QSizeF

    \value SizePolicy  a QSizePolicy

    \value String  a QString

    \value StringList  a QStringList

    \value TextFormat  a QTextFormat

    \value TextLength  a QTextLength

    \value Time  a QTime

    \value UInt  a \l uint

    \value ULongLong a \l qulonglong

    \value Url  a QUrl

    \value Vector2D  a QVector2D

    \value Vector3D  a QVector3D

    \value Vector4D  a QVector4D

    \value UserType Base value for user-defined types.

    \omitvalue CString

    \omitvalue ColorGroup

    \omitvalue IconSet

    \omitvalue LastGuiType

    \omitvalue LastCoreType

    \omitvalue LastType

*/

/*!

    \fn QVariant::QVariant()

    Constructs an invalid variant.

*/

/*!

    \fn QVariant::QVariant(int typeOrUserType, const void *copy)

    Constructs variant of type \a typeOrUserType, and initializes with

    \a copy if \a copy is not 0.

    Note that you have to pass the address of the variable you want stored.

    Usually, you never have to use this constructor, use QVariant::fromValue()

    instead to construct variants from the pointer types represented by

    \c QMetaType::VoidStar, \c QMetaType::QObjectStar and

    \c QMetaType::QWidgetStar.

    \sa QVariant::fromValue(), Type

*/

/*!

    \fn QVariant::QVariant(Type type)

    Constructs a null variant of type \a type.

*/

/*!

    \fn QVariant::create(int type, const void *copy)

    \internal

    Constructs a variant private of type \a type, and initializes with \a copy if

    \a copy is not 0.

*/

void QVariant::create(int type, const void *copy)

{

    d.type = type;

    handler->construct(&d, copy);

}

/*!

    \fn QVariant::~QVariant()

    Destroys the QVariant and the contained object.

    Note that subclasses that reimplement clear() should reimplement

    the destructor to call clear(). This destructor calls clear(), but

    because it is the destructor, QVariant::clear() is called rather

    than a subclass's clear().

*/

QVariant::~QVariant()

{

    if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared && d.type > Char && d.type < UserType))

        handler->clear(&d);

}

/*!

  \fn QVariant::QVariant(const QVariant &p)

    Constructs a copy of the variant, \a p, passed as the argument to

    this constructor.

*/

QVariant::QVariant(const QVariant &p)

    : d(p.d)

{

    if (d.is_shared) {

        d.data.shared->ref.ref();

    } else if (p.d.type > Char && p.d.type < QVariant::UserType) {

        handler->construct(&d, p.constData());

        d.is_null = p.d.is_null;

    }

}

#ifndef QT_NO_DATASTREAM

/*!

    Reads the variant from the data stream, \a s.

*/

QVariant::QVariant(QDataStream &s)

{

    d.is_null = true;

    s >> *this;

}

#endif //QT_NO_DATASTREAM

/*!

  \fn QVariant::QVariant(const QString &val)

    Constructs a new variant with a string value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QLatin1String &val)

    Constructs a new variant with a string value, \a val.

*/

/*!

  \fn QVariant::QVariant(const char *val)

    Constructs a new variant with a string value of \a val.

    The variant creates a deep copy of \a val, using the encoding

    set by QTextCodec::setCodecForCStrings().

    Note that \a val is converted to a QString for storing in the

    variant and QVariant::type() will return QMetaType::QString for

    the variant.

    You can disable this operator by defining \c

    QT_NO_CAST_FROM_ASCII when you compile your applications.

    \sa QTextCodec::setCodecForCStrings()

*/

#ifndef QT_NO_CAST_FROM_ASCII

QVariant::QVariant(const char *val)

{

    QString s = QString::fromAscii(val);

    create(String, &s);

}

#endif

/*!

  \fn QVariant::QVariant(const QStringList &val)

    Constructs a new variant with a string list value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QMap<QString, QVariant> &val)

    Constructs a new variant with a map of QVariants, \a val.

*/

/*!

  \fn QVariant::QVariant(const QHash<QString, QVariant> &val)

    Constructs a new variant with a hash of QVariants, \a val.

*/

/*!

  \fn QVariant::QVariant(const QDate &val)

    Constructs a new variant with a date value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QTime &val)

    Constructs a new variant with a time value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QDateTime &val)

    Constructs a new variant with a date/time value, \a val.

*/

/*!

    \since 4.7

  \fn QVariant::QVariant(const QEasingCurve &val)

    Constructs a new variant with an easing curve value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QByteArray &val)

    Constructs a new variant with a bytearray value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QBitArray &val)

    Constructs a new variant with a bitarray value, \a val.

*/

/*!

  \fn QVariant::QVariant(const QPoint &val)

  Constructs a new variant with a point value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QPointF &val)

  Constructs a new variant with a point value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QRectF &val)

  Constructs a new variant with a rect value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QLineF &val)

  Constructs a new variant with a line value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QLine &val)

  Constructs a new variant with a line value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QRect &val)

  Constructs a new variant with a rect value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QSize &val)

  Constructs a new variant with a size value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QSizeF &val)

  Constructs a new variant with a size value of \a val.

 */

/*!

  \fn QVariant::QVariant(const QUrl &val)

  Constructs a new variant with a url value of \a val.

 */

/*!

  \fn QVariant::QVariant(int val)

    Constructs a new variant with an integer value, \a val.

*/

/*!

  \fn QVariant::QVariant(uint val)

    Constructs a new variant with an unsigned integer value, \a val.