qvariant.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Copyright (C) 2021 Intel Corporation.
** Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com>
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#include "qvariant.h"
#include "qbitarray.h"
#include "qbytearray.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qmap.h"
#include "qdatetime.h"
#if QT_CONFIG(easingcurve)
#include "qeasingcurve.h"
#endif
#include "qlist.h"
#if QT_CONFIG(regularexpression)
#include "qregularexpression.h"
#endif
#include "qstring.h"
#include "qstringlist.h"
#include "qurl.h"
#include "qlocale.h"
#include "quuid.h"
#if QT_CONFIG(itemmodel)
#include "qabstractitemmodel.h"
#endif
#ifndef QT_BOOTSTRAPPED
#include "qcborarray.h"
#include "qcborcommon.h"
#include "qcbormap.h"
#include "qjsonvalue.h"
#include "qjsonobject.h"
#include "qjsonarray.h"
#include "qjsondocument.h"
#include "qbytearraylist.h"
#endif
#include "private/qvariant_p.h"
#include "private/qlocale_p.h"
#include "qmetatype_p.h"
#include <qmetaobject.h>
 
#ifndef QT_NO_GEOM_VARIANT
#include "qsize.h"
#include "qpoint.h"
#include "qrect.h"
#include "qline.h"
#endif
 
#include <cmath>
#include <float.h>
#include <cstring>
 
QT_BEGIN_NAMESPACE
 
namespace { // anonymous used to hide QVariant handlers
 
static qlonglong qMetaTypeNumber(const QVariant::Private *d)
{
    switch (d->typeId()) {
    case QMetaType::Int:
        return d->get<int>();
    case QMetaType::LongLong:
        return d->get<qlonglong>();
    case QMetaType::Char:
        return qlonglong(d->get<char>());
    case QMetaType::SChar:
        return qlonglong(d->get<signed char>());
    case QMetaType::Short:
        return qlonglong(d->get<short>());
    case QMetaType::Long:
        return qlonglong(d->get<long>());
    case QMetaType::Float:
        return qRound64(d->get<float>());
    case QMetaType::Double:
        return qRound64(d->get<double>());
#ifndef QT_BOOTSTRAPPED
    case QMetaType::QJsonValue:
        return d->get<QJsonValue>().toDouble();
    case QMetaType::QCborValue:
        return d->get<QCborValue>().toInteger();
#endif
    }
    Q_ASSERT(false);
    return 0;
}
 
static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
{
    switch (d->typeId()) {
    case QMetaType::UInt:
        return d->get<unsigned int>();
    case QMetaType::ULongLong:
        return d->get<qulonglong>();
    case QMetaType::UChar:
        return d->get<unsigned char>();
    case QMetaType::UShort:
        return d->get<unsigned short>();
    case QMetaType::ULong:
        return d->get<unsigned long>();
    }
    Q_ASSERT(false);
    return 0;
}
 
static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok, bool allowStringToBool = false)
{
    *ok = true;
 
    switch (uint(d->typeId())) {
    case QMetaType::QString: {
        const QString &s = d->get<QString>();
        qlonglong l = s.toLongLong(ok);
        if (*ok)
            return l;
        if (allowStringToBool) {
            if (s == QLatin1String("false") || s == QLatin1String("0")) {
                *ok = true;
                return 0;
            }
            if (s == QLatin1String("true") || s == QLatin1String("1")) {
                *ok = true;
                return 1;
            }
        }
        return 0;
    }
    case QMetaType::QChar:
        return d->get<QChar>().unicode();
    case QMetaType::QByteArray:
        return d->get<QByteArray>().toLongLong(ok);
    case QMetaType::Bool:
        return qlonglong(d->get<bool>());
#ifndef QT_BOOTSTRAPPED
    case QMetaType::QCborValue:
        if (!d->get<QCborValue>().isInteger() && !d->get<QCborValue>().isDouble())
            break;
        return qMetaTypeNumber(d);
    case QMetaType::QJsonValue:
        if (!d->get<QJsonValue>().isDouble())
            break;
        Q_FALLTHROUGH();
#endif
    case QMetaType::Double:
    case QMetaType::Int:
    case QMetaType::Char:
    case QMetaType::SChar:
    case QMetaType::Short:
    case QMetaType::Long:
    case QMetaType::Float:
    case QMetaType::LongLong:
        return qMetaTypeNumber(d);
    case QMetaType::ULongLong:
    case QMetaType::UInt:
    case QMetaType::UChar:
    case QMetaType::UShort:
    case QMetaType::ULong:
 
        return qlonglong(qMetaTypeUNumber(d));
    }
 
    QMetaType typeInfo = d->type();
    if (typeInfo.flags() & QMetaType::IsEnumeration
        || d->typeId() == QMetaType::QCborSimpleType) {
        switch (typeInfo.sizeOf()) {
        case 1:
            return d->get<signed char>();
        case 2:
            return d->get<short>();
        case 4:
            return d->get<int>();
        case 8:
            return d->get<qlonglong>();
        }
    }
 
    *ok = false;
    return Q_INT64_C(0);
}
 
static qreal qConvertToRealNumber(const QVariant::Private *d, bool *ok)
{
    *ok = true;
    switch (uint(d->typeId())) {
    case QMetaType::QString:
        return d->get<QString>().toDouble(ok);
    case QMetaType::Double:
        return qreal(d->get<double>());
    case QMetaType::Float:
        return qreal(d->get<float>());
    case QMetaType::ULongLong:
    case QMetaType::UInt:
    case QMetaType::UChar:
    case QMetaType::UShort:
    case QMetaType::ULong:
        return qreal(qMetaTypeUNumber(d));
#ifndef QT_BOOTSTRAPPED
    case QMetaType::QCborValue:
        return d->get<QCborValue>().toDouble();
    case QMetaType::QJsonValue:
        return d->get<QJsonValue>().toDouble();
#endif
    default:
        // includes enum conversion as well as invalid types
        return qreal(qConvertToNumber(d, ok));
    }
}
 
