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
// Qt-Security score:critical reason:data-parser
 
#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
 
/*!
    \class QJsonArray
    \inmodule QtCore
    \ingroup json
    \ingroup shared
    \ingroup qtserialization
    \reentrant
    \since 5.0
 
    \brief The QJsonArray class encapsulates a JSON array.
 
    \compares equality
    \compareswith equality QJsonValue
    \endcompareswith
 
    A JSON array is a list of values. The list can be manipulated by inserting and
    removing QJsonValue's from the array.
 
    A QJsonArray can be converted to and from a QVariantList. You can query the
    number of entries with size(), insert(), and removeAt() entries from it
    and iterate over its content using the standard C++ iterator pattern.
 
    QJsonArray is an implicitly shared class and shares the data with the document
    it has been created from as long as it is not being modified.
 
    You can convert the array to and from text based JSON through QJsonDocument.
 
    \sa {JSON Support in Qt}, {Saving and Loading a Game}
*/
 
/*!
    \typedef QJsonArray::Iterator
 
    Qt-style synonym for QJsonArray::iterator.
*/
 
/*!
    \typedef QJsonArray::ConstIterator
 
    Qt-style synonym for QJsonArray::const_iterator.
*/
 
/*!
    \typedef QJsonArray::size_type
 
    Typedef for qsizetype. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::value_type
 
    Typedef for QJsonValue. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::difference_type
 
    Typedef for qsizetype. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::pointer
 
    Typedef for QJsonValue *. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::const_pointer
 
    Typedef for const QJsonValue *. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::reference
 
    Typedef for QJsonValue &. Provided for STL compatibility.
*/
 
/*!
    \typedef QJsonArray::const_reference
 
    Typedef for const QJsonValue &. Provided for STL compatibility.
*/
 
/*!
    Creates an empty array.
 */
QJsonArray::QJsonArray() = default;
 
/*!
    \fn QJsonArray::QJsonArray(std::initializer_list<QJsonValue> args)
    \since 5.4
    Creates an array initialized from \a args initialization list.
 
    QJsonArray can be constructed in a way similar to JSON notation,
    for example:
    \code
    QJsonArray array = { 1, 2.2, QString() };
    \endcode
 */
 
/*!
    \internal
 */
QJsonArray::QJsonArray(QCborContainerPrivate *array)
    : a(array)
{
}
 
/*!
    Deletes the array.
 */
QJsonArray::~QJsonArray() = default;
 
QJsonArray::QJsonArray(std::initializer_list<QJsonValue> args)
{
    for (const auto & arg : args)
        append(arg);
}
 
/*!
    Creates a copy of \a other.
 
    Since QJsonArray is implicitly shared, the copy is shallow
    as long as the object doesn't get modified.
 */
QJsonArray::QJsonArray(const QJsonArray &other) noexcept = default;
 
/*!
    \since 5.10
 
    Move-constructs a QJsonArray from \a other.
*/
QJsonArray::QJsonArray(QJsonArray &&other) noexcept
    : a(other.a)
{
    other.a = nullptr;
}
 
/*!
    Assigns \a other to this array.
 */
QJsonArray &QJsonArray::operator =(const QJsonArray &other) noexcept = default;
 
/*!
    \fn QJsonArray &QJsonArray::operator =(QJsonArray &&other)
    \since 5.10
 
    Move-assigns \a other to this array.
*/
 
/*!
    \fn void QJsonArray::swap(QJsonArray &other)
    \since 5.10
    \memberswap{array}
*/
 
/*! \fn QJsonArray &QJsonArray::operator+=(const QJsonValue &value)
 
    Appends \a value to the array, and returns a reference to the array itself.
 
    \since 5.3
    \sa append(), operator<<()
*/
 
/*! \fn QJsonArray QJsonArray::operator+(const QJsonValue &value) const
 
    Returns an array that contains all the items in this array followed
    by the provided \a value.
 
    \since 5.3
    \sa operator+=()
*/
 
/*! \fn QJsonArray &QJsonArray::operator<<(const QJsonValue &value)
 
    Appends \a value to the array, and returns a reference to the array itself.
 
    \since 5.3
    \sa operator+=(), append()
*/
 
