Revision control
++ // 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
++