qjsonobject.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 <qjsonobject.h>
#include <qjsonvalue.h>
#include <qjsonarray.h>
#include <qjsondocument.h>
#include <qstringlist.h>
#include <qdebug.h>
#include <qvariant.h>
#include <qcbormap.h>
#include <qmap.h>
#include <qhash.h>
 
#include <private/qcborvalue_p.h>
#include "qjsonwriter_p.h"
#include "qjson_p.h"
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
QJsonObject::QJsonObject() = default;
 
QJsonObject::QJsonObject(QCborContainerPrivate *object)
    : o(object)
{
}
 
QJsonObject::~QJsonObject() = default;
 
QJsonObject::QJsonObject(std::initializer_list<std::pair<QString, QJsonValue> > args)
{
    for (const auto &arg : args)
        insert(arg.first, arg.second);
}
 
QJsonObject::QJsonObject(const QJsonObject &other) noexcept = default;
 
QJsonObject::QJsonObject(QJsonObject &&other) noexcept
    : o(other.o)
{
    other.o = nullptr;
}
 
QJsonObject &QJsonObject::operator =(const QJsonObject &other) noexcept = default;
 
 
#ifndef QT_NO_VARIANT
QJsonObject QJsonObject::fromVariantMap(const QVariantMap &map)
{
    return QJsonPrivate::Variant::toJsonObject(map);
}
 
QVariantMap QJsonObject::toVariantMap() const
{
    return QCborMap::fromJsonObject(*this).toVariantMap();
}
 
QJsonObject QJsonObject::fromVariantHash(const QVariantHash &hash)
{
    // ### this is implemented the trivial way, not the most efficient way
 
    QJsonObject object;
    for (QVariantHash::const_iterator it = hash.constBegin(); it != hash.constEnd(); ++it)
        object.insert(it.key(), QJsonValue::fromVariant(it.value()));
    return object;
}
 
QVariantHash QJsonObject::toVariantHash() const
{
    return QCborMap::fromJsonObject(*this).toVariantHash();
}
#endif // !QT_NO_VARIANT
 
QStringList QJsonObject::keys() const
{
    QStringList keys;
    if (o) {
        keys.reserve(o->elements.size() / 2);
        for (qsizetype i = 0, end = o->elements.size(); i < end; i += 2)
            keys.append(o->stringAt(i));
    }
    return keys;
}
 
qsizetype QJsonObject::size() const
{
    return o ? o->elements.size() / 2 : 0;
}
 
bool QJsonObject::isEmpty() const
{
    return !o || o->elements.isEmpty();
}
 
template<typename String>
static qsizetype indexOf(const QExplicitlySharedDataPointer<QCborContainerPrivate> &o,
                         String key, bool *keyExists)
{
    const auto begin = QJsonPrivate::ConstKeyIterator(o->elements.constBegin());
    const auto end = QJsonPrivate::ConstKeyIterator(o->elements.constEnd());
 
    const auto it = std::lower_bound(
                begin, end, key,
                [&](const QJsonPrivate::ConstKeyIterator::value_type &e, const String &key) {
        return o->stringCompareElement(e.key(), key, QtCbor::Comparison::ForOrdering) < 0;
    });
 
    *keyExists = (it != end) && o->stringEqualsElement((*it).key(), key);
    return it.it - begin.it;
}
 
QJsonValue QJsonObject::value(const QString &key) const
{
    return value(QStringView(key));
}
 
QJsonValue QJsonObject::value(QStringView key) const
{
    return valueImpl(key);
}
 
QJsonValue QJsonObject::value(QLatin1StringView key) const
{
    return valueImpl(key);
}
 
template <typename T>
QJsonValue QJsonObject::valueImpl(T key) const
{
    if (!o)
        return QJsonValue(QJsonValue::Undefined);
 
    bool keyExists;
    auto i = indexOf(o, key, &keyExists);
    if (!keyExists)
        return QJsonValue(QJsonValue::Undefined);
    return QJsonPrivate::Value::fromTrustedCbor(o->valueAt(i + 1));
}
 
QJsonValue QJsonObject::operator [](const QString &key) const
{
    return (*this)[QStringView(key)];
}
 
QJsonValueRef QJsonObject::operator [](const QString &key)
{
    return (*this)[QStringView(key)];
}
 
QJsonValueRef QJsonObject::operator [](QStringView key)
{
    return atImpl(key);
}
 
