qjsondocument.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 <qjsondocument.h>
#include <qjsonobject.h>
#include <qjsonvalue.h>
#include <qjsonarray.h>
#include <qstringlist.h>
#include <qvariant.h>
#include <qmap.h>
#include <qhash.h>
#include <qdebug.h>
#include <qcbormap.h>
#include <qcborarray.h>
#include "qcborvalue_p.h"
#include "qjsonwriter_p.h"
#include "qjsonparser_p.h"
#include "qjson_p.h"
#include "qdatastream.h"
 
QT_BEGIN_NAMESPACE
 
class QJsonDocumentPrivate
{
    Q_DISABLE_COPY_MOVE(QJsonDocumentPrivate);
public:
    QJsonDocumentPrivate() = default;
    QJsonDocumentPrivate(QCborValue data) : value(std::move(data)) {}
    ~QJsonDocumentPrivate()
    {
        if (rawData)
            free(rawData);
    }
 
    QCborValue value;
    char *rawData = nullptr;
    uint rawDataSize = 0;
 
    void clearRawData()
    {
        if (rawData) {
            free(rawData);
            rawData = nullptr;
            rawDataSize = 0;
        }
    }
};
 
QJsonDocument::QJsonDocument()
    : d(nullptr)
{
}
 
QJsonDocument::QJsonDocument(const QJsonObject &object)
    : d(nullptr)
{
    setObject(object);
}
 
QJsonDocument::QJsonDocument(const QJsonArray &array)
    : d(nullptr)
{
    setArray(array);
}
 
QJsonDocument::QJsonDocument(const QCborValue &data)
    : d(std::make_unique<QJsonDocumentPrivate>(data))
{
    Q_ASSERT(d);
}
 
QJsonDocument::~QJsonDocument() = default;
 
QJsonDocument::QJsonDocument(const QJsonDocument &other)
{
    if (other.d) {
        if (!d)
            d = std::make_unique<QJsonDocumentPrivate>();
        d->value = other.d->value;
    } else {
        d.reset();
    }
}
 
QJsonDocument::QJsonDocument(QJsonDocument &&other) noexcept
    : d(std::move(other.d))
{
}
 
void QJsonDocument::swap(QJsonDocument &other) noexcept
{
    qSwap(d, other.d);
}
 
QJsonDocument &QJsonDocument::operator =(const QJsonDocument &other)
{
    if (this != &other) {
        if (other.d) {
            if (!d)
                d = std::make_unique<QJsonDocumentPrivate>();
            else
                d->clearRawData();
            d->value = other.d->value;
        } else {
            d.reset();
        }
    }
    return *this;
}
 
#ifndef QT_NO_VARIANT
QJsonDocument QJsonDocument::fromVariant(const QVariant &variant)
{
    QJsonDocument doc;
 
    switch (variant.metaType().id()) {
    case QMetaType::QVariantMap:
        doc.setObject(QJsonObject::fromVariantMap(variant.toMap()));
        break;
    case QMetaType::QVariantHash:
        doc.setObject(QJsonObject::fromVariantHash(variant.toHash()));
        break;
    case QMetaType::QVariantList:
        doc.setArray(QJsonArray::fromVariantList(variant.toList()));
        break;
    case QMetaType::QStringList:
        doc.d = std::make_unique<QJsonDocumentPrivate>();
        doc.d->value = QCborArray::fromStringList(variant.toStringList());
        break;
    default:
        break;
    }
    return doc;
}
 
QVariant QJsonDocument::toVariant() const
{
    if (!d)
        return QVariant();
 
    QCborContainerPrivate *container = QJsonPrivate::Value::container(d->value);
    if (d->value.isArray())
        return QJsonArray(container).toVariantList();
    return QJsonObject(container).toVariantMap();
}
#endif // !QT_NO_VARIANT
 
#if !defined(QT_JSON_READONLY) || defined(Q_QDOC)
QByteArray QJsonDocument::toJson(JsonFormat format) const
{
    QByteArray json;
    if (!d)
        return json;
 
    const QCborContainerPrivate *container = QJsonPrivate::Value::container(d->value);
    if (d->value.isArray())
        QJsonPrivate::Writer::arrayToJson(container, json, 0, (format == Compact));
    else
        QJsonPrivate::Writer::objectToJson(container, json, 0, (format == Compact));
 
    return json;
}
#endif
 
