qjsoncbor.cpp

Go to the documentation of this file.

// Copyright (C) 2020 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcborvalue.h"
#include "qcborvalue_p.h"
 
#include "qcborarray.h"
#include "qcbormap.h"
 
#include "qjsonarray.h"
#include "qjsonobject.h"
#include "qjsondocument.h"
#include "qjson_p.h"
 
#include <qmap.h>
#include <qhash.h>
 
#include <private/qnumeric_p.h>
#include <quuid.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QtCbor;
 
enum class ConversionMode { FromRaw, FromVariantToJson };
 
static QJsonValue fpToJson(double v)
{
    return qt_is_finite(v) ? QJsonValue(v) : QJsonValue();
}
 
static QString simpleTypeString(QCborValue::Type t)
{
    int simpleType = t - QCborValue::SimpleType;
    if (unsigned(simpleType) < 0x100)
        return QString::fromLatin1("simple(%1)").arg(simpleType);
 
    // if we got here, we got an unknown type
    qWarning("QCborValue: found unknown type 0x%x", t);
    return QString();
 
}
 
static QString encodeByteArray(const QCborContainerPrivate *d, qsizetype idx, QCborTag encoding)
{
    const ByteData *b = d->byteData(idx);
    if (!b)
        return QString();
 
    QByteArray data = QByteArray::fromRawData(b->byte(), b->len);
    if (encoding == QCborKnownTags::ExpectedBase16)
        data = data.toHex();
    else if (encoding == QCborKnownTags::ExpectedBase64)
        data = data.toBase64();
    else
        data = data.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
 
    return QString::fromLatin1(data, data.size());
}
 
static QString makeString(const QCborContainerPrivate *d, qsizetype idx,
                          ConversionMode mode = ConversionMode::FromRaw);
 
static QString maybeEncodeTag(const QCborContainerPrivate *d)
{
    qint64 tag = d->elements.at(0).value;
    const Element &e = d->elements.at(1);
 
    switch (tag) {
    case qint64(QCborKnownTags::DateTimeString):
    case qint64(QCborKnownTags::Url):
        if (e.type == QCborValue::String)
            return makeString(d, 1);
        break;
 
    case qint64(QCborKnownTags::ExpectedBase64url):
    case qint64(QCborKnownTags::ExpectedBase64):
    case qint64(QCborKnownTags::ExpectedBase16):
        if (e.type == QCborValue::ByteArray)
            return encodeByteArray(d, 1, QCborTag(tag));
        break;
 
    case qint64(QCborKnownTags::Uuid):
#ifndef QT_BOOTSTRAPPED
        if (const ByteData *b = d->byteData(e); e.type == QCborValue::ByteArray && b
                && b->len == sizeof(QUuid))
            return QUuid::fromRfc4122(b->asByteArrayView()).toString(QUuid::WithoutBraces);
#endif
        break;
    }
 
    // don't know what to do, bail out
    return QString();
}
 
static QString encodeTag(const QCborContainerPrivate *d)
{
    QString s;
    if (!d || d->elements.size() != 2)
        return s;               // invalid (incomplete?) tag state
 
    s = maybeEncodeTag(d);
    if (s.isNull()) {
        // conversion failed, ignore the tag and convert the tagged value
        s = makeString(d, 1);
    }
    return s;
}
 
static Q_NEVER_INLINE QString makeString(const QCborContainerPrivate *d, qsizetype idx,
                                         ConversionMode mode)
{
    const auto &e = d->elements.at(idx);
 
    switch (e.type) {
    case QCborValue::Integer:
        return QString::number(qint64(e.value));
 
    case QCborValue::Double:
        return QString::number(e.fpvalue());
 
    case QCborValue::ByteArray:
        return mode == ConversionMode::FromVariantToJson
                ? d->stringAt(idx)
                : encodeByteArray(d, idx, QCborTag(QCborKnownTags::ExpectedBase64url));
 
    case QCborValue::String:
        return d->stringAt(idx);
 
    case QCborValue::Array:
    case QCborValue::Map:
#if defined(QT_JSON_READONLY) || defined(QT_BOOTSTRAPPED)
        qFatal("Writing JSON is disabled.");
        return QString();
#else
        return d->valueAt(idx).toDiagnosticNotation(QCborValue::Compact);
#endif
 
    case QCborValue::SimpleType:
        break;
 
    case QCborValue::False:
        return QStringLiteral("false");
 
    case QCborValue::True:
        return QStringLiteral("true");
 
    case QCborValue::Null:
        return QStringLiteral("null");
 
    case QCborValue::Undefined:
        return QStringLiteral("undefined");
 
    case QCborValue::Invalid:
        return QString();
 
    case QCborValue::Tag:
    case QCborValue::DateTime:
    case QCborValue::Url:
    case QCborValue::RegularExpression:
    case QCborValue::Uuid:
        return encodeTag(e.flags & Element::IsContainer ? e.container : nullptr);
    }
 
    // maybe it's a simple type
    return simpleTypeString(e.type);
}
 
