qjsonvalue.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// Copyright (C) 2022 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <qjsonobject.h>
#include <qjsonvalue.h>
#include <qjsonarray.h>
#include <qjsondocument.h>
#include <qurl.h>
#include <quuid.h>
#include <qvariant.h>
#include <qstringlist.h>
#include <qmap.h>
#include <qhash.h>
#include <qdebug.h>
#include "qdatastream.h"
 
#include <private/qnumeric_p.h>
#include <private/qcborvalue_p.h>
 
#include <qcborarray.h>
#include <qcbormap.h>
 
#include "qjson_p.h"
 
QT_BEGIN_NAMESPACE
 
static QJsonValue::Type convertFromCborType(QCborValue::Type type) noexcept
{
    switch (type) {
    case QCborValue::Null:
        return QJsonValue::Null;
    case QCborValue::True:
    case QCborValue::False:
        return QJsonValue::Bool;
    case QCborValue::Double:
    case QCborValue::Integer:
        return QJsonValue::Double;
    case QCborValue::String:
        return QJsonValue::String;
    case QCborValue::Array:
        return QJsonValue::Array;
    case QCborValue::Map:
        return QJsonValue::Object;
    case QCborValue::Undefined:
    default:
        return QJsonValue::Undefined;
    }
}
 
QJsonValue::QJsonValue(Type type)
{
    switch (type) {
    case Null:
        value = QCborValue::Null;
        break;
    case Bool:
        value = QCborValue::False;
        break;
    case Double:
        value = QCborValue::Double;
        break;
    case String:
        value = QCborValue::String;
        break;
    case Array:
        value = QCborValue::Array;
        break;
    case Object:
        value = QCborValue::Map;
        break;
    case Undefined:
        break;
    }
}
 
QJsonValue::QJsonValue(bool b)
    : value(b)
{
}
 
static inline QCborValue doubleValueHelper(double v)
{
    qint64 n = 0;
    // Convert to integer if the number is an integer and changing wouldn't
    // introduce additional digit precision not present in the double.
    if (convertDoubleTo<qint64>(v, &n, false /* allow_precision_upgrade */))
        return n;
    else
        return v;
}
 
QJsonValue::QJsonValue(double v)
    : value(doubleValueHelper(v))
{
}
 
QJsonValue::QJsonValue(int v)
    : value(v)
{
}
 
QJsonValue::QJsonValue(qint64 v)
    : value(v)
{
}
 
QJsonValue::QJsonValue(const QString &s)
    : value(s)
{
}
 
QJsonValue::QJsonValue(QLatin1StringView s)
    : value(s)
{
}
 
QJsonValue::QJsonValue(const QJsonArray &a)
    : value(QCborArray::fromJsonArray(a))
{
}
 
QJsonValue::QJsonValue(QJsonArray &&a) noexcept
    : value(QCborArray::fromJsonArray(std::move(a)))
{
}
 
QJsonValue::QJsonValue(const QJsonObject &o)
    : value(QCborMap::fromJsonObject(o))
{
}
 
QJsonValue::QJsonValue(QJsonObject &&o) noexcept
    : value(QCborMap::fromJsonObject(std::move(o)))
{
}
 
 
QJsonValue::~QJsonValue() = default;
 
QJsonValue::QJsonValue(const QJsonValue &other) noexcept = default;
 
QJsonValue &QJsonValue::operator =(const QJsonValue &other) noexcept
{
    QJsonValue copy(other);
    swap(copy);
    return *this;
}
 
QJsonValue::QJsonValue(QJsonValue &&other) noexcept
    : value(std::move(other.value))
{
    other.value = QCborValue(nullptr);
}
 
void QJsonValue::swap(QJsonValue &other) noexcept
{
    value.swap(other.value);
}
 