/*!
    Converts the string list \a list to a QJsonArray.
 
    The values in \a list will be converted to JSON values.
 
    \sa toVariantList(), QJsonValue::fromVariant()
 */
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
/*!
    Converts the variant list \a list to a QJsonArray.
 
    The QVariant values in \a list will be converted to JSON values.
 
    \note Conversion from \l QVariant is not completely lossless. Please see
    the documentation in QJsonValue::fromVariant() for more information.
 
    \sa toVariantList(), QJsonValue::fromVariant()
 */
QJsonArray QJsonArray::fromVariantList(const QVariantList &list)
{
    return QJsonPrivate::Variant::toJsonArray(list);
}
 
/*!
    Converts this object to a QVariantList.
 
    Returns the created map.
 */
QVariantList QJsonArray::toVariantList() const
{
    return QCborArray::fromJsonArray(*this).toVariantList();
}
#endif // !QT_NO_VARIANT
 
 
/*!
    Returns the number of values stored in the array.
 */
qsizetype QJsonArray::size() const
{
    return a ? a->elements.size() : 0;
}
 
/*!
    \fn QJsonArray::count() const
 
    Same as size().
 
    \sa size()
*/
 
/*!
    Returns \c true if the object is empty. This is the same as size() == 0.
 
    \sa size()
 */
bool QJsonArray::isEmpty() const
{
    return a == nullptr || a->elements.isEmpty();
}
 
/*!
    Returns a QJsonValue representing the value for index \a i.
 
    The returned QJsonValue is \c Undefined, if \a i is out of bounds.
 
 */
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));
}
 
/*!
    Returns the first value stored in the array.
 
    Same as \c at(0).
 
    \sa at()
 */
QJsonValue QJsonArray::first() const
{
    return at(0);
}
 
/*!
    Returns the last value stored in the array.
 
    Same as \c{at(size() - 1)}.
 
    \sa at()
 */
QJsonValue QJsonArray::last() const
{
    return at(a ? (a->elements.size() - 1) : 0);
}
 
/*!
    Inserts \a value at the beginning of the array.
 
    This is the same as \c{insert(0, value)} and will prepend \a value to the array.
 
    \sa append(), insert()
 */
void QJsonArray::prepend(const QJsonValue &value)
{
    insert(0, value);
}
 
/*!
    Inserts \a value at the end of the array.
 
    \sa prepend(), insert()
 */
void QJsonArray::append(const QJsonValue &value)
{
    insert(a ? a->elements.size() : 0, value);
}
 
/*!
    Removes the value at index position \a i. \a i must be a valid
    index position in the array (i.e., \c{0 <= i < size()}).
 
    \sa insert(), replace()
 */
void QJsonArray::removeAt(qsizetype i)
{
    if (!a || i < 0 || i >= a->elements.size())
        return;
    detach();
    a->removeAt(i);
}
 
/*! \fn void QJsonArray::removeFirst()
 
    Removes the first item in the array. Calling this function is
    equivalent to calling \c{removeAt(0)}. The array must not be empty. If
    the array can be empty, call isEmpty() before calling this
    function.
 
    \sa removeAt(), removeLast()
*/
 
/*! \fn void QJsonArray::removeLast()
 
    Removes the last item in the array. Calling this function is
    equivalent to calling \c{removeAt(size() - 1)}. The array must not be
    empty. If the array can be empty, call isEmpty() before calling
    this function.
 
    \sa removeAt(), removeFirst()
*/
 
/*!
    Removes the item at index position \a i and returns it. \a i must
    be a valid index position in the array (i.e., \c{0 <= i < size()}).
 
    If you don't use the return value, removeAt() is more efficient.
 
    \sa removeAt()
 */
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;
}
 
/*!
    Inserts \a value at index position \a i in the array. If \a i
    is \c 0, the value is prepended to the array. If \a i is size(), the
    value is appended to the array.
 
    \sa append(), prepend(), replace(), removeAt()
 */
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));
}
 
/*!
    \fn QJsonArray::iterator QJsonArray::insert(iterator before, const QJsonValue &value)
 
    Inserts \a value before the position pointed to by \a before, and returns an iterator
    pointing to the newly inserted item.
 
    \sa erase(), insert(qsizetype, const QJsonValue &)
*/
 
/*!
    \fn QJsonArray::iterator QJsonArray::erase(iterator it)
 
    Removes the item pointed to by \a it, and returns an iterator pointing to the
    next item.
 
    \sa removeAt()
*/
 
