qjsvalue.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtCore/qstring.h>
#include <QtCore/qvarlengtharray.h>
#include <QtCore/qdatetime.h>
#include "qjsvalue.h"
#include "qjsprimitivevalue.h"
#include "qjsmanagedvalue.h"
#include "qjsvalue_p.h"
#include "qv4value_p.h"
#include "qv4object_p.h"
#include "qv4functionobject_p.h"
#include "qv4dateobject_p.h"
#include "qv4runtime_p.h"
#include "qv4variantobject_p.h"
#include "qv4regexpobject_p.h"
#include "qv4errorobject_p.h"
#include <private/qv4mm_p.h>
#include <private/qv4jscall_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qv4qmetaobjectwrapper_p.h>
#include <private/qv4urlobject_p.h>
#include <private/qqmlbuiltins_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QV4;
 
QJSValue::QJSValue(bool value) : d(QJSValuePrivate::encode(value))
{
}
 
QJSValue::QJSValue(int value) : d(QJSValuePrivate::encode(value))
{
}
 
QJSValue::QJSValue(uint value) : d(QJSValuePrivate::encode(value))
{
}
 
QJSValue::QJSValue(double value) : d(QJSValuePrivate::encode(value))
{
}
 
QJSValue::QJSValue(const QString &value) : d(QJSValuePrivate::encode(value))
{
}
 
QJSValue::QJSValue(SpecialValue value)
    : d(value == NullValue ? QJSValuePrivate::encodeNull() : QJSValuePrivate::encodeUndefined())
{
}
 
QJSValue::QJSValue(const QLatin1String &value) : d(QJSValuePrivate::encode(value))
{
}
 
#ifndef QT_NO_CAST_FROM_ASCII
QJSValue::QJSValue(const char *value) : d(QJSValuePrivate::encode(QString::fromUtf8(value)))
{
}
#endif
 
QJSValue::QJSValue(const QJSValue &other) : d(other.d)
{
    switch (QJSValuePrivate::tag(d)) {
    case QJSValuePrivate::Kind::Undefined:
    case QJSValuePrivate::Kind::Null:
    case QJSValuePrivate::Kind::IntValue:
    case QJSValuePrivate::Kind::BoolValue:
        return;
    case QJSValuePrivate::Kind::DoublePtr:
        d = QJSValuePrivate::encode(*QJSValuePrivate::doublePtr(d));
        return;
    case QJSValuePrivate::Kind::QV4ValuePtr:
        d = QJSValuePrivate::encode(*QJSValuePrivate::qv4ValuePtr(d));
        return;
    case QJSValuePrivate::Kind::QStringPtr:
        d = QJSValuePrivate::encode(*QJSValuePrivate::qStringPtr(d));
        break;
    }
}
 
QJSValue::~QJSValue()
{
    QJSValuePrivate::free(this);
}
 
bool QJSValue::isBool() const
{
    return QJSValuePrivate::tag(d) == QJSValuePrivate::Kind::BoolValue;
}
 
bool QJSValue::isNumber() const
{
    switch (QJSValuePrivate::tag(d)) {
    case QJSValuePrivate::Kind::IntValue:
    case QJSValuePrivate::Kind::DoublePtr:
        return true;
    default:
        break;
    }
 
    return false;
}
 
bool QJSValue::isNull() const
{
    return QJSValuePrivate::tag(d) == QJSValuePrivate::Kind::Null;
}
 
bool QJSValue::isString() const
{
    switch (QJSValuePrivate::tag(d)) {
    case QJSValuePrivate::Kind::QStringPtr:
        return true;
    case QJSValuePrivate::Kind::QV4ValuePtr: {
        return QJSValuePrivate::qv4ValuePtr(d)->isString();
    }
    default:
        break;
    }
 
    return false;
}
 
bool QJSValue::isUndefined() const
{
    switch (QJSValuePrivate::tag(d)) {
    case QJSValuePrivate::Kind::Undefined:
        return true;
    case QJSValuePrivate::Kind::QV4ValuePtr:
        return QJSValuePrivate::qv4ValuePtr(d)->isUndefined();
    default:
        break;
    }
 
    return false;
}
 
bool QJSValue::isError() const
{
    return QJSValuePrivate::asManagedType<ErrorObject>(this);
}
 
bool QJSValue::isUrl() const
{
    return QJSValuePrivate::asManagedType<UrlObject>(this);
}
 