#ifndef QT_NO_VARIANT
QJsonValue QJsonValue::fromVariant(const QVariant &variant)
{
    switch (variant.metaType().id()) {
    case QMetaType::Nullptr:
        return QJsonValue(Null);
    case QMetaType::Bool:
        return QJsonValue(variant.toBool());
    case QMetaType::Short:
    case QMetaType::UShort:
    case QMetaType::Int:
    case QMetaType::UInt:
    case QMetaType::LongLong:
        return QJsonValue(variant.toLongLong());
    case QMetaType::ULongLong:
        if (variant.toULongLong() <= static_cast<uint64_t>(std::numeric_limits<qint64>::max()))
            return QJsonValue(variant.toLongLong());
        Q_FALLTHROUGH();
    case QMetaType::Float:
    case QMetaType::Double: {
        double v = variant.toDouble();
        return qt_is_finite(v) ? QJsonValue(v) : QJsonValue();
    }
    case QMetaType::QString:
        return QJsonValue(variant.toString());
    case QMetaType::QStringList:
        return QJsonValue(QJsonArray::fromStringList(variant.toStringList()));
    case QMetaType::QVariantList:
        return QJsonValue(QJsonArray::fromVariantList(variant.toList()));
    case QMetaType::QVariantMap:
        return QJsonValue(QJsonObject::fromVariantMap(variant.toMap()));
    case QMetaType::QVariantHash:
        return QJsonValue(QJsonObject::fromVariantHash(variant.toHash()));
#ifndef QT_BOOTSTRAPPED
    case QMetaType::QUrl:
        return QJsonValue(variant.toUrl().toString(QUrl::FullyEncoded));
    case QMetaType::QUuid:
        return variant.toUuid().toString(QUuid::WithoutBraces);
    case QMetaType::QJsonValue:
        return variant.toJsonValue();
    case QMetaType::QJsonObject:
        return variant.toJsonObject();
    case QMetaType::QJsonArray:
        return variant.toJsonArray();
    case QMetaType::QJsonDocument: {
        QJsonDocument doc = variant.toJsonDocument();
        return doc.isArray() ? QJsonValue(doc.array()) : QJsonValue(doc.object());
    }
    case QMetaType::QCborValue:
        return qvariant_cast<QCborValue>(variant).toJsonValue();
    case QMetaType::QCborArray:
        return qvariant_cast<QCborArray>(variant).toJsonArray();
    case QMetaType::QCborMap:
        return qvariant_cast<QCborMap>(variant).toJsonObject();
#endif
    default:
        break;
    }
    QString string = variant.toString();
    if (string.isEmpty())
        return QJsonValue();
    return QJsonValue(string);
}
 
QVariant QJsonValue::toVariant() const
{
    switch (value.type()) {
    case QCborValue::True:
        return true;
    case QCborValue::False:
        return false;
    case QCborValue::Integer:
        return toInteger();
    case QCborValue::Double:
        return toDouble();
    case QCborValue::String:
        return toString();
    case QCborValue::Array:
        return toArray().toVariantList();
    case QCborValue::Map:
        return toObject().toVariantMap();
    case QCborValue::Null:
        return QVariant::fromValue(nullptr);
    case QCborValue::Undefined:
    default:
        break;
    }
    return QVariant();
}
 
#endif // !QT_NO_VARIANT
 
QJsonValue::Type QJsonValue::type() const
{
    return convertFromCborType(value.type());
}
 
bool QJsonValue::toBool(bool defaultValue) const
{
    switch (value.type()) {
    case QCborValue::True:
        return true;
    case QCborValue::False:
        return false;
    default:
        return defaultValue;
    }
}
 
int QJsonValue::toInt(int defaultValue) const
{
    switch (value.type()) {
    case QCborValue::Double: {
        int dblInt;
        if (convertDoubleTo<int>(toDouble(), &dblInt))
            return dblInt;
        break;
    }
    case QCborValue::Integer: {
        const auto n = value.toInteger();
        if (qint64(int(n)) == n)
            return int(n);
        break;
    }
    default:
        break;
    }
    return defaultValue;
}
 
qint64 QJsonValue::toInteger(qint64 defaultValue) const
{
    switch (value.type()) {
    case QCborValue::Integer:
        return value.toInteger();
    case QCborValue::Double: {
        qint64 dblInt;
        if (convertDoubleTo<qint64>(toDouble(), &dblInt))
            return dblInt;
        break;
    }
    default:
        break;
    }
    return defaultValue;
}
 
double QJsonValue::toDouble(double defaultValue) const
{
    return value.toDouble(defaultValue);
}
 
QString QJsonValue::toString(const QString &defaultValue) const
{
    return value.toString(defaultValue);
}
 
QString QJsonValue::toString() const
{
    return value.toString();
}
 