/*!
    Replaces the item at index position \a i with \a value. \a i must
    be a valid index position in the array (i.e., \c{0 <= i < size()}).
 
    \sa operator[](), removeAt()
 */
void QJsonArray::replace(qsizetype i, const QJsonValue &value)
{
    Q_ASSERT (a && i >= 0 && i < a->elements.size());
    detach();
    a->replaceAt(i, QCborValue::fromJsonValue(value));
}
 
/*!
    Returns \c true if the array contains an occurrence of \a value, otherwise \c false.
 
    \sa count()
 */
bool QJsonArray::contains(const QJsonValue &value) const
{
    for (qsizetype i = 0; i < size(); i++) {
        if (at(i) == value)
            return true;
    }
    return false;
}
 
/*!
    Returns the value at index position \a i as a modifiable reference.
    \a i must be a valid index position in the array (i.e., \c{0 <= i <
    size()}).
 
    The return value is of type QJsonValueRef, a helper class for QJsonArray
    and QJsonObject. When you get an object of type QJsonValueRef, you can
    use it as if it were a reference to a QJsonValue. If you assign to it,
    the assignment will apply to the character in the QJsonArray of QJsonObject
    from which you got the reference.
 
    \sa at()
 */
QJsonValueRef QJsonArray::operator [](qsizetype i)
{
    Q_ASSERT(a && i >= 0 && i < a->elements.size());
    return QJsonValueRef(this, i);
}
 
/*!
    \overload
 
    Same as at().
 */
QJsonValue QJsonArray::operator[](qsizetype i) const
{
    return at(i);
}
 
bool comparesEqual(const QJsonArray &lhs, const QJsonArray &rhs)
{
    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)
{
    return lhs == rhs.toArray();
}
 
/*! \fn bool QJsonArray::operator==(const QJsonArray &lhs, const QJsonArray &rhs)
 
    Returns \c true if \a lhs array is equal to \a rhs, \c false otherwise.
*/
 
/*! \fn bool QJsonArray::operator!=(const QJsonArray &lhs, const QJsonArray &rhs)
 
    Returns \c true if \a lhs array is not equal to \a rhs, \c false otherwise.
*/
 
/*! \fn QJsonArray::iterator QJsonArray::begin()
 
    Returns an \l{STL-style iterators}{STL-style iterator} pointing to the first item in
    the array.
 
    \sa constBegin(), end()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::begin() const
 
    \overload
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::constBegin() const
 
    Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
    in the array.
 
    \sa begin(), constEnd()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::cbegin() const
 
    Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
    in the array.
 
    \sa begin(), cend()
*/
 
/*! \fn QJsonArray::iterator QJsonArray::end()
 
    Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary item
    after the last item in the array.
 
    \sa begin(), constEnd()
*/
 
/*! \fn const_iterator QJsonArray::end() const
 
    \overload
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::constEnd() const
 
    Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
    item after the last item in the array.
 
    \sa constBegin(), end()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::cend() const
 
    Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
    item after the last item in the array.
 
    \sa cbegin(), end()
*/
 
/*! \fn void QJsonArray::push_back(const QJsonValue &value)
 
    This function is provided for STL compatibility. It is equivalent
    to \l{QJsonArray::append()}{append(value)} and will append \a value to the array.
*/
 
/*! \fn void QJsonArray::push_front(const QJsonValue &value)
 
    This function is provided for STL compatibility. It is equivalent
    to \l{QJsonArray::prepend()}{prepend(value)} and will prepend \a value to the array.
*/
 
/*! \fn void QJsonArray::pop_front()
 
    This function is provided for STL compatibility. It is equivalent
    to removeFirst(). The array must not be empty. If the array can be
    empty, call isEmpty() before calling this function.
*/
 
/*! \fn void QJsonArray::pop_back()
 
    This function is provided for STL compatibility. It is equivalent
    to removeLast(). The array must not be empty. If the array can be
    empty, call isEmpty() before calling this function.
*/
 
/*! \fn bool QJsonArray::empty() const
 
    This function is provided for STL compatibility. It is equivalent
    to isEmpty() and returns \c true if the array is empty.
*/
 