// the type of d has already been set, but other field are not set
static void customConstruct(QVariant::Private *d, const void *copy)
{
    QtPrivate::QMetaTypeInterface *iface = d->typeInterface();
    if (!(iface && iface->size)) {
        *d = QVariant::Private();
        return;
    }
 
    if (QVariant::Private::canUseInternalSpace(iface)) {
        // QVariant requires type to be copy and default constructible
        Q_ASSERT(iface->copyCtr);
        Q_ASSERT(iface->defaultCtr);
        if (copy)
            iface->copyCtr(iface, &d->data, copy);
        else
            iface->defaultCtr(iface, &d->data);
        d->is_shared = false;
    } else {
        d->data.shared = QVariant::PrivateShared::create(iface);
        if (copy)
            iface->copyCtr(iface, d->data.shared->data(), copy);
        else
            iface->defaultCtr(iface, d->data.shared->data());
        d->is_shared = true;
    }
    // need to check for nullptr_t here, as this can get called by fromValue(nullptr). fromValue() uses
    // std::addressof(value) which in this case returns the address of the nullptr object.
    d->is_null = !copy || QMetaType(iface) == QMetaType::fromType<std::nullptr_t>();
}
 
static void customClear(QVariant::Private *d)
{
    auto iface = reinterpret_cast<QtPrivate::QMetaTypeInterface *>(d->packedType << 2);
    if (!iface)
        return;
    if (!d->is_shared) {
        if (iface->dtor)
            iface->dtor(iface, &d->data);
    } else {
        if (iface->dtor)
            iface->dtor(iface, d->data.shared->data());
        QVariant::PrivateShared::free(d->data.shared);
    }
}
 
 
} // anonymous used to hide QVariant handlers
 
//### Qt 7: Remove in favor of QMetaType overload
void QVariant::create(int type, const void *copy)
{
    create(QMetaType(type), copy);
}
 
void QVariant::create(QMetaType type, const void *copy)
{
    d = Private(type);
    customConstruct(&d, copy);
}
 
QVariant::~QVariant()
{
    if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared))
        customClear(&d);
}
 
QVariant::QVariant(const QVariant &p)
    : d(p.d)
{
    if (d.is_shared) {
        d.data.shared->ref.ref();
        return;
    }
    QtPrivate::QMetaTypeInterface *iface = d.typeInterface();
    auto other = p.constData();
    if (iface) {
        if (other)
            iface->copyCtr(iface, &d.data, other);
        else
            iface->defaultCtr(iface, &d.data);
    }
}
 
QVariant::QVariant(QMetaType type, const void *copy) : d(type)
{
    customConstruct(&d, copy);
}
 
QVariant::QVariant(int val)
    : d(QMetaType::fromType<int>())
{ d.set(val); }
QVariant::QVariant(uint val)
    : d(QMetaType::fromType<uint>())
{ d.set(val); }
QVariant::QVariant(qlonglong val)
    : d(QMetaType::fromType<qlonglong>())
{ d.set(val); }
QVariant::QVariant(qulonglong val)
    : d(QMetaType::fromType<qulonglong>())
{ d.set(val); }
QVariant::QVariant(bool val)
    : d(QMetaType::fromType<bool>())
{ d.set(val); }
QVariant::QVariant(double val)
    : d(QMetaType::fromType<double>())
{ d.set(val); }
QVariant::QVariant(float val)
    : d(QMetaType::fromType<float>())
{ d.set(val); }
 
QVariant::QVariant(const QByteArray &val)
    : d(QMetaType::fromType<QByteArray>())
{ v_construct<QByteArray>(&d, val); }
QVariant::QVariant(const QBitArray &val)
    : d(QMetaType::fromType<QBitArray>())
{ v_construct<QBitArray>(&d, val);  }
QVariant::QVariant(const QString &val)
    : d(QMetaType::fromType<QString>())
{ v_construct<QString>(&d, val);  }
QVariant::QVariant(QChar val)
    : d(QMetaType::fromType<QChar>())
{ v_construct<QChar>(&d, val);  }
QVariant::QVariant(QLatin1String val)
    : d(QMetaType::fromType<QString>())
{ v_construct<QString>(&d, val); }
QVariant::QVariant(const QStringList &val)
    : d(QMetaType::fromType<QStringList>())
{ v_construct<QStringList>(&d, val); }
 