QJSValue::ErrorType QJSValue::errorType() const
{
    const QV4::ErrorObject *error = QJSValuePrivate::asManagedType<ErrorObject>(this);
    if (!error)
        return NoError;
    switch (error->d()->errorType) {
    case QV4::Heap::ErrorObject::Error:
        return GenericError;
    case QV4::Heap::ErrorObject::EvalError:
        return EvalError;
    case QV4::Heap::ErrorObject::RangeError:
        return RangeError;
    case QV4::Heap::ErrorObject::ReferenceError:
        return ReferenceError;
    case QV4::Heap::ErrorObject::SyntaxError:
        return SyntaxError;
    case QV4::Heap::ErrorObject::TypeError:
        return TypeError;
    case QV4::Heap::ErrorObject::URIError:
        return URIError;
    }
    Q_UNREACHABLE_RETURN(NoError);
}
 
bool QJSValue::isArray() const
{
    return QJSValuePrivate::asManagedType<ArrayObject>(this);
}
 
bool QJSValue::isObject() const
{
    return QJSValuePrivate::asManagedType<QV4::Object>(this);
}
 
bool QJSValue::isCallable() const
{
    return QJSValuePrivate::asManagedType<FunctionObject>(this);
}
 
#if QT_DEPRECATED_SINCE(6, 9)
bool QJSValue::isVariant() const
{
    if (QJSValuePrivate::asManagedType<QV4::VariantObject>(this))
        return true;
    if (auto vt = QJSValuePrivate::asManagedType<QV4::QQmlValueTypeWrapper>(this))
        if (vt->metaObject() == &QQmlVarForeign::staticMetaObject)
            return true;
    return false;
}
#endif
 
QString QJSValue::toString() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return *string;
 
    return QV4::Value::fromReturnedValue(QJSValuePrivate::asReturnedValue(this)).toQStringNoThrow();
}
 
template<typename T>
T caughtResult(const QJSValue *v, T (QV4::Value::*convert)() const)
{
    const T result = (QV4::Value::fromReturnedValue(QJSValuePrivate::asReturnedValue(v)).*convert)();
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(v);
    if (engine && engine->hasException) {
        engine->catchException();
        return T();
    }
    return result;
}
 
double QJSValue::toNumber() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return RuntimeHelpers::stringToNumber(*string);
 
    return caughtResult<double>(this, &QV4::Value::toNumber);
}
 
bool QJSValue::toBool() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return string->size() > 0;
 
    return caughtResult<bool>(this, &QV4::Value::toBoolean);
}
 
qint32 QJSValue::toInt() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return QV4::Value::toInt32(RuntimeHelpers::stringToNumber(*string));
 
    return caughtResult<qint32>(this, &QV4::Value::toInt32);
}
 
quint32 QJSValue::toUInt() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return QV4::Value::toUInt32(RuntimeHelpers::stringToNumber(*string));
 
    return caughtResult<quint32>(this, &QV4::Value::toUInt32);
}
 
QVariant QJSValue::toVariant() const
{
    return toVariant(ConvertJSObjects);
}
 
QVariant QJSValue::toVariant(QJSValue::ObjectConversionBehavior behavior) const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return QVariant(*string);
 
    QV4::Value val = QV4::Value::fromReturnedValue(QJSValuePrivate::asReturnedValue(this));
    if (val.isUndefined())
        return QVariant();
    if (val.isNull())
        return QVariant(QMetaType::fromType<std::nullptr_t>(), nullptr);
    if (val.isBoolean())
        return QVariant(val.booleanValue());
    if (val.isInt32()) // Includes doubles that can be losslessly casted to int
        return QVariant(val.integerValue());
    if (val.isNumber())
        return QVariant(val.doubleValue());
 
    Q_ASSERT(val.isManaged());
 
    if (val.isString())
        return QVariant(val.toQString());
    if (val.as<QV4::Managed>()) {
        if (behavior == RetainJSObjects)
            return QV4::ExecutionEngine::toVariant(
                    val, /*typeHint*/ QMetaType{}, /*createJSValueForObjectsAndSymbols=*/ true);
        else
            return QV4::ExecutionEngine::toVariantLossy(val);
    }
 
    Q_ASSERT(false);
    return QVariant();
}
 
QJSPrimitiveValue QJSValue::toPrimitive() const
{
    if (const QString *string = QJSValuePrivate::asQString(this))
        return *string;
 
    const QV4::Value val = QV4::Value::fromReturnedValue(QJSValuePrivate::asReturnedValue(this));
    return QV4::ExecutionEngine::createPrimitive(&val);
}
 