/*! \class QJsonArray::iterator
    \inmodule QtCore
    \brief The QJsonArray::iterator class provides an STL-style non-const iterator for QJsonArray.
 
    \compares strong
    \compareswith strong QJsonArray::const_iterator
    \endcompareswith
 
    QJsonArray::iterator allows you to iterate over a QJsonArray
    and to modify the array item associated with the
    iterator. If you want to iterate over a const QJsonArray, use
    QJsonArray::const_iterator instead. It is generally a good practice to
    use QJsonArray::const_iterator on a non-const QJsonArray as well, unless
    you need to change the QJsonArray through the iterator. Const
    iterators are slightly faster and improves code readability.
 
    The default QJsonArray::iterator constructor creates an uninitialized
    iterator. You must initialize it using a QJsonArray function like
    QJsonArray::begin(), QJsonArray::end(), or QJsonArray::insert() before you can
    start iterating.
 
    Most QJsonArray functions accept an integer index rather than an
    iterator. For that reason, iterators are rarely useful in
    connection with QJsonArray. One place where STL-style iterators do
    make sense is as arguments to \l{generic algorithms}.
 
    Multiple iterators can be used on the same array. However, be
    aware that any non-const function call performed on the QJsonArray
    will render all existing iterators undefined.
 
    \sa QJsonArray::const_iterator
*/
 
/*! \typedef QJsonArray::iterator::iterator_category
 
  A synonym for \e {std::random_access_iterator_tag} indicating
  this iterator is a random access iterator.
*/
 
/*! \typedef QJsonArray::iterator::difference_type
 
    \internal
*/
 
/*! \typedef QJsonArray::iterator::value_type
 
    \internal
*/
 
/*! \typedef QJsonArray::iterator::reference
 
    \internal
*/
 
/*! \typedef QJsonArray::iterator::pointer
 
    \internal
*/
 
/*! \fn QJsonArray::iterator::iterator()
 
    Constructs an uninitialized iterator.
 
    Functions like operator*() and operator++() should not be called
    on an uninitialized iterator. Use operator=() to assign a value
    to it before using it.
 
    \sa QJsonArray::begin(), QJsonArray::end()
*/
 
/*! \fn QJsonArray::iterator::iterator(QJsonArray *array, qsizetype index)
    \internal
*/
 
/*! \fn QJsonValueRef QJsonArray::iterator::operator*() const
 
 
    Returns a modifiable reference to the current item.
 
    You can change the value of an item by using operator*() on the
    left side of an assignment.
 
    The return value is of type QJsonValueRef, a helper class for QJsonArray
    and QJsonObject. When you get an object of type QJsonValueRef, you can
    use it as if it were a reference to a QJsonValue. If you assign to it,
    the assignment will apply to the character in the QJsonArray of QJsonObject
    from which you got the reference.
*/
 
/*! \fn QJsonValueRef *QJsonArray::iterator::operator->() const
 
    Returns a pointer to a modifiable reference to the current item.
*/
 
/*! \fn QJsonValueRef QJsonArray::iterator::operator[](qsizetype j) const
 
    Returns a modifiable reference to the item at offset \a j from the
    item pointed to by this iterator (the item at position \c{*this + j}).
 
    This function is provided to make QJsonArray iterators behave like C++
    pointers.
 
    The return value is of type QJsonValueRef, a helper class for QJsonArray
    and QJsonObject. When you get an object of type QJsonValueRef, you can
    use it as if it were a reference to a QJsonValue. If you assign to it,
    the assignment will apply to the element in the QJsonArray or QJsonObject
    from which you got the reference.
 
    \sa operator+()
*/
 
/*!
    \fn bool QJsonArray::iterator::operator==(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator==(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if \a lhs points to the same item as \a rhs
    iterator; otherwise returns \c false.
 
    \sa operator!=()
*/
 
/*!
    \fn bool QJsonArray::iterator::operator!=(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator!=(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if \a lhs points to a different item than \a rhs
    iterator; otherwise returns \c false.
 
    \sa operator==()
*/
 
/*!
    \fn bool QJsonArray::iterator::operator<(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator<(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is less than
    the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::iterator::operator<=(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator<=(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is less than
    or equal to the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::iterator::operator>(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator>(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is greater
    than the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::iterator::operator>=(const iterator &lhs, const iterator &rhs)
    \fn bool QJsonArray::iterator::operator>=(const iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is greater
    than or equal to the item pointed to by the \a rhs iterator.
*/
 