QJsonArray QJsonValue::toArray(const QJsonArray &defaultValue) const
{
    if (!isArray())
        return defaultValue;
    QCborContainerPrivate *dd = nullptr;
    const auto n = QJsonPrivate::Value::valueHelper(value);
    const auto container = QJsonPrivate::Value::container(value);
    Q_ASSERT(n == -1 || container == nullptr);
    if (n < 0)
        dd = container;
    return QJsonArray(dd);
}
 
QJsonArray QJsonValue::toArray() const
{
    return toArray(QJsonArray());
}
 
QJsonObject QJsonValue::toObject(const QJsonObject &defaultValue) const
{
    if (!isObject())
        return defaultValue;
    QCborContainerPrivate *dd = nullptr;
    const auto container = QJsonPrivate::Value::container(value);
    const auto n = QJsonPrivate::Value::valueHelper(value);
    Q_ASSERT(n == -1 || container == nullptr);
    if (n < 0)
        dd = container;
    return QJsonObject(dd);
}
 
QJsonObject QJsonValue::toObject() const
{
    return toObject(QJsonObject());
}
 
const QJsonValue QJsonValue::operator[](const QString &key) const
{
    return (*this)[QStringView(key)];
}
 
const QJsonValue QJsonValue::operator[](QStringView key) const
{
    if (!isObject())
        return QJsonValue(QJsonValue::Undefined);
 
    return toObject().value(key);
}
 
const QJsonValue QJsonValue::operator[](QLatin1StringView key) const
{
    if (!isObject())
        return QJsonValue(QJsonValue::Undefined);
 
    return toObject().value(key);
}
 
const QJsonValue QJsonValue::operator[](qsizetype i) const
{
    if (!isArray())
        return QJsonValue(QJsonValue::Undefined);
 
    return toArray().at(i);
}
 
bool comparesEqual(const QJsonValue &lhs, const QJsonValue &rhs) noexcept
{
    if (lhs.value.type() != rhs.value.type()) {
        if (lhs.isDouble() && rhs.isDouble()) {
            // One value Cbor integer, one Cbor double, should interact as doubles.
            return lhs.toDouble() == rhs.toDouble();
        }
        return false;
    }
 
    switch (lhs.value.type()) {
    case QCborValue::Undefined:
    case QCborValue::Null:
    case QCborValue::True:
    case QCborValue::False:
        break;
    case QCborValue::Double:
        return lhs.toDouble() == rhs.toDouble();
    case QCborValue::Integer:
        return QJsonPrivate::Value::valueHelper(lhs.value)
                == QJsonPrivate::Value::valueHelper(rhs.value);
    case QCborValue::String:
        return lhs.toString() == rhs.toString();
    case QCborValue::Array:
        return lhs.toArray() == rhs.toArray();
    case QCborValue::Map:
        return lhs.toObject() == rhs.toObject();
    default:
        return false;
    }
    return true;
}
 
void QJsonValueRef::detach()
{
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
    QCborContainerPrivate *d = QJsonPrivate::Value::container(*this);
    d = QCborContainerPrivate::detach(d, d->elements.size());
 
    if (is_object)
        o->o.reset(d);
    else
        a->a.reset(d);
#else
    d = QCborContainerPrivate::detach(d, d->elements.size());
#endif
}
 
static QJsonValueRef &assignToRef(QJsonValueRef &ref, const QCborValue &value, bool is_object)
{
    QCborContainerPrivate *d = QJsonPrivate::Value::container(ref);
    qsizetype index = QJsonPrivate::Value::indexHelper(ref);
    if (is_object && value.isUndefined()) {
        d->removeAt(index);
        d->removeAt(index - 1);
    } else {
        d->replaceAt(index, value);
    }
 
    return ref;
}
 
QJsonValueRef &QJsonValueRef::operator =(const QJsonValue &val)
{
    detach();
    return assignToRef(*this, QCborValue::fromJsonValue(val), is_object);
}
 
QJsonValueRef &QJsonValueRef::operator =(const QJsonValueRef &ref)
{
    // ### optimize more?
    const QCborContainerPrivate *d = QJsonPrivate::Value::container(ref);
    qsizetype index = QJsonPrivate::Value::indexHelper(ref);
 
    if (d == QJsonPrivate::Value::container(*this) &&
            index == QJsonPrivate::Value::indexHelper(*this))
        return *this;     // self assignment
 
    detach();
    return assignToRef(*this, d->valueAt(index), is_object);
}
 