QJSValue QJSValue::call(const QJSValueList &args) const
{
    const FunctionObject *f = QJSValuePrivate::asManagedType<FunctionObject>(this);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    Q_ASSERT(engine);
 
    Scope scope(engine);
    JSCallArguments jsCallData(scope, args.size());
    *jsCallData.thisObject = engine->globalObject;
    for (int i = 0; i < args.size(); ++i) {
        if (!QJSValuePrivate::checkEngine(engine, args.at(i))) {
            qWarning("QJSValue::call() failed: cannot call function with argument created in a different engine");
            return QJSValue();
        }
        jsCallData.args[i] = QJSValuePrivate::convertToReturnedValue(engine, args.at(i));
    }
 
    ScopedValue result(scope, f->call(jsCallData));
    if (engine->hasException)
        result = engine->catchException();
    if (engine->isInterrupted.loadRelaxed())
        result = engine->newErrorObject(QStringLiteral("Interrupted"));
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QJSValue QJSValue::callWithInstance(const QJSValue &instance, const QJSValueList &args) const
{
    const FunctionObject *f = QJSValuePrivate::asManagedType<FunctionObject>(this);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    Q_ASSERT(engine);
    Scope scope(engine);
 
    if (!QJSValuePrivate::checkEngine(engine, instance)) {
        qWarning("QJSValue::call() failed: cannot call function with thisObject created in a different engine");
        return QJSValue();
    }
 
    JSCallArguments jsCallData(scope, args.size());
    *jsCallData.thisObject = QJSValuePrivate::convertToReturnedValue(engine, instance);
    for (int i = 0; i < args.size(); ++i) {
        if (!QJSValuePrivate::checkEngine(engine, args.at(i))) {
            qWarning("QJSValue::call() failed: cannot call function with argument created in a different engine");
            return QJSValue();
        }
        jsCallData.args[i] = QJSValuePrivate::convertToReturnedValue(engine, args.at(i));
    }
 
    ScopedValue result(scope, f->call(jsCallData));
    if (engine->hasException)
        result = engine->catchException();
    if (engine->isInterrupted.loadRelaxed())
        result = engine->newErrorObject(QStringLiteral("Interrupted"));
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QJSValue QJSValue::callAsConstructor(const QJSValueList &args) const
{
    const FunctionObject *f = QJSValuePrivate::asManagedType<FunctionObject>(this);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    Q_ASSERT(engine);
 
    Scope scope(engine);
    JSCallArguments jsCallData(scope, args.size());
    for (int i = 0; i < args.size(); ++i) {
        if (!QJSValuePrivate::checkEngine(engine, args.at(i))) {
            qWarning("QJSValue::callAsConstructor() failed: cannot construct function with argument created in a different engine");
            return QJSValue();
        }
        jsCallData.args[i] = QJSValuePrivate::convertToReturnedValue(engine, args.at(i));
    }
 
    ScopedValue result(scope, f->callAsConstructor(jsCallData));
    if (engine->hasException)
        result = engine->catchException();
    if (engine->isInterrupted.loadRelaxed())
        result = engine->newErrorObject(QStringLiteral("Interrupted"));
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QJSValue QJSValue::prototype() const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return QJSValue();
    QV4::Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asManagedType<QV4::Object>(this));
    if (!o)
        return QJSValue();
    ScopedObject p(scope, o->getPrototypeOf());
    if (!p)
        return QJSValue(NullValue);
    return QJSValuePrivate::fromReturnedValue(p.asReturnedValue());
}
 
void QJSValue::setPrototype(const QJSValue& prototype)
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return;
    Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return;
    QV4::Value val = QV4::Value::fromReturnedValue(QJSValuePrivate::asReturnedValue(&prototype));
    if (val.isNull()) {
        o->setPrototypeOf(nullptr);
        return;
    }
 
    ScopedObject p(scope, val);
    if (!p)
        return;
    if (o->engine() != p->engine()) {
        qWarning("QJSValue::setPrototype() failed: cannot set a prototype created in a different engine");
        return;
    }
    if (!o->setPrototypeOf(p))
        qWarning("QJSValue::setPrototype() failed: cyclic prototype value");
}
 
QJSValue& QJSValue::operator=(const QJSValue& other)
{
    if (d == other.d)
        return *this;
 
    QJSValuePrivate::free(this);
    d = 0;
 
    if (const QString *string = QJSValuePrivate::asQString(&other))
        QJSValuePrivate::setString(this, *string);
    else
        QJSValuePrivate::setValue(this, QJSValuePrivate::asReturnedValue(&other));
 
    return *this;
}
 