QJsonValue qt_convertToJson(QCborContainerPrivate *d, qsizetype idx,
                            ConversionMode mode = ConversionMode::FromRaw);
 
static QJsonValue convertExtendedTypeToJson(QCborContainerPrivate *d)
{
    qint64 tag = d->elements.at(0).value;
 
    switch (tag) {
    case qint64(QCborKnownTags::Url):
#ifdef QT_BOOTSTRAPPED
        break;
#else
        // use the fully-encoded URL form
        if (d->elements.at(1).type == QCborValue::String)
            return QUrl::fromEncoded(d->byteData(1)->asByteArrayView()).toString(QUrl::FullyEncoded);
        Q_FALLTHROUGH();
#endif
 
    case qint64(QCborKnownTags::DateTimeString):
    case qint64(QCborKnownTags::ExpectedBase64url):
    case qint64(QCborKnownTags::ExpectedBase64):
    case qint64(QCborKnownTags::ExpectedBase16):
    case qint64(QCborKnownTags::Uuid): {
        // use the string conversion
        QString s = maybeEncodeTag(d);
        if (!s.isNull())
            return s;
    }
    }
 
    // for all other tags, ignore it and return the converted tagged item
    return qt_convertToJson(d, 1);
}
 
// We need to do this because sub-objects may need conversion.
static QJsonArray convertToJsonArray(QCborContainerPrivate *d,
                                     ConversionMode mode = ConversionMode::FromRaw)
{
    QJsonArray a;
    if (d) {
        for (qsizetype idx = 0; idx < d->elements.size(); ++idx)
            a.append(qt_convertToJson(d, idx, mode));
    }
    return a;
}
 
// We need to do this because the keys need to be sorted and converted to strings
// and sub-objects may need recursive conversion.
static QJsonObject convertToJsonObject(QCborContainerPrivate *d,
                                       ConversionMode mode = ConversionMode::FromRaw)
{
    QJsonObject o;
    if (d) {
        for (qsizetype idx = 0; idx < d->elements.size(); idx += 2)
            o.insert(makeString(d, idx), qt_convertToJson(d, idx + 1, mode));
    }
    return o;
}
 
QJsonValue qt_convertToJson(QCborContainerPrivate *d, qsizetype idx, ConversionMode mode)
{
    // encoding the container itself
    if (idx == -QCborValue::Array)
        return convertToJsonArray(d, mode);
    if (idx == -QCborValue::Map)
        return convertToJsonObject(d, mode);
    if (idx < 0) {
        // tag-like type
        if (!d || d->elements.size() != 2)
            return QJsonValue::Undefined;   // invalid state
        return convertExtendedTypeToJson(d);
    }
 
    // an element in the container
    const auto &e = d->elements.at(idx);
    switch (e.type) {
    case QCborValue::Integer:
        return QJsonValue(e.value);
    case QCborValue::ByteArray:
        if (mode == ConversionMode::FromVariantToJson) {
            const auto value = makeString(d, idx, mode);
            return value.isEmpty() ? QJsonValue() : QJsonPrivate::Value::fromTrustedCbor(value);
        }
        break;
    case QCborValue::RegularExpression:
        if (mode == ConversionMode::FromVariantToJson)
            return QJsonValue();
        break;
    case QCborValue::String:
    case QCborValue::SimpleType:
        // make string
        break;
 
    case QCborValue::Array:
    case QCborValue::Map:
    case QCborValue::Tag:
    case QCborValue::DateTime:
    case QCborValue::Url:
    case QCborValue::Uuid:
        // recurse
        return qt_convertToJson(e.flags & Element::IsContainer ? e.container : nullptr, -e.type,
                                mode);
 
    case QCborValue::Null:
    case QCborValue::Undefined:
    case QCborValue::Invalid:
        return QJsonValue();
 
    case QCborValue::False:
        return false;
 
    case QCborValue::True:
        return true;
 
    case QCborValue::Double:
        return fpToJson(e.fpvalue());
    }
 
    return QJsonPrivate::Value::fromTrustedCbor(makeString(d, idx, mode));
}
 