QVariant::QVariant(QDate val)
    : d(QMetaType::fromType<QDate>())
{ v_construct<QDate>(&d, val); }
QVariant::QVariant(QTime val)
    : d(QMetaType::fromType<QTime>())
{ v_construct<QTime>(&d, val); }
QVariant::QVariant(const QDateTime &val)
    : d(QMetaType::fromType<QDateTime>())
{ v_construct<QDateTime>(&d, val); }
#if QT_CONFIG(easingcurve)
QVariant::QVariant(const QEasingCurve &val)
    : d(QMetaType::fromType<QEasingCurve>())
{ v_construct<QEasingCurve>(&d, val); }
#endif
QVariant::QVariant(const QList<QVariant> &list)
    : d(QMetaType::fromType<QList<QVariant>>())
{ v_construct<QVariantList>(&d, list); }
QVariant::QVariant(const QMap<QString, QVariant> &map)
    : d(QMetaType::fromType<QMap<QString, QVariant>>())
{ v_construct<QVariantMap>(&d, map); }
QVariant::QVariant(const QHash<QString, QVariant> &hash)
    : d(QMetaType::fromType<QHash<QString, QVariant>>())
{ v_construct<QVariantHash>(&d, hash); }
#ifndef QT_NO_GEOM_VARIANT
QVariant::QVariant(const QPoint &pt)
    : d(QMetaType::fromType<QPoint>())
{ v_construct<QPoint>(&d, pt); }
QVariant::QVariant(const QPointF &pt)
    : d(QMetaType::fromType<QPointF>())
{ v_construct<QPointF>(&d, pt); }
QVariant::QVariant(const QRectF &r)
    : d(QMetaType::fromType<QRectF>())
{ v_construct<QRectF>(&d, r); }
QVariant::QVariant(const QLineF &l)
    : d(QMetaType::fromType<QLineF>())
{ v_construct<QLineF>(&d, l); }
QVariant::QVariant(const QLine &l)
    : d(QMetaType::fromType<QLine>())
{ v_construct<QLine>(&d, l); }
QVariant::QVariant(const QRect &r)
    : d(QMetaType::fromType<QRect>())
{ v_construct<QRect>(&d, r); }
QVariant::QVariant(const QSize &s)
    : d(QMetaType::fromType<QSize>())
{ v_construct<QSize>(&d, s); }
QVariant::QVariant(const QSizeF &s)
    : d(QMetaType::fromType<QSizeF>())
{ v_construct<QSizeF>(&d, s); }
#endif
#ifndef QT_BOOTSTRAPPED
QVariant::QVariant(const QUrl &u)
    : d(QMetaType::fromType<QUrl>())
{ v_construct<QUrl>(&d, u); }
#endif
QVariant::QVariant(const QLocale &l)
    : d(QMetaType::fromType<QLocale>())
{ v_construct<QLocale>(&d, l); }
#if QT_CONFIG(regularexpression)
QVariant::QVariant(const QRegularExpression &re)
    : d(QMetaType::fromType<QRegularExpression>())
{ v_construct<QRegularExpression>(&d, re); }
#endif // QT_CONFIG(regularexpression)
QVariant::QVariant(const QUuid &uuid)
    : d(QMetaType::fromType<QUuid>())
{ v_construct<QUuid>(&d, uuid); }
#ifndef QT_BOOTSTRAPPED
QVariant::QVariant(const QJsonValue &jsonValue)
    : d(QMetaType::fromType<QJsonValue>())
{ v_construct<QJsonValue>(&d, jsonValue); }
QVariant::QVariant(const QJsonObject &jsonObject)
    : d(QMetaType::fromType<QJsonObject>())
{ v_construct<QJsonObject>(&d, jsonObject); }
QVariant::QVariant(const QJsonArray &jsonArray)
    : d(QMetaType::fromType<QJsonArray>())
{ v_construct<QJsonArray>(&d, jsonArray); }
QVariant::QVariant(const QJsonDocument &jsonDocument)
    : d(QMetaType::fromType<QJsonDocument>())
{ v_construct<QJsonDocument>(&d, jsonDocument); }
#endif // QT_BOOTSTRAPPED
#if QT_CONFIG(itemmodel)
QVariant::QVariant(const QModelIndex &modelIndex)
    : d(QMetaType::fromType<QModelIndex>())
{ v_construct<QModelIndex>(&d, modelIndex); }
QVariant::QVariant(const QPersistentModelIndex &modelIndex)
    : d(QMetaType::fromType<QPersistentModelIndex>())
{ v_construct<QPersistentModelIndex>(&d, modelIndex); }
#endif
 
QMetaType QVariant::metaType() const
{
    return d.type();
}
 
QVariant &QVariant::operator=(const QVariant &variant)
{
    if (this == &variant)
        return *this;
 
    clear();
    if (variant.d.is_shared) {
        variant.d.data.shared->ref.ref();
        d = variant.d;
    } else {
        d = variant.d;
        QtPrivate::QMetaTypeInterface *iface = d.typeInterface();
        const void *other = variant.constData();
        if (iface) {
            if (other)
                iface->copyCtr(iface, &d, other);
            else
                iface->defaultCtr(iface, &d);
        }
    }
 
    return *this;
}
 
void QVariant::detach()
{
    if (!d.is_shared || d.data.shared->ref.loadRelaxed() == 1)
        return;
 
    Private dd(d.type());
    customConstruct(&dd, constData());
    if (!d.data.shared->ref.deref())
        customClear(&d);
    d.data.shared = dd.data.shared;
}
 
const char *QVariant::typeName() const
{
    return d.type().name();
}
 
void QVariant::clear()
{
    if ((d.is_shared && !d.data.shared->ref.deref()) || (!d.is_shared))
        customClear(&d);
    d = {};
}
 