QJsonValueRef QJsonObject::operator [](QLatin1StringView key)
{
    return atImpl(key);
}
 
template <typename T>
QJsonValueRef QJsonObject::atImpl(T key)
{
    if (!o)
        o = new QCborContainerPrivate;
 
    bool keyExists = false;
    auto index = indexOf(o, key, &keyExists);
    if (!keyExists) {
        detach(o->elements.size() / 2 + 1);
        o->insertAt(index, key);
        o->insertAt(index + 1, QCborValue::fromJsonValue(QJsonValue()));
    }
    // detaching will happen if and when this QJsonValueRef is assigned to
    return QJsonValueRef(this, index / 2);
}
 
QJsonObject::iterator QJsonObject::insert(const QString &key, const QJsonValue &value)
{
    return insert(QStringView(key), value);
}
 
QJsonObject::iterator QJsonObject::insert(QStringView key, const QJsonValue &value)
{
    return insertImpl(key, value);
}
 
QJsonObject::iterator QJsonObject::insert(QLatin1StringView key, const QJsonValue &value)
{
    return insertImpl(key, value);
}
 
template <typename T>
QJsonObject::iterator QJsonObject::insertImpl(T key, const QJsonValue &value)
{
    if (value.type() == QJsonValue::Undefined) {
        remove(key);
        return end();
    }
    bool keyExists = false;
    auto pos = o ? indexOf(o, key, &keyExists) : 0;
    return insertAt(pos, key, value, keyExists);
}
 
template <typename T>
QJsonObject::iterator QJsonObject::insertAt(qsizetype pos, T key, const QJsonValue &value, bool keyExists)
{
    if (o)
        detach(o->elements.size() / 2 + (keyExists ? 0 : 1));
    else
        o = new QCborContainerPrivate;
 
    if (keyExists) {
        o->replaceAt(pos + 1, QCborValue::fromJsonValue(value));
    } else {
        o->insertAt(pos, key);
        o->insertAt(pos + 1, QCborValue::fromJsonValue(value));
    }
    return {this, pos / 2};
}
 
void QJsonObject::remove(const QString &key)
{
    remove(QStringView(key));
}
 
void QJsonObject::remove(QStringView key)
{
    removeImpl(key);
}
 
void QJsonObject::remove(QLatin1StringView key)
{
    removeImpl(key);
}
 
template <typename T>
void QJsonObject::removeImpl(T key)
{
    if (!o)
        return;
 
    bool keyExists;
    auto index = indexOf(o, key, &keyExists);
    if (!keyExists)
        return;
 
    removeAt(index);
}
 
QJsonValue QJsonObject::take(const QString &key)
{
    return take(QStringView(key));
}
 
QJsonValue QJsonObject::take(QStringView key)
{
    return takeImpl(key);
}
 
QJsonValue QJsonObject::take(QLatin1StringView key)
{
    return takeImpl(key);
}
 
template <typename T>
QJsonValue QJsonObject::takeImpl(T key)
{
    if (!o)
        return QJsonValue(QJsonValue::Undefined);
 
    bool keyExists;
    auto index = indexOf(o, key, &keyExists);
    if (!keyExists)
        return QJsonValue(QJsonValue::Undefined);
 
    detach();
    const QJsonValue v = QJsonPrivate::Value::fromTrustedCbor(o->extractAt(index + 1));
    removeAt(index);
    return v;
}
 
bool QJsonObject::contains(const QString &key) const
{
    return contains(QStringView(key));
}
 
bool QJsonObject::contains(QStringView key) const
{
    return containsImpl(key);
}
 
bool QJsonObject::contains(QLatin1StringView key) const
{
    return containsImpl(key);
}
 
template <typename T>
bool QJsonObject::containsImpl(T key) const
{
    if (!o)
        return false;
 
    bool keyExists;
    indexOf(o, key, &keyExists);
    return keyExists;
}
 
bool comparesEqual(const QJsonObject &lhs, const QJsonObject &rhs) noexcept
{
    if (lhs.o == rhs.o)
        return true;
 
    if (!lhs.o)
        return !rhs.o->elements.size();
    if (!rhs.o)
        return !lhs.o->elements.size();
    if (lhs.o->elements.size() != rhs.o->elements.size())
        return false;
 
    for (qsizetype i = 0, end = lhs.o->elements.size(); i < end; ++i) {
        if (lhs.o->valueAt(i) != rhs.o->valueAt(i))
            return false;
    }
 
    return true;
}
 
