qvariant.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2021 Intel Corporation.
// Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qvariant_p.h"
#include "qbitarray.h"
#include "qbytearray.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qmap.h"
#include "qhash.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/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 <memory>
 
#include <cmath>
#include <float.h>
#include <cstring>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace { // anonymous used to hide QVariant handlers
 
static qlonglong qMetaTypeNumberBySize(const QVariant::Private *d)
{
    switch (d->typeInterface()->size) {
    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>();
    }
    Q_UNREACHABLE_RETURN(0);
}
 
static qlonglong qMetaTypeNumber(const QVariant::Private *d)
{
    switch (d->typeInterface()->typeId) {
    case QMetaType::Int:
    case QMetaType::LongLong:
    case QMetaType::Char:
    case QMetaType::SChar:
    case QMetaType::Short:
    case QMetaType::Long:
        return qMetaTypeNumberBySize(d);
    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_UNREACHABLE_RETURN(0);
}
 
static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
{
    switch (d->typeInterface()->size) {
    case 1:
        return d->get<unsigned char>();
    case 2:
        return d->get<unsigned short>();
    case 4:
        return d->get<unsigned int>();
    case 8:
        return d->get<qulonglong>();
    }
    Q_UNREACHABLE_RETURN(0);
}
 
static std::optional<qlonglong> qConvertToNumber(const QVariant::Private *d, bool allowStringToBool = false)
{
    bool ok;
    switch (d->typeInterface()->typeId) {
    case QMetaType::QString: {
        const QString &s = d->get<QString>();
        if (qlonglong l = s.toLongLong(&ok); ok)
            return l;
        if (allowStringToBool) {
            if (s == "false"_L1 || s == "0"_L1)
                return 0;
            if (s == "true"_L1 || s == "1"_L1)
                return 1;
        }
        return std::nullopt;
    }
    case QMetaType::QChar:
        return d->get<QChar>().unicode();
    case QMetaType::QByteArray:
        if (qlonglong l = d->get<QByteArray>().toLongLong(&ok); ok)
            return l;
        return std::nullopt;
    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::Char16:
    case QMetaType::Char32:
    case QMetaType::UShort:
    case QMetaType::ULong:
        return qlonglong(qMetaTypeUNumber(d));
    }
 
    if (d->typeInterface()->flags & QMetaType::IsEnumeration
        || d->typeInterface()->typeId == QMetaType::QCborSimpleType)
        return qMetaTypeNumberBySize(d);
 
    return std::nullopt;
}
 
static std::optional<double> qConvertToRealNumber(const QVariant::Private *d)
{
    bool ok;
    switch (d->typeInterface()->typeId) {
    case QMetaType::QString:
        if (double r = d->get<QString>().toDouble(&ok); ok)
            return r;
        return std::nullopt;
    case QMetaType::Double:
        return d->get<double>();
    case QMetaType::Float:
        return double(d->get<float>());
    case QMetaType::Float16:
        return double(d->get<qfloat16>());
    case QMetaType::ULongLong:
    case QMetaType::UInt:
    case QMetaType::UChar:
    case QMetaType::Char16:
    case QMetaType::Char32:
    case QMetaType::UShort:
    case QMetaType::ULong:
        return double(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
        if (std::optional<qlonglong> l = qConvertToNumber(d))
            return double(*l);
        return std::nullopt;
    }
}
 
static bool isValidMetaTypeForVariant(const QtPrivate::QMetaTypeInterface *iface, const void *copy)
{
    using namespace QtMetaTypePrivate;
    if (!iface || iface->size == 0)
        return false;
 
    Q_ASSERT(!isInterfaceFor<void>(iface));  // only void should have size 0
    if (!isCopyConstructible(iface) || !isDestructible(iface)) {
        // all meta types must be copyable (because QVariant is) and
        // destructible (because QVariant owns it)
        qWarning("QVariant: Provided metatype for '%s' does not support destruction and "
                 "copy construction", iface->name);
        return false;
    }
    if (!copy && !isDefaultConstructible(iface)) {
        // non-default-constructible types are acceptable, but not if you're
        // asking us to construct from nothing
        qWarning("QVariant: Cannot create type '%s' without a default constructor", iface->name);
        return false;
    }
 
    return true;
}
 
enum CustomConstructMoveOptions {
    UseCopy,  // custom construct uses the copy ctor unconditionally
    // future option: TryMove: uses move ctor if available, else copy ctor
    ForceMove, // custom construct use the move ctor (which must exist)
};
 
enum CustomConstructNullabilityOption {
    MaybeNull, // copy might be null, might be non-null
    NonNull, // copy is guarantueed to be non-null
    // future option: AlwaysNull?
};
 
// the type of d has already been set, but other field are not set
template <CustomConstructMoveOptions moveOption = UseCopy, CustomConstructNullabilityOption nullability = MaybeNull>
static void customConstruct(const QtPrivate::QMetaTypeInterface *iface, QVariant::Private *d,
                            std::conditional_t<moveOption == ForceMove, void *, const void *> copy)
{
    using namespace QtMetaTypePrivate;
    Q_ASSERT(iface);
    Q_ASSERT(iface->size);
    Q_ASSERT(!isInterfaceFor<void>(iface));
    Q_ASSERT(isCopyConstructible(iface));
    Q_ASSERT(isDestructible(iface));
    Q_ASSERT(copy || isDefaultConstructible(iface));
    if constexpr (moveOption == ForceMove)
        Q_ASSERT(isMoveConstructible(iface));
    if constexpr (nullability == NonNull)
        Q_ASSERT(copy != nullptr);
 
    // 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.
    // ### Qt 7: remove nullptr_t special casing
    d->is_null = !copy QT6_ONLY(|| isInterfaceFor<std::nullptr_t>(iface));
 
    if (QVariant::Private::canUseInternalSpace(iface)) {
        d->is_shared = false;
        if (!copy && !iface->defaultCtr)
            return;     // trivial default constructor and it's OK to build in 0-filled storage, which we've already done
        if constexpr (moveOption == ForceMove && nullability == NonNull)
            moveConstruct(iface, d->data.data, copy);
        else
            construct(iface, d->data.data, copy);
    } else {
        d->data.shared = customConstructShared(iface->size, iface->alignment, [=](void *where) {
            if constexpr (moveOption == ForceMove && nullability == NonNull)
                moveConstruct(iface, where, copy);
            else
                construct(iface, where, copy);
        });
        d->is_shared = true;
    }
}
 
static void customClear(QVariant::Private *d)
{
    const QtPrivate::QMetaTypeInterface *iface = d->typeInterface();
    if (!iface)
        return;
    if (!d->is_shared) {
        QtMetaTypePrivate::destruct(iface, d->data.data);
    } else {
        QtMetaTypePrivate::destruct(iface, d->data.shared->data());
        QVariant::PrivateShared::free(d->data.shared);
    }
}
 
static QVariant::Private clonePrivate(const QVariant::Private &other)
{
    QVariant::Private d = other;
    if (d.is_shared) {
        d.data.shared->ref.ref();
    } else if (const QtPrivate::QMetaTypeInterface *iface = d.typeInterface()) {
        Q_ASSERT(d.canUseInternalSpace(iface));
 
        // if not trivially copyable, ask to copy
        if (iface->copyCtr)
            QtMetaTypePrivate::copyConstruct(iface, d.data.data, other.data.data);
    }
    return d;
}
 
} // 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)
{
    *this = QVariant::fromMetaType(type, copy);
}
 
QVariant::~QVariant()
{
    if (!d.is_shared || !d.data.shared->ref.deref())
        customClear(&d);
}
 
QVariant::QVariant(const QVariant &p)
    : d(clonePrivate(p.d))
{
}
 
QVariant::QVariant(std::in_place_t, QMetaType type) : d(type.iface())
{
    // we query the metatype instead of detecting it at compile time
    // so that we can change relocatability of internal types
    if (!Private::canUseInternalSpace(type.iface())) {
        d.data.shared = PrivateShared::create(type.sizeOf(), type.alignOf());
        d.is_shared = true;
    }
}
 
void *QVariant::prepareForEmplace(QMetaType type)
{
    /* There are two cases where we can reuse the existing storage
       (1) The new type fits in QVariant's SBO storage
       (2) We are using the externally allocated storage, the variant is
           detached, and the new type fits into the existing storage.
       In all other cases (3), we cannot reuse the storage.
     */
    auto typeFits = [&] {
        auto newIface = type.iface();
        auto oldIface = d.typeInterface();
        auto newSize = PrivateShared::computeAllocationSize(newIface->size, newIface->alignment);
        auto oldSize = PrivateShared::computeAllocationSize(oldIface->size, oldIface->alignment);
        return newSize <= oldSize;
    };
    if (Private::canUseInternalSpace(type.iface())) { // (1)
        clear();
        d.packedType = quintptr(type.iface()) >> 2;
        return d.data.data;
    } else if (d.is_shared && isDetached() && typeFits()) { // (2)
        QtMetaTypePrivate::destruct(d.typeInterface(), d.data.shared->data());
        // compare QVariant::PrivateShared::create
        const auto ps = d.data.shared;
        const auto align = type.alignOf();
        ps->offset =  PrivateShared::computeOffset(ps, align);
        d.packedType = quintptr(type.iface()) >> 2;
        return ps->data();
    }
    // (3)
    QVariant newVariant(std::in_place, type);
    swap(newVariant);
    // const cast is safe, we're in a non-const method
    return const_cast<void *>(d.storage());
}
 
QVariant::QVariant(QMetaType type, const void *copy)
    : d()
{
    *this = fromMetaType(type, copy);
}
 
QVariant::QVariant(int val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(uint val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(qlonglong val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(qulonglong val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(bool val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(double val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(float val) noexcept : d(std::piecewise_construct_t{}, val) {}
 
QVariant::QVariant(const QByteArray &val) noexcept : d(std::piecewise_construct_t{}, val) {}
#ifndef QT_BOOTSTRAPPED
QVariant::QVariant(const QBitArray &val) noexcept : d(std::piecewise_construct_t{}, val) {}
#endif
QVariant::QVariant(const QString &val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(QChar val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(const QStringList &val) noexcept : d(std::piecewise_construct_t{}, val) {}
 
QVariant::QVariant(QDate val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(QTime val) noexcept : d(std::piecewise_construct_t{}, val) {}
QVariant::QVariant(const QDateTime &val) noexcept : d(std::piecewise_construct_t{}, val) {}
 
QVariant::QVariant(const QList<QVariant> &list) noexcept : d(std::piecewise_construct_t{}, list) {}
QVariant::QVariant(const QMap<QString, QVariant> &map) noexcept : d(std::piecewise_construct_t{}, map) {}
QVariant::QVariant(const QHash<QString, QVariant> &hash) noexcept : d(std::piecewise_construct_t{}, hash) {}
 
QVariant::QVariant(QLatin1StringView val) : QVariant(QString(val)) {}
 
#if QT_CONFIG(easingcurve)
QVariant::QVariant(const QEasingCurve &val) : d(std::piecewise_construct_t{}, val) {}
#endif
#ifndef QT_NO_GEOM_VARIANT
QVariant::QVariant(QPoint pt) noexcept
    : d(std::piecewise_construct_t{}, pt) {}
QVariant::QVariant(QPointF pt) noexcept(Private::FitsInInternalSize<sizeof(qreal) * 2>)
    : d(std::piecewise_construct_t{}, pt) {}
QVariant::QVariant(QRect r) noexcept(Private::FitsInInternalSize<sizeof(int) * 4>)
    : d(std::piecewise_construct_t{}, r) {}
QVariant::QVariant(QRectF r) noexcept(Private::FitsInInternalSize<sizeof(qreal) * 4>)
    : d(std::piecewise_construct_t{}, r) {}
QVariant::QVariant(QLine l) noexcept(Private::FitsInInternalSize<sizeof(int) * 4>)
    : d(std::piecewise_construct_t{}, l) {}
QVariant::QVariant(QLineF l) noexcept(Private::FitsInInternalSize<sizeof(qreal) * 4>)
    : d(std::piecewise_construct_t{}, l) {}
QVariant::QVariant(QSize s) noexcept
    : d(std::piecewise_construct_t{}, s) {}
QVariant::QVariant(QSizeF s) noexcept(Private::FitsInInternalSize<sizeof(qreal) * 2>)
    : d(std::piecewise_construct_t{}, s) {}
#endif
#ifndef QT_BOOTSTRAPPED
QVariant::QVariant(const QUrl &u) noexcept : d(std::piecewise_construct_t{}, u) {}
#endif
QVariant::QVariant(const QLocale &l) noexcept : d(std::piecewise_construct_t{}, l) {}
#if QT_CONFIG(regularexpression)
QVariant::QVariant(const QRegularExpression &re) noexcept : d(std::piecewise_construct_t{}, re) {}
#endif // QT_CONFIG(regularexpression)
QVariant::QVariant(QUuid uuid) noexcept(Private::FitsInInternalSize<16>) : d(std::piecewise_construct_t{}, uuid) {}
#ifndef QT_BOOTSTRAPPED
QVariant::QVariant(const QJsonValue &jsonValue) noexcept(Private::FitsInInternalSize<sizeof(CborValueStandIn)>)
    : d(std::piecewise_construct_t{}, jsonValue)
{ static_assert(sizeof(CborValueStandIn) == sizeof(QJsonValue)); }
QVariant::QVariant(const QJsonObject &jsonObject) noexcept : d(std::piecewise_construct_t{}, jsonObject) {}
QVariant::QVariant(const QJsonArray &jsonArray) noexcept : d(std::piecewise_construct_t{}, jsonArray) {}
QVariant::QVariant(const QJsonDocument &jsonDocument) : d(std::piecewise_construct_t{}, jsonDocument) {}
#endif // QT_BOOTSTRAPPED
#if QT_CONFIG(itemmodel)
QVariant::QVariant(const QModelIndex &modelIndex) noexcept(Private::FitsInInternalSize<8 + 2 * sizeof(quintptr)>)
    : d(std::piecewise_construct_t{}, modelIndex) {}
QVariant::QVariant(const QPersistentModelIndex &modelIndex) : d(std::piecewise_construct_t{}, modelIndex) {}
#endif
 
QMetaType QVariant::metaType() const
{
    return d.type();
}
 
QVariant &QVariant::operator=(const QVariant &variant)
{
    if (this == &variant)
        return *this;
 
    clear();
    d = clonePrivate(variant.d);
    return *this;
}
 
void QVariant::detach()
{
    if (!d.is_shared || d.data.shared->ref.loadRelaxed() == 1)
        return;
 
    Q_ASSERT(isValidMetaTypeForVariant(d.typeInterface(), constData()));
    Private dd(d.typeInterface());
    // null variant is never shared; anything else is NonNull
    customConstruct<UseCopy, NonNull>(d.typeInterface(), &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())
        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.type().id());
    }
}
 
void QVariant::save(QDataStream &s) const
{
    quint32 typeId = d.type().id();
    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.type().id());
        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);
}
 
#ifndef QT_BOOTSTRAPPED
QBitArray QVariant::toBitArray() const
{
    return qvariant_cast<QBitArray>(*this);
}
#endif // QT_BOOTSTRAPPED
 
template <typename T>
inline T qNumVariantToHelper(const QVariant::Private &d, bool *ok)
{
    QMetaType t = QMetaType::fromType<T>();
    if (ok)
        *ok = true;
 
    if (d.type() == t)
        return d.get<T>();
 
    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);
}
 
uint QVariant::toUInt(bool *ok) const
{
    return qNumVariantToHelper<uint>(d, ok);
}
 
qlonglong QVariant::toLongLong(bool *ok) const
{
    return qNumVariantToHelper<qlonglong>(d, ok);
}
 
qulonglong QVariant::toULongLong(bool *ok) const
{
    return qNumVariantToHelper<qulonglong>(d, ok);
}
 
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);
}
 
float QVariant::toFloat(bool *ok) const
{
    return qNumVariantToHelper<float>(d, ok);
}
 
qreal QVariant::toReal(bool *ok) const
{
    return qNumVariantToHelper<qreal>(d, ok);
}
 
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.type().id() != 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::Char16 |
            Q_UINT64_C(1) << QMetaType::Char32 |
            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 || tp == QMetaType::Float16;
}
 
static bool canBeNumericallyCompared(const QtPrivate::QMetaTypeInterface *iface1,
                                     const QtPrivate::QMetaTypeInterface *iface2)
{
    if (!iface1 || !iface2)
        return false;
 
    // We don't need QMetaType::id() here because the type Id is always stored
    // directly for all built-in types.
    bool isNumeric1 = qIsNumericType(iface1->typeId);
    bool isNumeric2 = qIsNumericType(iface2->typeId);
 
    // if they're both numeric (or QString), then they can be compared
    if (isNumeric1 && isNumeric2)
        return true;
 
    bool isEnum1 = iface1->flags & QMetaType::IsEnumeration;
    bool isEnum2 = iface2->flags & QMetaType::IsEnumeration;
 
    // if both are enums, we can only compare if they are the same enum
    // (the language does allow comparing two different enum types, but that's
    // usually considered poor coding and produces a warning)
    if (isEnum1 && isEnum2)
        return QMetaType(iface1) == QMetaType(iface2);
 
    // if one is an enum and the other is a numeric, we can compare too
    if (isEnum1 && isNumeric2)
        return true;
    if (isNumeric1 && isEnum2)
        return true;
 
    // we need at least one enum and one numeric...
    return false;
}
 
static int numericTypePromotion(const QtPrivate::QMetaTypeInterface *iface1,
                                const QtPrivate::QMetaTypeInterface *iface2)
{
    Q_ASSERT(canBeNumericallyCompared(iface1, iface2));
 
    // We don't need QMetaType::id() here because the type Id is always stored
    // directly for the types we're comparing against below.
    uint t1 = iface1->typeId;
    uint t2 = iface2->typeId;
 
    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;
 
    auto isUnsigned = [](uint tp) {
        // only types for which sizeof(T) >= sizeof(int); lesser ones promote to int
        return tp == QMetaType::ULongLong || tp == QMetaType::ULong ||
                tp == QMetaType::UInt || tp == QMetaType::Char32;
    };
    bool isUnsigned1 = isUnsigned(t1);
    bool isUnsigned2 = isUnsigned(t2);
 
    // integral rules:
    // 1) if either type is a 64-bit unsigned, compare as 64-bit unsigned
    if (isUnsigned1 && iface1->size > sizeof(int))
        return QMetaType::ULongLong;
    if (isUnsigned2 && iface2->size > sizeof(int))
        return QMetaType::ULongLong;
 
    // 2) if either type is 64-bit, compare as 64-bit signed
    if (iface1->size > sizeof(int) || iface2->size > sizeof(int))
        return QMetaType::LongLong;
 
    // 3) if either type is 32-bit unsigned, compare as 32-bit unsigned
    if (isUnsigned1 || isUnsigned2)
        return QMetaType::UInt;
 
    // 4) otherwise, just do int promotion
    return QMetaType::Int;
}
 
template <typename Numeric> static QPartialOrdering spaceShip(Numeric lhs, Numeric rhs)
{
    if (lhs == rhs)
        return QPartialOrdering::Equivalent;
    if constexpr (std::numeric_limits<Numeric>::has_quiet_NaN) {
        if (std::isnan(lhs) || std::isnan(rhs))
            return QPartialOrdering::Unordered;
    }
 
    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;
    return smaller ? QPartialOrdering::Less : QPartialOrdering::Greater;
}
 
static QPartialOrdering integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2)
{
    // use toLongLong to retrieve the data, it gets us all the bits
    std::optional<qlonglong> l1 = qConvertToNumber(d1, promotedType == QMetaType::Bool);
    std::optional<qlonglong> l2 = qConvertToNumber(d2, promotedType == QMetaType::Bool);
    if (!l1 || !l2)
        return QPartialOrdering::Unordered;
    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);
 
    return spaceShip<int>(*l1, *l2);
}
 