QJSValue::QJSValue(QJSPrimitiveValue &&value)
{
    switch (value.type()) {
    case QJSPrimitiveValue::Undefined:
        d = QJSValuePrivate::encodeUndefined();
        return;
    case QJSPrimitiveValue::Null:
        d = QJSValuePrivate::encodeNull();
        return;
    case QJSPrimitiveValue::Boolean:
        d = QJSValuePrivate::encode(value.asBoolean());
        return;
    case QJSPrimitiveValue::Integer:
        d = QJSValuePrivate::encode(value.asInteger());
        return;
    case QJSPrimitiveValue::Double:
        d = QJSValuePrivate::encode(value.asDouble());
        return;
    case QJSPrimitiveValue::String:
        d = QJSValuePrivate::encode(value.asString());
        return;
    }
 
    Q_UNREACHABLE();
}
 
QJSValue::QJSValue(QJSManagedValue &&value)
{
    if (!value.d) {
        d = QV4::Encode::undefined();
    } else if (value.d->isManaged()) {
        // If it's managed, we can adopt the persistent value.
        QJSValuePrivate::adoptPersistentValue(this, value.d);
        value.d = nullptr;
    } else {
        d = QJSValuePrivate::encode(*value.d);
        QV4::PersistentValueStorage::free(value.d);
        value.d = nullptr;
    }
}
 
static bool js_equal(const QString &string, const QV4::Value &value)
{
    if (String *s = value.stringValue())
        return string == s->toQString();
    if (value.isNumber())
        return RuntimeHelpers::stringToNumber(string) == value.asDouble();
    if (value.isBoolean())
        return RuntimeHelpers::stringToNumber(string) == double(value.booleanValue());
    if (QV4::Object *o = value.objectValue()) {
        Scope scope(o->engine());
        ScopedValue p(scope, RuntimeHelpers::toPrimitive(value, PREFERREDTYPE_HINT));
        return js_equal(string, p);
    }
    return false;
}
 
bool QJSValue::equals(const QJSValue& other) const
{
    if (const QString *string = QJSValuePrivate::asQString(this)) {
        if (const QString *otherString = QJSValuePrivate::asQString(&other))
            return *string == *otherString;
        return js_equal(*string, QJSValuePrivate::asReturnedValue(&other));
    }
 
    if (const QString *otherString = QJSValuePrivate::asQString(&other))
        return js_equal(*otherString, QJSValuePrivate::asReturnedValue(this));
 
    return Runtime::CompareEqual::call(QJSValuePrivate::asReturnedValue(this),
                                       QJSValuePrivate::asReturnedValue(&other));
}
 
bool QJSValue::strictlyEquals(const QJSValue& other) const
{
    if (const QString *string = QJSValuePrivate::asQString(this)) {
        if (const QString *otherString = QJSValuePrivate::asQString(&other))
            return *string == *otherString;
        if (const String *s = QJSValuePrivate::asManagedType<String>(&other))
            return *string == s->toQString();
        return false;
    }
 
    if (const QString *otherString = QJSValuePrivate::asQString(&other)) {
        if (const String *s = QJSValuePrivate::asManagedType<String>(this))
            return *otherString == s->toQString();
        return false;
    }
 
    return RuntimeHelpers::strictEqual(QJSValuePrivate::asReturnedValue(this),
                                       QJSValuePrivate::asReturnedValue(&other));
}
 
QJSValue QJSValue::property(const QString& name) const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return QJSValue();
 
    QV4::Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return QJSValue();
 
    ScopedString s(scope, engine->newString(name));
    QV4::ScopedValue result(scope, o->get(s->toPropertyKey()));
    if (engine->hasException)
        result = engine->catchException();
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QJSValue QJSValue::property(quint32 arrayIndex) const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return QJSValue();
 
    QV4::Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return QJSValue();
 
    QV4::ScopedValue result(scope, arrayIndex == UINT_MAX ? o->get(engine->id_uintMax()) : o->get(arrayIndex));
    if (engine->hasException)
        engine->catchException();
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
void QJSValue::setProperty(const QString& name, const QJSValue& value)
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return;
    Scope scope(engine);
 
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return;
 
    if (!QJSValuePrivate::checkEngine(engine, value)) {
        qWarning("QJSValue::setProperty(%s) failed: cannot set value created in a different engine", name.toUtf8().constData());
        return;
    }
 
    ScopedString s(scope, engine->newString(name));
    QV4::ScopedValue v(scope, QJSValuePrivate::convertToReturnedValue(engine, value));
    o->put(s->toPropertyKey(), v);
    if (engine->hasException)
        engine->catchException();
}
 