#ifndef QT_NO_VARIANT
QVariant QJsonValueConstRef::toVariant() const
{
    return concrete(*this).toVariant();
}
#endif // !QT_NO_VARIANT
 
QJsonArray QJsonValueConstRef::toArray() const
{
    return concrete(*this).toArray();
}
 
QJsonObject QJsonValueConstRef::toObject() const
{
    return concrete(*this).toObject();
}
 
QJsonValue::Type QJsonValueConstRef::concreteType(QJsonValueConstRef self) noexcept
{
    return convertFromCborType(QJsonPrivate::Value::elementHelper(self).type);
}
 
bool QJsonValueConstRef::concreteBool(QJsonValueConstRef self, bool defaultValue) noexcept
{
    auto &e = QJsonPrivate::Value::elementHelper(self);
    if (e.type == QCborValue::False)
        return false;
    if (e.type == QCborValue::True)
        return true;
    return defaultValue;
}
 
qint64 QJsonValueConstRef::concreteInt(QJsonValueConstRef self, qint64 defaultValue, bool clamp) noexcept
{
    auto &e = QJsonPrivate::Value::elementHelper(self);
    qint64 v = defaultValue;
    if (e.type == QCborValue::Double) {
        // convertDoubleTo modifies the output even on returning false
        if (!convertDoubleTo<qint64>(e.fpvalue(), &v))
            v = defaultValue;
    } else if (e.type == QCborValue::Integer) {
        v = e.value;
    }
    if (clamp && qint64(int(v)) != v)
        return defaultValue;
    return v;
}
 
double QJsonValueConstRef::concreteDouble(QJsonValueConstRef self, double defaultValue) noexcept
{
    auto &e = QJsonPrivate::Value::elementHelper(self);
    if (e.type == QCborValue::Double)
        return e.fpvalue();
    if (e.type == QCborValue::Integer)
        return e.value;
    return defaultValue;
}
 
QString QJsonValueConstRef::concreteString(QJsonValueConstRef self, const QString &defaultValue)
{
    const QCborContainerPrivate *d = QJsonPrivate::Value::container(self);
    qsizetype index = QJsonPrivate::Value::indexHelper(self);
    if (d->elements.at(index).type != QCborValue::String)
        return defaultValue;
    return d->stringAt(index);
}
 
QJsonValue QJsonValueConstRef::concrete(QJsonValueConstRef self) noexcept
{
    const QCborContainerPrivate *d = QJsonPrivate::Value::container(self);
    qsizetype index = QJsonPrivate::Value::indexHelper(self);
    return QJsonPrivate::Value::fromTrustedCbor(d->valueAt(index));
}
 