/*! \fn QJsonArray::iterator &QJsonArray::iterator::operator++()
 
    The prefix \c{++} operator, \c{++it}, advances the iterator to the
    next item in the array and returns an iterator to the new current
    item.
 
    Calling this function on QJsonArray::end() leads to undefined results.
 
    \sa operator--()
*/
 
/*! \fn QJsonArray::iterator QJsonArray::iterator::operator++(int)
 
    \overload
 
    The postfix \c{++} operator, \c{it++}, advances the iterator to the
    next item in the array and returns an iterator to the previously
    current item.
*/
 
/*! \fn QJsonArray::iterator &QJsonArray::iterator::operator--()
 
    The prefix \c{--} operator, \c{--it}, makes the preceding item
    current and returns an iterator to the new current item.
 
    Calling this function on QJsonArray::begin() leads to undefined results.
 
    \sa operator++()
*/
 
/*! \fn QJsonArray::iterator QJsonArray::iterator::operator--(int)
 
    \overload
 
    The postfix \c{--} operator, \c{it--}, makes the preceding item
    current and returns an iterator to the previously current item.
*/
 
/*! \fn QJsonArray::iterator &QJsonArray::iterator::operator+=(qsizetype j)
 
    Advances the iterator by \a j items. If \a j is negative, the
    iterator goes backward.
 
    \sa operator-=(), operator+()
*/
 
/*! \fn QJsonArray::iterator &QJsonArray::iterator::operator-=(qsizetype j)
 
    Makes the iterator go back by \a j items. If \a j is negative,
    the iterator goes forward.
 
    \sa operator+=(), operator-()
*/
 
/*! \fn QJsonArray::iterator QJsonArray::iterator::operator+(qsizetype j) const
 
    Returns an iterator to the item at \a j positions forward from
    this iterator. If \a j is negative, the iterator goes backward.
 
    \sa operator-(), operator+=()
*/
 
/*! \fn QJsonArray::iterator QJsonArray::iterator::operator-(qsizetype j) const
 
    Returns an iterator to the item at \a j positions backward from
    this iterator. If \a j is negative, the iterator goes forward.
 
    \sa operator+(), operator-=()
*/
 
/*! \fn qsizetype QJsonArray::iterator::operator-(iterator other) const
 
    Returns the number of items between the item pointed to by \a
    other and the item pointed to by this iterator.
*/
 
/*! \class QJsonArray::const_iterator
    \inmodule QtCore
    \brief The QJsonArray::const_iterator class provides an STL-style const iterator for QJsonArray.
 
    \compares strong
    \compareswith strong QJsonArray::iterator
    \endcompareswith
 
    QJsonArray::const_iterator allows you to iterate over a
    QJsonArray. If you want to modify the QJsonArray as
    you iterate over it, use QJsonArray::iterator instead. It is generally a
    good practice to use QJsonArray::const_iterator on a non-const QJsonArray
    as well, unless you need to change the QJsonArray through the
    iterator. Const iterators are slightly faster and improves
    code readability.
 
    The default QJsonArray::const_iterator constructor creates an
    uninitialized iterator. You must initialize it using a QJsonArray
    function like QJsonArray::constBegin(), QJsonArray::constEnd(), or
    QJsonArray::insert() before you can start iterating.
 
    Most QJsonArray functions accept an integer index rather than an
    iterator. For that reason, iterators are rarely useful in
    connection with QJsonArray. One place where STL-style iterators do
    make sense is as arguments to \l{generic algorithms}.
 
    Multiple iterators can be used on the same array. However, be
    aware that any non-const function call performed on the QJsonArray
    will render all existing iterators undefined.
 
    \sa QJsonArray::iterator
*/
 
/*! \fn QJsonArray::const_iterator::const_iterator()
 
    Constructs an uninitialized iterator.
 
    Functions like operator*() and operator++() should not be called
    on an uninitialized iterator. Use operator=() to assign a value
    to it before using it.
 
    \sa QJsonArray::constBegin(), QJsonArray::constEnd()
*/
 
/*! \fn QJsonArray::const_iterator::const_iterator(const QJsonArray *array, qsizetype index)
    \internal
*/
 
/*! \typedef QJsonArray::const_iterator::iterator_category
 
  A synonym for \e {std::random_access_iterator_tag} indicating
  this iterator is a random access iterator.
*/
 