void QJSValue::setProperty(quint32 arrayIndex, const QJSValue& value)
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return;
    Scope scope(engine);
 
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return;
 
    if (!QJSValuePrivate::checkEngine(engine, value)) {
        qWarning("QJSValue::setProperty(%d) failed: cannot set value created in a different engine", arrayIndex);
        return;
    }
 
    QV4::ScopedValue v(scope, QJSValuePrivate::convertToReturnedValue(engine, value));
    PropertyKey id = arrayIndex != UINT_MAX ? PropertyKey::fromArrayIndex(arrayIndex) : engine->id_uintMax()->propertyKey();
    o->put(id, v);
    if (engine->hasException)
        engine->catchException();
}
 
bool QJSValue::deleteProperty(const QString &name)
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return false;
 
    Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return false;
 
    ScopedString s(scope, engine->newString(name));
    return o->deleteProperty(s->toPropertyKey());
}
 
bool QJSValue::hasProperty(const QString &name) const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return false;
 
    Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return false;
 
    ScopedString s(scope, engine->newString(name));
    return o->hasProperty(s->toPropertyKey());
}
 
bool QJSValue::hasOwnProperty(const QString &name) const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return false;
 
    Scope scope(engine);
    ScopedObject o(scope, QJSValuePrivate::asReturnedValue(this));
    if (!o)
        return false;
 
    ScopedString s(scope, engine->newIdentifier(name));
    return o->getOwnProperty(s->propertyKey()) != Attr_Invalid;
}
 
QObject *QJSValue::toQObject() const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return nullptr;
    QV4::Scope scope(engine);
    QV4::Scoped<QV4::QObjectWrapper> wrapper(scope, QJSValuePrivate::asReturnedValue(this));
    if (!wrapper)
        return nullptr;
 
    return wrapper->object();
}
 
const QMetaObject *QJSValue::toQMetaObject() const
{
    QV4::ExecutionEngine *engine = QJSValuePrivate::engine(this);
    if (!engine)
        return nullptr;
    QV4::Scope scope(engine);
    QV4::Scoped<QV4::QMetaObjectWrapper> wrapper(scope, QJSValuePrivate::asReturnedValue(this));
    if (!wrapper)
        return nullptr;
 
    return wrapper->metaObject();
}
 
 
QDateTime QJSValue::toDateTime() const
{
    if (const QV4::DateObject *date = QJSValuePrivate::asManagedType<DateObject>(this))
        return date->toQDateTime();
    return QDateTime();
}
 
bool QJSValue::isDate() const
{
    return QJSValuePrivate::asManagedType<DateObject>(this);
}
 
bool QJSValue::isRegExp() const
{
    return QJSValuePrivate::asManagedType<RegExpObject>(this);
}
 
bool QJSValue::isQObject() const
{
    return QJSValuePrivate::asManagedType<QV4::QObjectWrapper>(this);
}
 
bool QJSValue::isQMetaObject() const
{
    return QJSValuePrivate::asManagedType<QV4::QMetaObjectWrapper>(this);
}
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QJSValue &jsv)
{
    quint32 isNullOrUndefined = 0;
    if (jsv.isNull())
        isNullOrUndefined |= 0x1;
    if (jsv.isUndefined())
        isNullOrUndefined |= 0x2;
    stream << isNullOrUndefined;
    if (!isNullOrUndefined) {
        const QVariant v = jsv.toVariant();
        switch (v.userType()) {
        case QMetaType::Bool:
        case QMetaType::Double:
        case QMetaType::Int:
        case QMetaType::QString:
            v.save(stream);
            break;
        default:
            qWarning() << "QDataStream::operator<< was to save a non-trivial QJSValue."
                       << "This is not supported anymore, please stream a QVariant instead.";
            QVariant().save(stream);
            break;
        }
 
    }
    return stream;
}
 
QDataStream &operator>>(QDataStream &stream, QJSValue &jsv)
{
    quint32 isNullOrUndefined;
    stream >> isNullOrUndefined;
 
    if (isNullOrUndefined & 0x1) {
        jsv = QJSValue(QJSValue::NullValue);
    } else if (isNullOrUndefined & 0x2) {
        jsv = QJSValue();
    } else {
        QVariant v;
        v.load(stream);
 
        switch (v.userType()) {
        case QMetaType::Bool:
            jsv = QJSValue(v.toBool());
            break;
        case QMetaType::Double:
            jsv = QJSValue(v.toDouble());
            break;
        case QMetaType::Int:
            jsv = QJSValue(v.toInt());
            break;
        case QMetaType::QString:
            jsv = QJSValue(v.toString());
            break;
        default:
            qWarning() << "QDataStream::operator>> to restore a non-trivial QJSValue."
                       << "This is not supported anymore, please stream a QVariant instead.";
            break;
        }
    }
    return stream;
}
#endif
 
QT_END_NAMESPACE