static QPartialOrdering numericCompare(const QVariant::Private *d1, const QVariant::Private *d2)
{
    uint promotedType = numericTypePromotion(d1->typeInterface(), d2->typeInterface());
    if (promotedType != QMetaType::QReal)
        return integralCompare(promotedType, d1, d2);
 
    // floating point comparison
    const auto r1 = qConvertToRealNumber(d1);
    const auto r2 = qConvertToRealNumber(d2);
    if (!r1 || !r2)
        return QPartialOrdering::Unordered;
    if (*r1 == *r2)
        return QPartialOrdering::Equivalent;
 
    return spaceShip(*r1, *r2);
}
 
#ifndef QT_BOOTSTRAPPED
static bool qvCanConvertMetaObject(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 QPartialOrdering 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 (canBeNumericallyCompared(metatype.iface(), v.d.type().iface()))
            return numericCompare(&d, &v.d) == QPartialOrdering::Equivalent;
#ifndef QT_BOOTSTRAPPED
        // if both types are related pointers to QObjects, check if they point to the same object
        if (qvCanConvertMetaObject(metatype, v.metaType()))
            return pointerCompare(&d, &v.d) == QPartialOrdering::Equivalent;
#endif
        return false;
    }
 
    // For historical reasons: QVariant() == QVariant()
    if (!metatype.isValid())
        return true;
 
    return metatype.equals(d.storage(), v.d.storage());
}
 
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 (canBeNumericallyCompared(lhs.d.type().iface(), rhs.d.type().iface()))
            return numericCompare(&lhs.d, &rhs.d);
#ifndef QT_BOOTSTRAPPED
        if (qvCanConvertMetaObject(lhs.metaType(), rhs.metaType()))
            return 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.type().id();
    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;
}
 
QVariant QVariant::moveConstruct(QMetaType type, void *data)
{
    QVariant var;
    var.d = QVariant::Private(type.d_ptr);
    customConstruct<ForceMove, NonNull>(type.d_ptr, &var.d, data);
    return var;
}
 
QVariant QVariant::copyConstruct(QMetaType type, const void *data)
{
    QVariant var;
    var.d = QVariant::Private(type.d_ptr);
    customConstruct<UseCopy, NonNull>(type.d_ptr, &var.d, data);
    return var;
}
 
#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
 
QVariant QVariant::fromMetaType(QMetaType type, const void *copy)
{
    QVariant result;
    type.registerType();
    const auto iface = type.iface();
    if (isValidMetaTypeForVariant(iface, copy)) {
        result.d = Private(iface);
        customConstruct(iface, &result.d, copy);
    }
    return result;
}
 
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