#ifndef QT_NO_DATASTREAM
enum { MapFromThreeCount = 36 };
static const ushort mapIdFromQt3ToCurrent[MapFromThreeCount] =
{
    QMetaType::UnknownType,
    QMetaType::QVariantMap,
    QMetaType::QVariantList,
    QMetaType::QString,
    QMetaType::QStringList,
    QMetaType::QFont,
    QMetaType::QPixmap,
    QMetaType::QBrush,
    QMetaType::QRect,
    QMetaType::QSize,
    QMetaType::QColor,
    QMetaType::QPalette,
    0, // ColorGroup
    QMetaType::QIcon,
    QMetaType::QPoint,
    QMetaType::QImage,
    QMetaType::Int,
    QMetaType::UInt,
    QMetaType::Bool,
    QMetaType::Double,
    0, // Buggy ByteArray, QByteArray never had id == 20
    QMetaType::QPolygon,
    QMetaType::QRegion,
    QMetaType::QBitmap,
    QMetaType::QCursor,
    QMetaType::QSizePolicy,
    QMetaType::QDate,
    QMetaType::QTime,
    QMetaType::QDateTime,
    QMetaType::QByteArray,
    QMetaType::QBitArray,
#if QT_CONFIG(shortcut)
    QMetaType::QKeySequence,
#else
    0, // QKeySequence
#endif
    QMetaType::QPen,
    QMetaType::LongLong,
    QMetaType::ULongLong,
#if QT_CONFIG(easingcurve)
    QMetaType::QEasingCurve
#endif
};
 
// values needed to map Qt5 based type id's to Qt6 based ones
constexpr int Qt5UserType = 1024;
constexpr int Qt5LastCoreType = QMetaType::QCborMap;
constexpr int Qt5FirstGuiType = 64;
constexpr int Qt5LastGuiType = 87;
constexpr int Qt5SizePolicy = 121;
constexpr int Qt5RegExp = 27;
constexpr int Qt5KeySequence = 75;
constexpr int Qt5QQuaternion = 85;
 
constexpr int Qt6ToQt5GuiTypeDelta = qToUnderlying(QMetaType::FirstGuiType) - Qt5FirstGuiType;
 
void QVariant::load(QDataStream &s)
{
    clear();
 
    quint32 typeId;
    s >> typeId;
    if (s.version() < QDataStream::Qt_4_0) {
        // map to Qt 5 ids
        if (typeId >= MapFromThreeCount)
            return;
        typeId = mapIdFromQt3ToCurrent[typeId];
    } else if (s.version() < QDataStream::Qt_5_0) {
        // map to Qt 5 type ids
        if (typeId == 127 /* QVariant::UserType */) {
            typeId = Qt5UserType;
        } else if (typeId >= 128 && typeId != Qt5UserType) {
            // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
            // by moving all ids down by 97.
            typeId -= 97;
        } else if (typeId == 75 /* QSizePolicy */) {
            typeId = Qt5SizePolicy;
        } else if (typeId > 75 && typeId <= 86) {
            // and as a result these types received lower ids too
            // QKeySequence QPen QTextLength QTextFormat QTransform QMatrix4x4 QVector2D QVector3D QVector4D QQuaternion
            typeId -=1;
        }
    }
    if (s.version() < QDataStream::Qt_6_0) {
        // map from Qt 5 to Qt 6 values
        if (typeId == Qt5UserType) {
            typeId = QMetaType::User;
        } else if (typeId >= Qt5FirstGuiType && typeId <= Qt5LastGuiType) {
            typeId += Qt6ToQt5GuiTypeDelta;
        } else if (typeId == Qt5SizePolicy) {
            typeId = QMetaType::QSizePolicy;
        } else if (typeId == Qt5RegExp) {
            typeId = QMetaType::fromName("QRegExp").id();
        }
    }
 
    qint8 is_null = false;
    if (s.version() >= QDataStream::Qt_4_2)
        s >> is_null;
    if (typeId == QMetaType::User) {
        QByteArray name;
        s >> name;
        typeId = QMetaType::fromName(name).id();
        if (typeId == QMetaType::UnknownType) {
            s.setStatus(QDataStream::ReadCorruptData);
            qWarning("QVariant::load: unknown user type with name %s.", name.constData());
            return;
        }
    }
    create(typeId, nullptr);
    d.is_null = is_null;
 
    if (!isValid()) {
        if (s.version() < QDataStream::Qt_5_0) {
            // Since we wrote something, we should read something
            QString x;
            s >> x;
        }
        d.is_null = true;
        return;
    }
 
    // const cast is safe since we operate on a newly constructed variant
    void *data = const_cast<void *>(constData());
    if (!d.type().load(s, data)) {
        s.setStatus(QDataStream::ReadCorruptData);
        qWarning("QVariant::load: unable to load type %d.", d.typeId());
    }
}
 