QJsonValue QCborValue::toJsonValue() const
{
    if (container)
        return qt_convertToJson(container, n < 0 ? -type() : n);
 
    // simple values
    switch (type()) {
    case False:
        return false;
 
    case Integer:
        return QJsonPrivate::Value::fromTrustedCbor(*this);
 
    case True:
        return true;
 
    case Null:
    case Undefined:
    case Invalid:
        return QJsonValue();
 
    case Double:
        return fpToJson(fp_helper());
 
    case SimpleType:
        break;
 
    case ByteArray:
    case String:
        // empty strings
        return QJsonValue::String;
 
    case Array:
        // empty array
        return QJsonArray();
 
    case Map:
        // empty map
        return QJsonObject();
 
    case Tag:
    case DateTime:
    case Url:
    case RegularExpression:
    case Uuid:
        // Reachable, but invalid in Json
        return QJsonValue::Undefined;
    }
 
    return QJsonPrivate::Value::fromTrustedCbor(simpleTypeString(type()));
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
QJsonValue QCborValueRef::toJsonValue() const
{
    return qt_convertToJson(d, i);
}
#endif
 
QJsonArray QCborArray::toJsonArray() const
{
    return convertToJsonArray(d.data());
}
 
QJsonArray QJsonPrivate::Variant::toJsonArray(const QVariantList &list)
{
    const auto cborArray = QCborArray::fromVariantList(list);
    return convertToJsonArray(cborArray.d.data(), ConversionMode::FromVariantToJson);
}
 
QJsonObject QCborMap::toJsonObject() const
{
    return convertToJsonObject(d.data());
}
 
QJsonObject QJsonPrivate::Variant::toJsonObject(const QVariantMap &map)
{
    const auto cborMap = QCborMap::fromVariantMap(map);
    return convertToJsonObject(cborMap.d.data(), ConversionMode::FromVariantToJson);
}
 
QVariant QCborValue::toVariant() const
{
    switch (type()) {
    case Integer:
        return toInteger();
 
    case Double:
        return toDouble();
 
    case SimpleType:
        break;
 
    case False:
    case True:
        return isTrue();
 
    case Null:
        return QVariant::fromValue(nullptr);
 
    case Undefined:
        return QVariant();
 
    case ByteArray:
        return toByteArray();
 
    case String:
        return toString();
 
    case Array:
        return toArray().toVariantList();
 
    case Map:
        return toMap().toVariantMap();
 
    case Tag:
        // ignore tags
        return taggedValue().toVariant();
 
    case DateTime:
        return toDateTime();
 
#ifndef QT_BOOTSTRAPPED
    case Url:
        return toUrl();
 
#  if QT_CONFIG(regularexpression)
    case RegularExpression:
        return toRegularExpression();
#  endif
 
    case Uuid:
        return toUuid();
#endif
 
    case Invalid:
        return QVariant();
 
    default:
        break;
    }
 
    if (isSimpleType())
        return QVariant::fromValue(toSimpleType());
 
    Q_UNREACHABLE_RETURN(QVariant());
}
 
QCborValue QCborValue::fromJsonValue(const QJsonValue &v)
{
    switch (v.type()) {
    case QJsonValue::Bool:
        return v.toBool();
    case QJsonValue::Double: {
        if (v.value.t == Integer)
            return v.toInteger();
        return v.toDouble();
    }
    case QJsonValue::String:
        return v.toString();
    case QJsonValue::Array:
        return QCborArray::fromJsonArray(v.toArray());
    case QJsonValue::Object:
        return QCborMap::fromJsonObject(v.toObject());
    case QJsonValue::Null:
        return nullptr;
    case QJsonValue::Undefined:
        break;
    }
    return QCborValue();
}
 
static void appendVariant(QCborContainerPrivate *d, const QVariant &variant)
{
    // Handle strings and byte arrays directly, to avoid creating a temporary
    // dummy container to hold their data.
    int type = variant.metaType().id();
    if (type == QMetaType::QString) {
        d->append(variant.toString());
    } else if (type == QMetaType::QByteArray) {
        QByteArray ba = variant.toByteArray();
        d->appendByteData(ba.constData(), ba.size(), QCborValue::ByteArray);
    } else {
        // For everything else, use the function below.
        d->append(QCborValue::fromVariant(variant));
    }
}
 
QCborValue QCborValue::fromVariant(const QVariant &variant)
{
    switch (variant.metaType().id()) {
    case QMetaType::UnknownType:
        return {};
    case QMetaType::Nullptr:
        return nullptr;
    case QMetaType::Bool:
        return variant.toBool();
    case QMetaType::Short:
    case QMetaType::UShort:
    case QMetaType::Int:
    case QMetaType::LongLong:
    case QMetaType::UInt:
        return variant.toLongLong();
    case QMetaType::ULongLong:
        if (variant.toULongLong() <= static_cast<uint64_t>(std::numeric_limits<qint64>::max()))
            return variant.toLongLong();
        Q_FALLTHROUGH();
    case QMetaType::Float:
    case QMetaType::Double:
        return variant.toDouble();
    case QMetaType::QString:
        return variant.toString();
    case QMetaType::QStringList:
        return QCborArray::fromStringList(variant.toStringList());
    case QMetaType::QByteArray:
        return variant.toByteArray();
    case QMetaType::QDateTime:
        return QCborValue(variant.toDateTime());
#ifndef QT_BOOTSTRAPPED
    case QMetaType::QUrl:
        return QCborValue(variant.toUrl());
    case QMetaType::QUuid:
        return QCborValue(variant.toUuid());
#endif
    case QMetaType::QVariantList:
        return QCborArray::fromVariantList(variant.toList());
    case QMetaType::QVariantMap:
        return QCborMap::fromVariantMap(variant.toMap());
    case QMetaType::QVariantHash:
        return QCborMap::fromVariantHash(variant.toHash());
#ifndef QT_BOOTSTRAPPED
#if QT_CONFIG(regularexpression)
    case QMetaType::QRegularExpression:
        return QCborValue(variant.toRegularExpression());
#endif
    case QMetaType::QJsonValue:
        return fromJsonValue(variant.toJsonValue());
    case QMetaType::QJsonObject:
        return QCborMap::fromJsonObject(variant.toJsonObject());
    case QMetaType::QJsonArray:
        return QCborArray::fromJsonArray(variant.toJsonArray());
    case QMetaType::QJsonDocument: {
        QJsonDocument doc = variant.toJsonDocument();
        if (doc.isArray())
            return QCborArray::fromJsonArray(doc.array());
        return QCborMap::fromJsonObject(doc.object());
    }
    case QMetaType::QCborValue:
        return qvariant_cast<QCborValue>(variant);
    case QMetaType::QCborArray:
        return qvariant_cast<QCborArray>(variant);
    case QMetaType::QCborMap:
        return qvariant_cast<QCborMap>(variant);
    case QMetaType::QCborSimpleType:
        return qvariant_cast<QCborSimpleType>(variant);
#endif
    default:
        break;
    }
 
    if (variant.isNull())
        return QCborValue(nullptr);
 
    QString string = variant.toString();
    if (string.isNull())
        return QCborValue();        // undefined
    return string;
}
 
QVariantList QCborArray::toVariantList() const
{
    QVariantList retval;
    retval.reserve(size());
    for (qsizetype i = 0; i < size(); ++i)
        retval.append(d->valueAt(i).toVariant());
    return retval;
}
 
QCborArray QCborArray::fromStringList(const QStringList &list)
{
    QCborArray a;
    a.detach(list.size());
    for (const QString &s : list)
        a.d->append(s);
    return a;
}
 
QCborArray QCborArray::fromVariantList(const QVariantList &list)
{
    QCborArray a;
    a.detach(list.size());
    for (const QVariant &v : list)
        appendVariant(a.d.data(), v);
    return a;
}
 
QCborArray QCborArray::fromJsonArray(const QJsonArray &array)
{
    QCborArray result;
    result.d = array.a;
    return result;
}
 
QCborArray QCborArray::fromJsonArray(QJsonArray &&array) noexcept
{
    QCborArray result;
    result.d = std::exchange(array.a, {});
    return result;
 
}
 
QVariantMap QCborMap::toVariantMap() const
{
    QVariantMap retval;
    for (qsizetype i = 0; i < 2 * size(); i += 2)
        retval.insert(makeString(d.data(), i), d->valueAt(i + 1).toVariant());
    return retval;
}
 
QVariantHash QCborMap::toVariantHash() const
{
    QVariantHash retval;
    retval.reserve(size());
    for (qsizetype i = 0; i < 2 * size(); i += 2)
        retval.insert(makeString(d.data(), i), d->valueAt(i + 1).toVariant());
    return retval;
}
 
QCborMap QCborMap::fromVariantMap(const QVariantMap &map)
{
    QCborMap m;
    m.detach(map.size());
    QCborContainerPrivate *d = m.d.data();
 
    auto it = map.begin();
    auto end = map.end();
    for ( ; it != end; ++it) {
        d->append(it.key());
        appendVariant(d, it.value());
    }
    return m;
}
 
QCborMap QCborMap::fromVariantHash(const QVariantHash &hash)
{
    QCborMap m;
    m.detach(hash.size());
    QCborContainerPrivate *d = m.d.data();
 
    auto it = hash.begin();
    auto end = hash.end();
    for ( ; it != end; ++it) {
        d->append(it.key());
        appendVariant(d, it.value());
    }
    return m;
}
 
QCborMap QCborMap::fromJsonObject(const QJsonObject &obj)
{
    QCborMap result;
    result.d = obj.o;
    return result;
}
 
QCborMap QCborMap::fromJsonObject(QJsonObject &&obj) noexcept
{
    QCborMap result;
    result.d = std::exchange(obj.o, {});
    return result;
}
 
QT_END_NAMESPACE