qjsonarray.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 <qcborarray.h>
#include <qvariant.h>
#include <qdebug.h>
 
#include <private/qcborvalue_p.h>
#include <private/qjson_p.h>
 
#include "qjsonwriter_p.h"
 
QT_BEGIN_NAMESPACE
 
QJsonArray::QJsonArray() = default;
 
QJsonArray::QJsonArray(QCborContainerPrivate *array)
    : a(array)
{
}
 
QJsonArray::~QJsonArray() = default;
 
QJsonArray::QJsonArray(std::initializer_list<QJsonValue> args)
{
    for (const auto & arg : args)
        append(arg);
}
 
QJsonArray::QJsonArray(const QJsonArray &other) noexcept = default;
 
QJsonArray::QJsonArray(QJsonArray &&other) noexcept
    : a(other.a)
{
    other.a = nullptr;
}
 
QJsonArray &QJsonArray::operator =(const QJsonArray &other) noexcept = default;
 
QJsonArray QJsonArray::fromStringList(const QStringList &list)
{
    QJsonArray array;
    for (QStringList::const_iterator it = list.constBegin(); it != list.constEnd(); ++it)
        array.append(QJsonValue(*it));
    return array;
}
 
#ifndef QT_NO_VARIANT
QJsonArray QJsonArray::fromVariantList(const QVariantList &list)
{
    return QJsonPrivate::Variant::toJsonArray(list);
}
 
QVariantList QJsonArray::toVariantList() const
{
    return QCborArray::fromJsonArray(*this).toVariantList();
}
#endif // !QT_NO_VARIANT
 
 
qsizetype QJsonArray::size() const
{
    return a ? a->elements.size() : 0;
}
 
bool QJsonArray::isEmpty() const
{
    return a == nullptr || a->elements.isEmpty();
}
 
QJsonValue QJsonArray::at(qsizetype i) const
{
    if (!a || i < 0 || i >= a->elements.size())
        return QJsonValue(QJsonValue::Undefined);
 
    return QJsonPrivate::Value::fromTrustedCbor(a->valueAt(i));
}
 
QJsonValue QJsonArray::first() const
{
    return at(0);
}
 
QJsonValue QJsonArray::last() const
{
    return at(a ? (a->elements.size() - 1) : 0);
}
 
void QJsonArray::prepend(const QJsonValue &value)
{
    insert(0, value);
}
 
void QJsonArray::append(const QJsonValue &value)
{
    insert(a ? a->elements.size() : 0, value);
}
 
void QJsonArray::removeAt(qsizetype i)
{
    if (!a || i < 0 || i >= a->elements.size())
        return;
    detach();
    a->removeAt(i);
}
 
QJsonValue QJsonArray::takeAt(qsizetype i)
{
    if (!a || i < 0 || i >= a->elements.size())
        return QJsonValue(QJsonValue::Undefined);
 
    detach();
    const QJsonValue v = QJsonPrivate::Value::fromTrustedCbor(a->extractAt(i));
    a->removeAt(i);
    return v;
}
 
void QJsonArray::insert(qsizetype i, const QJsonValue &value)
{
    if (a)
        detach(a->elements.size() + 1);
    else
        a = new QCborContainerPrivate;
 
    Q_ASSERT (i >= 0 && i <= a->elements.size());
    a->insertAt(i, value.type() == QJsonValue::Undefined ? QCborValue(nullptr)
                                                         : QCborValue::fromJsonValue(value));
}
 
void QJsonArray::replace(qsizetype i, const QJsonValue &value)
{
    Q_ASSERT (a && i >= 0 && i < a->elements.size());
    detach();
    a->replaceAt(i, QCborValue::fromJsonValue(value));
}
 
bool QJsonArray::contains(const QJsonValue &value) const
{
    for (qsizetype i = 0; i < size(); i++) {
        if (at(i) == value)
            return true;
    }
    return false;
}
 
QJsonValueRef QJsonArray::operator [](qsizetype i)
{
    Q_ASSERT(a && i >= 0 && i < a->elements.size());
    return QJsonValueRef(this, i);
}
 
QJsonValue QJsonArray::operator[](qsizetype i) const
{
    return at(i);
}
 
bool comparesEqual(const QJsonArray &lhs, const QJsonArray &rhs) noexcept
{
    if (lhs.a == rhs.a)
        return true;
 
    if (!lhs.a)
        return !rhs.a->elements.size();
    if (!rhs.a)
        return !lhs.a->elements.size();
    if (lhs.a->elements.size() != rhs.a->elements.size())
        return false;
 
    for (qsizetype i = 0; i < lhs.a->elements.size(); ++i) {
        if (lhs.a->valueAt(i) != rhs.a->valueAt(i))
            return false;
    }
    return true;
}
 
bool comparesEqual(const QJsonArray &lhs, const QJsonValue &rhs) noexcept
{
    return lhs == rhs.toArray();
}
 
bool QJsonArray::detach(qsizetype reserve)
{
    if (!a)
        return true;
    a = a->detach(a.data(), reserve ? reserve : size());
    return a;
}
 
size_t qHash(const QJsonArray &array, size_t seed)
{
    return qHashRange(array.begin(), array.end(), seed);
}
 
#if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_JSON_READONLY)
QDebug operator<<(QDebug dbg, const QJsonArray &a)
{
    QDebugStateSaver saver(dbg);
    if (!a.a) {
        dbg << "QJsonArray()";
        return dbg;
    }
    QByteArray json;
    QJsonPrivate::Writer::arrayToJson(a.a.data(), json, 0, true);
    dbg.nospace() << "QJsonArray("
                  << json.constData() // print as utf-8 string without extra quotation marks
                  << ")";
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &stream, const QJsonArray &array)
{
    return stream << QJsonDocument{array};
}
 
QDataStream &operator>>(QDataStream &stream, QJsonArray &array)
{
    QJsonDocument doc;
    stream >> doc;
    array = doc.array();
    return stream;
}
#endif
 
QT_END_NAMESPACE