void QVariant::save(QDataStream &s) const
{
    quint32 typeId = d.typeId();
    bool saveAsUserType = false;
    if (typeId >= QMetaType::User) {
        typeId = QMetaType::User;
        saveAsUserType = true;
    }
    if (s.version() < QDataStream::Qt_6_0) {
        // map to Qt 5 values
        if (typeId == QMetaType::User) {
            typeId = Qt5UserType;
            if (!strcmp(d.type().name(), "QRegExp")) {
                typeId = 27; // QRegExp in Qt 4/5
            }
        } else if (typeId > Qt5LastCoreType && typeId <= QMetaType::LastCoreType) {
            // the type didn't exist in Qt 5
            typeId = Qt5UserType;
            saveAsUserType = true;
        } else if (typeId >= QMetaType::FirstGuiType && typeId <= QMetaType::LastGuiType) {
            typeId -= Qt6ToQt5GuiTypeDelta;
            if (typeId > Qt5LastGuiType) {
                typeId = Qt5UserType;
                saveAsUserType = true;
            }
        } else if (typeId == QMetaType::QSizePolicy) {
            typeId = Qt5SizePolicy;
        }
    }
    if (s.version() < QDataStream::Qt_4_0) {
        int i;
        for (i = 0; i <= MapFromThreeCount - 1; ++i) {
            if (mapIdFromQt3ToCurrent[i] == typeId) {
                typeId = i;
                break;
            }
        }
        if (i >= MapFromThreeCount) {
            s << QVariant();
            return;
        }
    } else if (s.version() < QDataStream::Qt_5_0) {
        if (typeId == Qt5UserType) {
            typeId = 127; // QVariant::UserType had this value in Qt4
            saveAsUserType = true;
        } else if (typeId >= 128 - 97 && typeId <= Qt5LastCoreType) {
            // In Qt4 id == 128 was FirstExtCoreType. In Qt5 ExtCoreTypes set was merged to CoreTypes
            // by moving all ids down by 97.
            typeId += 97;
        } else if (typeId == Qt5SizePolicy) {
            typeId = 75;
        } else if (typeId >= Qt5KeySequence && typeId <= Qt5QQuaternion) {
            // and as a result these types received lower ids too
            typeId += 1;
        } else if (typeId > Qt5QQuaternion || typeId == QMetaType::QUuid) {
            // These existed in Qt 4 only as a custom type
            typeId = 127;
            saveAsUserType = true;
        }
    }
    const char *typeName = nullptr;
    if (saveAsUserType) {
        if (s.version() < QDataStream::Qt_6_0)
            typeName = QtMetaTypePrivate::typedefNameForType(d.type().d_ptr);
        if (!typeName)
            typeName = d.type().name();
    }
    s << typeId;
    if (s.version() >= QDataStream::Qt_4_2)
        s << qint8(d.is_null);
    if (typeName)
        s << typeName;
 
    if (!isValid()) {
        if (s.version() < QDataStream::Qt_5_0)
            s << QString();
        return;
    }
 
    if (!d.type().save(s, constData())) {
        qWarning("QVariant::save: unable to save type '%s' (type id: %d).\n",
                 d.type().name(), d.typeId());
        Q_ASSERT_X(false, "QVariant::save", "Invalid type to save");
    }
}
 
QDataStream &operator>>(QDataStream &s, QVariant &p)
{
    p.load(s);
    return s;
}
 
QDataStream &operator<<(QDataStream &s, const QVariant &p)
{
    p.save(s);
    return s;
}
 
#endif //QT_NO_DATASTREAM
 
QStringList QVariant::toStringList() const
{
    return qvariant_cast<QStringList>(*this);
}
 
QString QVariant::toString() const
{
    return qvariant_cast<QString>(*this);
}
 
QVariantMap QVariant::toMap() const
{
    return qvariant_cast<QVariantMap>(*this);
}
 
QVariantHash QVariant::toHash() const
{
    return qvariant_cast<QVariantHash>(*this);
}
 
QDate QVariant::toDate() const
{
    return qvariant_cast<QDate>(*this);
}
 
QTime QVariant::toTime() const
{
    return qvariant_cast<QTime>(*this);
}
 
QDateTime QVariant::toDateTime() const
{
    return qvariant_cast<QDateTime>(*this);
}
 
#if QT_CONFIG(easingcurve)
QEasingCurve QVariant::toEasingCurve() const
{
    return qvariant_cast<QEasingCurve>(*this);
}
#endif
 
QByteArray QVariant::toByteArray() const
{
    return qvariant_cast<QByteArray>(*this);
}
 
#ifndef QT_NO_GEOM_VARIANT
QPoint QVariant::toPoint() const
{
    return qvariant_cast<QPoint>(*this);
}
 
QRect QVariant::toRect() const
{
    return qvariant_cast<QRect>(*this);
}
 
QSize QVariant::toSize() const
{
    return qvariant_cast<QSize>(*this);
}
 
QSizeF QVariant::toSizeF() const
{
    return qvariant_cast<QSizeF>(*this);
}
 
QRectF QVariant::toRectF() const
{
    return qvariant_cast<QRectF>(*this);
}
 
QLineF QVariant::toLineF() const
{
    return qvariant_cast<QLineF>(*this);
}
 
QLine QVariant::toLine() const
{
    return qvariant_cast<QLine>(*this);
}
 
QPointF QVariant::toPointF() const
{
    return qvariant_cast<QPointF>(*this);
}
 
#endif // QT_NO_GEOM_VARIANT
 
#ifndef QT_BOOTSTRAPPED
QUrl QVariant::toUrl() const
{
    return qvariant_cast<QUrl>(*this);
}
#endif
 
QLocale QVariant::toLocale() const
{
    return qvariant_cast<QLocale>(*this);
}
 
#if QT_CONFIG(regularexpression)
QRegularExpression QVariant::toRegularExpression() const
{
    return qvariant_cast<QRegularExpression>(*this);
}
#endif // QT_CONFIG(regularexpression)
 
#if QT_CONFIG(itemmodel)
QModelIndex QVariant::toModelIndex() const
{
    return qvariant_cast<QModelIndex>(*this);
}
 
QPersistentModelIndex QVariant::toPersistentModelIndex() const
{
    return qvariant_cast<QPersistentModelIndex>(*this);
}
#endif // QT_CONFIG(itemmodel)
 
QUuid QVariant::toUuid() const
{
    return qvariant_cast<QUuid>(*this);
}
 
#ifndef QT_BOOTSTRAPPED
QJsonValue QVariant::toJsonValue() const
{
    return qvariant_cast<QJsonValue>(*this);
}
 
QJsonObject QVariant::toJsonObject() const
{
    return qvariant_cast<QJsonObject>(*this);
}
 