QString QJsonValueConstRef::objectKey(QJsonValueConstRef self)
{
    Q_ASSERT(self.is_object);
    Q_ASSERT(self.is_object);
    const QCborContainerPrivate *d = QJsonPrivate::Value::container(self);
    qsizetype index = QJsonPrivate::Value::indexHelper(self);
 
    Q_ASSERT(d);
    Q_ASSERT(index < d->elements.size());
    return d->stringAt(index - 1);
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
QVariant QJsonValueRef::toVariant() const
{
    return QJsonValueConstRef::toVariant();
}
 
QJsonArray QJsonValueRef::toArray() const
{
    return QJsonValueConstRef::toArray();
}
 
QJsonObject QJsonValueRef::toObject() const
{
    return QJsonValueConstRef::toObject();
}
 
QJsonValue QJsonValueRef::toValue() const
{
    return concrete(*this);
}
#else
QJsonValueRef QJsonValueRef::operator[](qsizetype key)
{
    if (d->elements.at(index).type != QCborValue::Array)
        d->replaceAt(index, QCborValue::Array);
 
    auto &e = d->elements[index];
    e.container = QCborContainerPrivate::grow(e.container, key);    // detaches
    e.flags |= QtCbor::Element::IsContainer;
 
    return QJsonValueRef(e.container, key, false);
}
 
QJsonValueRef QJsonValueRef::operator[](QAnyStringView key)
{
    // must go through QJsonObject because some of the machinery is non-static
    // member or file-static in qjsonobject.cpp
    QJsonObject o = QJsonPrivate::Value::fromTrustedCbor(d->valueAt(index)).toObject();
    QJsonValueRef ret = key.visit([&](auto v) {
        if constexpr (std::is_same_v<decltype(v), QUtf8StringView>)
            return o[QString::fromUtf8(v)];
        else
            return o[v];
    });
 
    // ### did the QJsonObject::operator[] above detach?
    QCborContainerPrivate *x = o.o.take();
    Q_ASSERT(x->ref.loadRelaxed() == 1);
 
    auto &e = d->elements[index];
    if (e.flags & QtCbor::Element::IsContainer && e.container != x)
        o.o.reset(e.container);     // might not an object!
 
    e.flags |= QtCbor::Element::IsContainer;
    e.container = x;
 
    return ret;
}
#endif
 
size_t qHash(const QJsonValue &value, size_t seed)
{
    switch (value.type()) {
    case QJsonValue::Null:
        return qHash(nullptr, seed);
    case QJsonValue::Bool:
        return qHash(value.toBool(), seed);
    case QJsonValue::Double:
        return qHash(value.toDouble(), seed);
    case QJsonValue::String:
        return qHash(value.toString(), seed);
    case QJsonValue::Array:
        return qHash(value.toArray(), seed);
    case QJsonValue::Object:
        return qHash(value.toObject(), seed);
    case QJsonValue::Undefined:
        return seed;
    }
    Q_UNREACHABLE_RETURN(0);
}
 
#if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_JSON_READONLY)
QDebug operator<<(QDebug dbg, const QJsonValue &o)
{
    QDebugStateSaver saver(dbg);
    switch (o.value.type()) {
    case QCborValue::Undefined:
        dbg << "QJsonValue(undefined)";
        break;
    case QCborValue::Null:
        dbg << "QJsonValue(null)";
        break;
    case QCborValue::True:
    case QCborValue::False:
        dbg.nospace() << "QJsonValue(bool, " << o.toBool() << ')';
        break;
    case QCborValue::Integer:
        dbg.nospace() << "QJsonValue(double, " << o.toInteger() << ')';
        break;
    case QCborValue::Double:
        dbg.nospace() << "QJsonValue(double, " << o.toDouble() << ')';
        break;
    case QCborValue::String:
        dbg.nospace() << "QJsonValue(string, " << o.toString() << ')';
        break;
    case QCborValue::Array:
        dbg.nospace() << "QJsonValue(array, ";
        dbg << o.toArray();
        dbg << ')';
        break;
    case QCborValue::Map:
        dbg.nospace() << "QJsonValue(object, ";
        dbg << o.toObject();
        dbg << ')';
        break;
    default:
        Q_UNREACHABLE();
    }
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QJsonValue &v)
{
    quint8 type = v.type();
    stream << type;
    switch (type) {
    case QJsonValue::Undefined:
    case QJsonValue::Null:
        break;
    case QJsonValue::Bool:
        stream << v.toBool();
        break;
    case QJsonValue::Double:
        stream << v.toDouble();
        break;
    case QJsonValue::String:
        stream << v.toString();
        break;
    case QJsonValue::Array:
        stream << v.toArray();
        break;
    case QJsonValue::Object:
        stream << v.toObject();
        break;
    }
    return stream;
}
 
QDataStream &operator>>(QDataStream &stream, QJsonValue &v)
{
    quint8 type;
    stream >> type;
    switch (type) {
    case QJsonValue::Undefined:
    case QJsonValue::Null:
        v = QJsonValue{QJsonValue::Type(type)};
        break;
    case QJsonValue::Bool: {
        bool b;
        stream >> b;
        v = QJsonValue(b);
        break;
    } case QJsonValue::Double: {
        double d;
        stream >> d;
        v = QJsonValue{d};
        break;
    } case QJsonValue::String: {
        QString s;
        stream >> s;
        v = QJsonValue{s};
        break;
    }
    case QJsonValue::Array: {
        QJsonArray a;
        stream >> a;
        v = QJsonValue{a};
        break;
    }
    case QJsonValue::Object: {
        QJsonObject o;
        stream >> o;
        v = QJsonValue{o};
        break;
    }
    default: {
        stream.setStatus(QDataStream::ReadCorruptData);
        v = QJsonValue{QJsonValue::Undefined};
    }
    }
    return stream;
}
#endif
 
QT_END_NAMESPACE