QJsonDocument QJsonDocument::fromJson(const QByteArray &json, QJsonParseError *error)
{
    QJsonPrivate::Parser parser(json.constData(), json.size());
    QJsonDocument result;
    const QCborValue val = parser.parse(error);
    if (val.isArray() || val.isMap()) {
        result.d = std::make_unique<QJsonDocumentPrivate>();
        result.d->value = val;
    }
    return result;
}
 
bool QJsonDocument::isEmpty() const
{
    if (!d)
        return true;
 
    return false;
}
 
bool QJsonDocument::isArray() const
{
    if (!d)
        return false;
 
    return d->value.isArray();
}
 
bool QJsonDocument::isObject() const
{
    if (!d)
        return false;
 
    return d->value.isMap();
}
 
QJsonObject QJsonDocument::object() const
{
    if (isObject()) {
        if (auto container = QJsonPrivate::Value::container(d->value))
            return QJsonObject(container);
    }
    return QJsonObject();
}
 
QJsonArray QJsonDocument::array() const
{
    if (isArray()) {
        if (auto container = QJsonPrivate::Value::container(d->value))
            return QJsonArray(container);
    }
    return QJsonArray();
}
 
void QJsonDocument::setObject(const QJsonObject &object)
{
    if (!d)
        d = std::make_unique<QJsonDocumentPrivate>();
    else
        d->clearRawData();
 
    d->value = QCborValue::fromJsonValue(object);
}
 
void QJsonDocument::setArray(const QJsonArray &array)
{
    if (!d)
        d = std::make_unique<QJsonDocumentPrivate>();
    else
        d->clearRawData();
 
    d->value = QCborValue::fromJsonValue(array);
}
 
const QJsonValue QJsonDocument::operator[](const QString &key) const
{
    return (*this)[QStringView(key)];
}
 
const QJsonValue QJsonDocument::operator[](QStringView key) const
{
    if (!isObject())
        return QJsonValue(QJsonValue::Undefined);
 
    return QJsonPrivate::Value::fromTrustedCbor(d->value.toMap().value(key));
}
 
const QJsonValue QJsonDocument::operator[](QLatin1StringView key) const
{
    if (!isObject())
        return QJsonValue(QJsonValue::Undefined);
 
    return QJsonPrivate::Value::fromTrustedCbor(d->value.toMap().value(key));
}
 
const QJsonValue QJsonDocument::operator[](qsizetype i) const
{
    if (!isArray())
        return QJsonValue(QJsonValue::Undefined);
 
    return QJsonPrivate::Value::fromTrustedCbor(d->value.toArray().at(i));
}
 
bool comparesEqual(const QJsonDocument &lhs, const QJsonDocument &rhs) noexcept
{
    if (lhs.d && rhs.d)
        return lhs.d->value == rhs.d->value;
    return !lhs.d == !rhs.d;
}
 
bool QJsonDocument::isNull() const
{
    return (d == nullptr);
}
 
#if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_JSON_READONLY)
QDebug operator<<(QDebug dbg, const QJsonDocument &o)
{
    QDebugStateSaver saver(dbg);
    if (!o.d) {
        dbg << "QJsonDocument()";
        return dbg;
    }
    QByteArray json;
    const QCborContainerPrivate *container = QJsonPrivate::Value::container(o.d->value);
    if (o.d->value.isArray())
        QJsonPrivate::Writer::arrayToJson(container, json, 0, true);
    else
        QJsonPrivate::Writer::objectToJson(container, json, 0, true);
    dbg.nospace() << "QJsonDocument("
                  << json.constData() // print as utf-8 string without extra quotation marks
                  << ')';
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QJsonDocument &doc)
{
    stream << doc.toJson(QJsonDocument::Compact);
    return stream;
}
 
QDataStream &operator>>(QDataStream &stream, QJsonDocument &doc)
{
    QByteArray buffer;
    stream >> buffer;
    QJsonParseError parseError{};
    doc = QJsonDocument::fromJson(buffer, &parseError);
    if (parseError.error && !buffer.isEmpty())
        stream.setStatus(QDataStream::ReadCorruptData);
    return stream;
}
#endif
 
QT_END_NAMESPACE