QJsonArray QVariant::toJsonArray() const
{
    return qvariant_cast<QJsonArray>(*this);
}
 
QJsonDocument QVariant::toJsonDocument() const
{
    return qvariant_cast<QJsonDocument>(*this);
}
#endif // QT_BOOTSTRAPPED
 
QChar QVariant::toChar() const
{
    return qvariant_cast<QChar>(*this);
}
 
QBitArray QVariant::toBitArray() const
{
    return qvariant_cast<QBitArray>(*this);
}
 
template <typename T>
inline T qNumVariantToHelper(const QVariant::Private &d, bool *ok, const T& val)
{
    QMetaType t = QMetaType::fromType<T>();
    if (ok)
        *ok = true;
 
    if (d.type() == t)
        return val;
 
    T ret = 0;
    bool success = QMetaType::convert(d.type(), d.storage(), t, &ret);
    if (ok)
        *ok = success;
    return ret;
}
 
int QVariant::toInt(bool *ok) const
{
    return qNumVariantToHelper<int>(d, ok, d.get<int>());
}
 
uint QVariant::toUInt(bool *ok) const
{
    return qNumVariantToHelper<uint>(d, ok, d.get<unsigned int>());
}
 
qlonglong QVariant::toLongLong(bool *ok) const
{
    return qNumVariantToHelper<qlonglong>(d, ok, d.get<qlonglong>());
}
 
qulonglong QVariant::toULongLong(bool *ok) const
{
    return qNumVariantToHelper<qulonglong>(d, ok, d.get<qulonglong>());
}
 
bool QVariant::toBool() const
{
    auto boolType = QMetaType::fromType<bool>();
    if (d.type() == boolType)
        return d.get<bool>();
 
    bool res = false;
    QMetaType::convert(d.type(), constData(), boolType, &res);
    return res;
}
 
double QVariant::toDouble(bool *ok) const
{
    return qNumVariantToHelper<double>(d, ok, d.get<double>());
}
 
float QVariant::toFloat(bool *ok) const
{
    return qNumVariantToHelper<float>(d, ok, d.get<float>());
}
 
qreal QVariant::toReal(bool *ok) const
{
    return qNumVariantToHelper<qreal>(d, ok, d.get<qreal>());
}
 
QVariantList QVariant::toList() const
{
    return qvariant_cast<QVariantList>(*this);
}
 
bool QVariant::convert(QMetaType targetType)
{
    if (d.type() == targetType)
        return targetType.isValid();
 
    QVariant oldValue = *this;
 
    clear();
    create(targetType, nullptr);
    if (!oldValue.canConvert(targetType))
        return false;
 
    // Fail if the value is not initialized or was forced null by a previous failed convert.
    if (oldValue.d.is_null && oldValue.d.typeId() != QMetaType::Nullptr)
        return false;
 
    bool ok = QMetaType::convert(oldValue.d.type(), oldValue.constData(), targetType, data());
    d.is_null = !ok;
    return ok;
}
 
bool QVariant::convert(int type, void *ptr) const
{
    return QMetaType::convert(d.type(), constData(), QMetaType(type), ptr);
}
 
bool QVariant::view(int type, void *ptr)
{
    return QMetaType::view(d.type(), data(), QMetaType(type), ptr);
}
 
static bool qIsNumericType(uint tp)
{
    static const qulonglong numericTypeBits =
            Q_UINT64_C(1) << QMetaType::QString |
            Q_UINT64_C(1) << QMetaType::Bool |
            Q_UINT64_C(1) << QMetaType::Double |
            Q_UINT64_C(1) << QMetaType::Float |
            Q_UINT64_C(1) << QMetaType::Char |
            Q_UINT64_C(1) << QMetaType::SChar |
            Q_UINT64_C(1) << QMetaType::UChar |
            Q_UINT64_C(1) << QMetaType::Short |
            Q_UINT64_C(1) << QMetaType::UShort |
            Q_UINT64_C(1) << QMetaType::Int |
            Q_UINT64_C(1) << QMetaType::UInt |
            Q_UINT64_C(1) << QMetaType::Long |
            Q_UINT64_C(1) << QMetaType::ULong |
            Q_UINT64_C(1) << QMetaType::LongLong |
            Q_UINT64_C(1) << QMetaType::ULongLong;
    return tp < (CHAR_BIT * sizeof numericTypeBits) ? numericTypeBits & (Q_UINT64_C(1) << tp) : false;
}
 
static bool qIsFloatingPoint(uint tp)
{
    return tp == QMetaType::Double || tp == QMetaType::Float;
}
 
static int normalizeLowerRanks(uint tp)
{
    static const qulonglong numericTypeBits =
            Q_UINT64_C(1) << QMetaType::Bool |
            Q_UINT64_C(1) << QMetaType::Char |
            Q_UINT64_C(1) << QMetaType::SChar |
            Q_UINT64_C(1) << QMetaType::UChar |
            Q_UINT64_C(1) << QMetaType::Short |
            Q_UINT64_C(1) << QMetaType::UShort;
    return numericTypeBits & (Q_UINT64_C(1) << tp) ? uint(QMetaType::Int) : tp;
}
 
static int normalizeLong(uint tp)
{
    const uint IntType = sizeof(long) == sizeof(int) ? QMetaType::Int : QMetaType::LongLong;
    const uint UIntType = sizeof(ulong) == sizeof(uint) ? QMetaType::UInt : QMetaType::ULongLong;
    return tp == QMetaType::Long ? IntType :
           tp == QMetaType::ULong ? UIntType : tp;
}
 