/*! \typedef QJsonArray::const_iterator::difference_type
 
    \internal
*/
 
/*! \typedef QJsonArray::const_iterator::value_type
 
    \internal
*/
 
/*! \typedef QJsonArray::const_iterator::reference
 
    \internal
*/
 
/*! \typedef QJsonArray::const_iterator::pointer
 
    \internal
*/
 
/*! \fn QJsonArray::const_iterator::const_iterator(const iterator &other)
 
    Constructs a copy of \a other.
*/
 
/*! \fn const QJsonValueRef QJsonArray::const_iterator::operator*() const
 
    Returns the current item.
*/
 
/*! \fn const QJsonValueRef *QJsonArray::const_iterator::operator->() const
 
    Returns a pointer to the current item.
*/
 
/*! \fn QJsonValue QJsonArray::const_iterator::operator[](qsizetype j) const
 
    Returns the item at offset \a j from the item pointed to by this iterator (the item at
    position \c{*this + j}).
 
    This function is provided to make QJsonArray iterators behave like C++
    pointers.
 
    \sa operator+()
*/
 
/*! \fn bool QJsonArray::const_iterator::operator==(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if \a lhs points to the same item as \a rhs
    iterator; otherwise returns \c false.
 
    \sa operator!=()
*/
 
/*! \fn bool QJsonArray::const_iterator::operator!=(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if \a lhs points to a different item than \a rhs
    iterator; otherwise returns \c false.
 
    \sa operator==()
*/
 
/*!
    \fn bool QJsonArray::const_iterator::operator<(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is less than
    the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::const_iterator::operator<=(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is less than
    or equal to the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::const_iterator::operator>(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is greater
    than the item pointed to by the \a rhs iterator.
*/
 
/*!
    \fn bool QJsonArray::const_iterator::operator>=(const const_iterator &lhs, const const_iterator &rhs)
 
    Returns \c true if the item pointed to by \a lhs iterator is greater
    than or equal to the item pointed to by the \a rhs iterator.
*/
 
/*! \fn QJsonArray::const_iterator &QJsonArray::const_iterator::operator++()
 
    The prefix \c{++} operator, \c{++it}, advances the iterator to the
    next item in the array and returns an iterator to the new current
    item.
 
    Calling this function on QJsonArray::end() leads to undefined results.
 
    \sa operator--()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::const_iterator::operator++(int)
 
    \overload
 
    The postfix \c{++} operator, \c{it++}, advances the iterator to the
    next item in the array and returns an iterator to the previously
    current item.
*/
 
/*! \fn QJsonArray::const_iterator &QJsonArray::const_iterator::operator--()
 
    The prefix \c{--} operator, \c{--it}, makes the preceding item
    current and returns an iterator to the new current item.
 
    Calling this function on QJsonArray::begin() leads to undefined results.
 
    \sa operator++()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::const_iterator::operator--(int)
 
    \overload
 
    The postfix \c{--} operator, \c{it--}, makes the preceding item
    current and returns an iterator to the previously current item.
*/
 
/*! \fn QJsonArray::const_iterator &QJsonArray::const_iterator::operator+=(qsizetype j)
 
    Advances the iterator by \a j items. If \a j is negative, the
    iterator goes backward.
 
    \sa operator-=(), operator+()
*/
 
/*! \fn QJsonArray::const_iterator &QJsonArray::const_iterator::operator-=(qsizetype j)
 
    Makes the iterator go back by \a j items. If \a j is negative,
    the iterator goes forward.
 
    \sa operator+=(), operator-()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::const_iterator::operator+(qsizetype j) const
 
    Returns an iterator to the item at \a j positions forward from
    this iterator. If \a j is negative, the iterator goes backward.
 
    \sa operator-(), operator+=()
*/
 
/*! \fn QJsonArray::const_iterator QJsonArray::const_iterator::operator-(qsizetype j) const
 
    Returns an iterator to the item at \a j positions backward from
    this iterator. If \a j is negative, the iterator goes forward.
 
    \sa operator+(), operator-=()
*/
 
/*! \fn qsizetype QJsonArray::const_iterator::operator-(const_iterator other) const
 
    Returns the number of items between the item pointed to by \a
    other and the item pointed to by this iterator.
*/
 
/*!
    \internal
 */
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)
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