QJsonObject::iterator QJsonObject::erase(QJsonObject::iterator it)
{
    removeAt(it.item.index * 2);
 
    // index hasn't changed; the container pointer shouldn't have changed
    // because we shouldn't have detached (detaching happens on obtaining a
    // non-const iterator). But just in case we did, reload the pointer.
    return { this, qsizetype(it.item.index) };
}
 
QJsonObject::iterator QJsonObject::find(const QString &key)
{
    return find(QStringView(key));
}
 
QJsonObject::iterator QJsonObject::find(QStringView key)
{
    return findImpl(key);
}
 
QJsonObject::iterator QJsonObject::find(QLatin1StringView key)
{
    return findImpl(key);
}
 
template <typename T>
QJsonObject::iterator QJsonObject::findImpl(T key)
{
    bool keyExists = false;
    auto index = o ? indexOf(o, key, &keyExists) : 0;
    if (!keyExists)
        return end();
    detach();
    return {this, index / 2};
}
 
QJsonObject::const_iterator QJsonObject::constFind(const QString &key) const
{
    return constFind(QStringView(key));
}
 
QJsonObject::const_iterator QJsonObject::constFind(QStringView key) const
{
    return constFindImpl(key);
}
 
QJsonObject::const_iterator QJsonObject::constFind(QLatin1StringView key) const
{
    return constFindImpl(key);
}
 
template <typename T>
QJsonObject::const_iterator QJsonObject::constFindImpl(T key) const
{
    bool keyExists = false;
    auto index = o ? indexOf(o, key, &keyExists) : 0;
    if (!keyExists)
        return end();
    return {this, index / 2};
}
 
bool QJsonObject::detach(qsizetype reserve)
{
    if (!o)
        return true;
    o = QCborContainerPrivate::detach(o.data(), reserve ? reserve * 2 : o->elements.size());
    return o;
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
QString QJsonObject::keyAt(qsizetype i) const
{
    Q_ASSERT(o && i >= 0 && i * 2 < o->elements.size());
    return o->stringAt(i * 2);
}
 
QJsonValue QJsonObject::valueAt(qsizetype i) const
{
    if (!o || i < 0 || 2 * i + 1 >= o->elements.size())
        return QJsonValue(QJsonValue::Undefined);
    return QJsonPrivate::Value::fromTrustedCbor(o->valueAt(2 * i + 1));
}
 
void QJsonObject::setValueAt(qsizetype i, const QJsonValue &val)
{
    Q_ASSERT(o && i >= 0 && 2 * i + 1 < o->elements.size());
    detach();
    if (val.isUndefined()) {
        o->removeAt(2 * i + 1);
        o->removeAt(2 * i);
    } else {
        o->replaceAt(2 * i + 1, QCborValue::fromJsonValue(val));
    }
}
#endif // Qt 7
 
void QJsonObject::removeAt(qsizetype index)
{
    detach();
    o->removeAt(index + 1);
    o->removeAt(index);
}
 
size_t qHash(const QJsonObject &object, size_t seed)
{
    QtPrivate::QHashCombine hash;
    for (auto it = object.begin(), end = object.end(); it != end; ++it) {
        const QString key = it.key();
        const QJsonValue value = it.value();
        seed = hash(seed, std::pair<const QString&, const QJsonValue&>(key, value));
    }
    return seed;
}
 
#if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_JSON_READONLY)
QDebug operator<<(QDebug dbg, const QJsonObject &o)
{
    QDebugStateSaver saver(dbg);
    if (!o.o) {
        dbg << "QJsonObject()";
        return dbg;
    }
    QByteArray json;
    QJsonPrivate::Writer::objectToJson(o.o.data(), json, 0, true);
    dbg.nospace() << "QJsonObject("
                  << json.constData() // print as utf-8 string without extra quotation marks
                  << ")";
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QJsonObject &object)
{
    QJsonDocument doc{object};
    stream << doc.toJson(QJsonDocument::Compact);
    return stream;
}
 
QDataStream &operator>>(QDataStream &stream, QJsonObject &object)
{
    QJsonDocument doc;
    stream >> doc;
    object = doc.object();
    return stream;
}
#endif
 
QT_END_NAMESPACE