static int numericTypePromotion(uint t1, uint t2)
{
    Q_ASSERT(qIsNumericType(t1));
    Q_ASSERT(qIsNumericType(t2));
 
    if ((t1 == QMetaType::Bool && t2 == QMetaType::QString) ||
        (t2 == QMetaType::Bool && t1 == QMetaType::QString))
        return QMetaType::Bool;
 
    // C++ integral ranks: (4.13 Integer conversion rank [conv.rank])
    //   bool < signed char < short < int < long < long long
    //   unsigneds have the same rank as their signed counterparts
    // C++ integral promotion rules (4.5 Integral Promotions [conv.prom])
    // - any type with rank less than int can be converted to int or unsigned int
    // 5 Expressions [expr] paragraph 9:
    // - if either operand is double, the other shall be converted to double
    // -     "       "        float,   "          "         "         float
    // - if both operands have the same type, no further conversion is needed.
    // - if both are signed or if both are unsigned, convert to the one with highest rank
    // - if the unsigned has higher or same rank, convert the signed to the unsigned one
    // - if the signed can represent all values of the unsigned, convert to the signed
    // - otherwise, convert to the unsigned corresponding to the rank of the signed
 
    // floating point: we deviate from the C++ standard by always using qreal
    if (qIsFloatingPoint(t1) || qIsFloatingPoint(t2))
        return QMetaType::QReal;
 
    // integral rules:
    // for all platforms we support, int can always hold the values of lower-ranked types
    t1 = normalizeLowerRanks(t1);
    t2 = normalizeLowerRanks(t2);
 
    // normalize long / ulong: in all platforms we run, they're either the same as int or as long long
    t1 = normalizeLong(t1);
    t2 = normalizeLong(t2);
 
    // implement the other rules
    // the four possibilities are Int, UInt, LongLong and ULongLong
    // if any of the two is ULongLong, then it wins (highest rank, unsigned)
    // otherwise, if one of the two is LongLong, then the other is either LongLong too or lower-ranked
    // otherwise, if one of the two is UInt, then the other is either UInt too or Int
    if (t1 == QMetaType::ULongLong || t2 == QMetaType::ULongLong)
        return QMetaType::ULongLong;
    if (t1 == QMetaType::LongLong || t2 == QMetaType::LongLong)
        return QMetaType::LongLong;
    if (t1 == QMetaType::UInt || t2 == QMetaType::UInt)
        return QMetaType::UInt;
    return QMetaType::Int;
}
 
static bool integralEquals(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2)
{
    // use toLongLong to retrieve the data, it gets us all the bits
    bool ok;
    qlonglong l1 = qConvertToNumber(d1, &ok, promotedType == QMetaType::Bool);
    if (!ok)
        return false;
 
    qlonglong l2 = qConvertToNumber(d2, &ok, promotedType == QMetaType::Bool);
    if (!ok)
        return false;
 
    if (promotedType == QMetaType::Bool)
        return bool(l1) == bool(l2);
    if (promotedType == QMetaType::Int)
        return int(l1) == int(l2);
    if (promotedType == QMetaType::UInt)
        return uint(l1) == uint(l2);
    if (promotedType == QMetaType::LongLong)
        return l1 == l2;
    if (promotedType == QMetaType::ULongLong)
        return qulonglong(l1) == qulonglong(l2);
 
    Q_UNREACHABLE();
    return 0;
}
 
namespace {
template<typename Numeric>
int spaceShip(Numeric lhs, Numeric rhs)
{
    bool smaller;
    if constexpr (std::is_same_v<Numeric, QObject *>)
        smaller = std::less<QObject *>()(lhs, rhs); // can't use less all the time because of bool
    else
        smaller = lhs < rhs;
    if (smaller)
        return -1;
    else if (lhs == rhs)
        return 0;
    else
        return 1;
}
}
 
static std::optional<int> integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2)
{
    // use toLongLong to retrieve the data, it gets us all the bits
    bool ok;
    qlonglong l1 = qConvertToNumber(d1, &ok, promotedType == QMetaType::Bool);
    if (!ok)
        return std::nullopt;
 
    qlonglong l2 = qConvertToNumber(d2, &ok, promotedType == QMetaType::Bool);
    if (!ok)
        return std::nullopt;
 
    if (promotedType == QMetaType::Bool)
        return spaceShip<bool>(l1, l2);
    if (promotedType == QMetaType::Int)
        return spaceShip<int>(l1, l2);
    if (promotedType == QMetaType::UInt)
        return spaceShip<uint>(l1, l2);
    if (promotedType == QMetaType::LongLong)
        return spaceShip<qlonglong>(l1, l2);
    if (promotedType == QMetaType::ULongLong)
        return spaceShip<qulonglong>(l1, l2);
 
    Q_UNREACHABLE();
    return 0;
}
 
static std::optional<int> numericCompare(const QVariant::Private *d1, const QVariant::Private *d2)
{
    uint promotedType = numericTypePromotion(d1->typeId(), d2->typeId());
    if (promotedType != QMetaType::QReal)
        return integralCompare(promotedType, d1, d2);
    // qreal comparisons
    bool ok;
    qreal r1 = qConvertToRealNumber(d1, &ok);
    if (!ok)
        return std::nullopt;
    qreal r2 = qConvertToRealNumber(d2, &ok);
    if (!ok)
        return std::nullopt;
    if (r1 == r2)
        return 0;
 
    if (std::isnan(r1) || std::isnan(r2))
        return std::nullopt;
    return spaceShip<qreal>(r1, r2);
}
 
static bool numericEquals(const QVariant::Private *d1, const QVariant::Private *d2)
{
    uint promotedType = numericTypePromotion(d1->typeId(), d2->typeId());
    if (promotedType != QMetaType::QReal)
        return integralEquals(promotedType, d1, d2);
 
    // qreal comparisons
    bool ok;
    qreal r1 = qConvertToRealNumber(d1, &ok);
    if (!ok)
        return false;
    qreal r2 = qConvertToRealNumber(d2, &ok);
    if (!ok)
        return false;
    if (r1 == r2)
        return true;
 
    return false;
}
 
#ifndef QT_BOOTSTRAPPED
static bool canConvertMetaObject(QMetaType fromType, QMetaType toType)
{
    if ((fromType.flags() & QMetaType::PointerToQObject)
            && (toType.flags() & QMetaType::PointerToQObject)) {
        const QMetaObject *f = fromType.metaObject();
        const QMetaObject *t = toType.metaObject();
        return f && t && (f->inherits(t) || t->inherits(f));
    }
    return false;
}
 
static bool pointerEquals(const QVariant::Private *d1, const QVariant::Private *d2)
{
    // simply check whether both types point to the same data
    return d1->get<QObject *>() == d2->get<QObject *>();
}
 
static int pointerCompare(const QVariant::Private *d1, const QVariant::Private *d2)
{
    return spaceShip<QObject *>(d1->get<QObject *>(), d2->get<QObject *>());
}
#endif
 
bool QVariant::equals(const QVariant &v) const
{
    auto metatype = d.type();
 
    if (metatype != v.metaType()) {
        // try numeric comparisons, with C++ type promotion rules (no conversion)
        if (qIsNumericType(metatype.id()) && qIsNumericType(v.d.typeId()))
            return numericEquals(&d, &v.d);
#ifndef QT_BOOTSTRAPPED
        // if both types are related pointers to QObjects, check if they point to the same object
        if (canConvertMetaObject(metatype, v.metaType()))
            return pointerEquals(&d, &v.d);
#endif
        return false;
    }
 
    // For historical reasons: QVariant() == QVariant()
    if (!metatype.isValid())
        return true;
 
    return metatype.equals(d.storage(), v.d.storage());
}
 
static QPartialOrdering convertOptionalToPartialOrdering(const std::optional<int> &opt)
{
    if (!opt)
        return QPartialOrdering::Unordered;
    else if (*opt < 0)
        return QPartialOrdering::Less;
    else if (*opt == 0)
        return QPartialOrdering::Equivalent;
    else
        return QPartialOrdering::Greater;
}
 
QPartialOrdering QVariant::compare(const QVariant &lhs, const QVariant &rhs)
{
    QMetaType t = lhs.d.type();
    if (t != rhs.d.type()) {
        // try numeric comparisons, with C++ type promotion rules (no conversion)
        if (qIsNumericType(lhs.d.typeId()) && qIsNumericType(rhs.d.typeId()))
            return convertOptionalToPartialOrdering(numericCompare(&lhs.d, &rhs.d));
#ifndef QT_BOOTSTRAPPED
        if (canConvertMetaObject(lhs.metaType(), rhs.metaType()))
            return convertOptionalToPartialOrdering(pointerCompare(&lhs.d, &rhs.d));
#endif
        return QPartialOrdering::Unordered;
    }
    return t.compare(lhs.constData(), rhs.constData());
}
 
void *QVariant::data()
{
    detach();
    // set is_null to false, as the caller is likely to write some data into this variant
    d.is_null = false;
    return const_cast<void *>(constData());
}
 
bool QVariant::isNull() const
{
    if (d.is_null || !metaType().isValid())
        return true;
    if (metaType().flags() & QMetaType::IsPointer)
        return d.get<void *>() == nullptr;
    return false;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QVariant::qdebugHelper(QDebug dbg) const
{
    QDebugStateSaver saver(dbg);
    const uint typeId = d.typeId();
    dbg.nospace() << "QVariant(";
    if (typeId != QMetaType::UnknownType) {
        dbg << d.type().name() << ", ";
        bool streamed = d.type().debugStream(dbg, d.storage());
        if (!streamed && canConvert<QString>())
            dbg << toString();
    } else {
        dbg << "Invalid";
    }
    dbg << ')';
    return dbg;
}
 
#if QT_DEPRECATED_SINCE(6, 0)
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
 
QDebug operator<<(QDebug dbg, const QVariant::Type p)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QVariant::"
                  << (int(p) != int(QMetaType::UnknownType)
                     ? QMetaType(p).name()
                     : "Invalid");
    return dbg;
}
 
QT_WARNING_POP
#endif
 
#endif
 
const void *QtPrivate::QVariantTypeCoercer::convert(const QVariant &value, const QMetaType &type)
{
    if (type == QMetaType::fromType<QVariant>())
        return &value;
 
    if (type == value.metaType())
        return value.constData();
 
    if (value.canConvert(type)) {
        converted = value;
        if (converted.convert(type))
            return converted.constData();
    }
 
    return nullptr;
}
 
const void *QtPrivate::QVariantTypeCoercer::coerce(const QVariant &value, const QMetaType &type)
{
    if (const void *result = convert(value, type))
        return result;
 
    converted = QVariant(type);
    return converted.constData();
}
 
QVariantConstPointer::QVariantConstPointer(QVariant variant)
    : m_variant(std::move(variant))
{
}
 
QVariant QVariantConstPointer::operator*() const
{
    return m_variant;
}
 
const QVariant *QVariantConstPointer::operator->() const
{
    return &m_variant;
}
 
QT_END_NAMESPACE