diff options
Diffstat (limited to 'src/corelib/serialization/qcborarray.cpp')
| -rw-r--r-- | src/corelib/serialization/qcborarray.cpp | 1213 |
1 files changed, 1213 insertions, 0 deletions
diff --git a/src/corelib/serialization/qcborarray.cpp b/src/corelib/serialization/qcborarray.cpp new file mode 100644 index 0000000000..921fcf2fca --- /dev/null +++ b/src/corelib/serialization/qcborarray.cpp @@ -0,0 +1,1213 @@ +/**************************************************************************** +** +** Copyright (C) 2018 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qcborarray.h" +#include "qcborvalue_p.h" + +QT_BEGIN_NAMESPACE + +using namespace QtCbor; + +/*! + \class QCborArray + \inmodule QtCore + \ingroup cbor + \reentrant + \since 5.12 + + \brief The QCborArray class is used to hold an array of CBOR elements. + + This class can be used to hold one sequential container in CBOR (an array). + CBOR is the Concise Binary Object Representation, a very compact form of + binary data encoding that is a superset of JSON. It was created by the IETF + Constrained RESTful Environments (CoRE) WG, which has used it in many new + RFCs. It is meant to be used alongside the + \l{https://tools.ietf.org/html/rfc7252}{CoAP protocol}. + + QCborArray is very similar to \l QVariantList and \l QJsonArray and its API + is almost identical to those two classes. It can also be converted to and + from those two, though there may be loss of information in some + conversions. + + \sa QCborValue, QCborMap, QJsonArray, QList, QVector + */ + +/*! + \typedef QCborArray::size_type + + A typedef to qsizetype. + */ + +/*! + \typedef QCborArray::difference_type + + A typedef to qsizetype. + */ + +/*! + \typedef QCborArray::value_type + + The type of values that can be held in a QCborArray: that is, QCborValue. + */ + +/*! + \typedef QCborArray::pointer + + A typedef to \c{QCborValue *}, for compatibility with generic algorithms. + */ + +/*! + \typedef QCborArray::const_pointer + + A typedef to \c{const QCborValue *}, for compatibility with generic algorithms. + */ + +/*! + \typedef QCborArray::reference + + A typedef to \c{QCborValue &}, for compatibility with generic algorithms. + */ + +/*! + \typedef QCborArray::const_reference + + A typedef to \c{const QCborValue &}, for compatibility with generic algorithms. + */ + +/*! + Constructs an empty QCborArray. + */ +QCborArray::QCborArray() noexcept + : d(nullptr) +{ +} + +/*! + Copies the contents of \a other into this object. + */ +QCborArray::QCborArray(const QCborArray &other) noexcept + : d(other.d) +{ +} + +/*! + \fn QCborArray::QCborArray(std::initializer_list<QCborValue> args) + + Initializes this QCborArray from the C++ brace-enclosed list found in \a + args, as in the following example: + + \code + QCborArray a = { null, 0, 1, 1.5, 2, "Hello", QByteArray("World") }; + \endcode + */ + +/*! + Destroys this QCborArray and frees any associated resources. + */ +QCborArray::~QCborArray() +{ +} + +/*! + Replaces the contents of this array with that found in \a other, then + returns a reference to this object. + */ +QCborArray &QCborArray::operator=(const QCborArray &other) noexcept +{ + d = other.d; + return *this; +} + +/*! + \fn void QCborArray::swap(QCborArray &other) + + Swaps the contents of this object and \a other. + */ + +/*! + \fn QCborValue QCborArray::toCborValue() const + + Explicitly construcuts a \l QCborValue object that represents this array. + This function is usually not necessary since QCborValue has a constructor + for QCborArray, so the conversion is implicit. + + Converting QCborArray to QCborValue allows it to be used in any context + where QCborValues can be used, including as items in QCborArrays and as keys + and mapped types in QCborMap. Converting an array to QCborValue allows + access to QCborValue::toCbor(). + + \sa QCborValue::QCborValue(const QCborArray &) + */ + +/*! + Returns the size of this array. + + \sa isEmpty() + */ +qsizetype QCborArray::size() const noexcept +{ + return d ? d->elements.size() : 0; +} + +/*! + Empties this array. + + \sa isEmpty() + */ +void QCborArray::clear() +{ + d.reset(); +} + +/*! + \fn bool QCborArray::isEmpty() const + + Returns true if this QCborArray is empty (that is if size() is 0). + + \sa size(), clear() + */ + +/*! + Returns the QCborValue element at position \a i in the array. + + If the array is smaller than \a i elements, this function returns a + QCborValue containing an undefined value. For that reason, it is not + possible with this function to tell apart the situation where the array is + not large enough from the case where the array starts with an undefined + value. + + \sa operator[](), first(), last(), insert(), prepend(), append(), + removeAt(), takeAt() + */ +QCborValue QCborArray::at(qsizetype i) const +{ + if (!d || size_t(i) >= size_t(size())) + return QCborValue(); + return d->valueAt(i); +} + +/*! + \fn QCborValue QCborArray::first() const + + Returns the first QCborValue of this array. + + If the array is empty, this function returns a QCborValue containing an + undefined value. For that reason, it is not possible with this function to + tell apart the situation where the array is not large enough from the case + where the array ends with an undefined value. + + \sa operator[](), at(), last(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn QCborValue QCborArray::last() const + + Returns the last QCborValue of this array. + + If the array is empty, this function returns a QCborValue containing an + undefined value. For that reason, it is not possible with this function to + tell apart the situation where the array is not large enough from the case + where the array ends with an undefined value. + + \sa operator[](), at(), first(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn QCborValue QCborArray::operator[](qsizetype i) const + + Returns the QCborValue element at position \a i in the array. + + If the array is smaller than \a i elements, this function returns a + QCborValue containing an undefined value. For that reason, it is not + possible with this function to tell apart the situation where the array is + not large enough from the case where the array contains an undefined value + at position \a i. + + \sa at(), first(), last(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn QCborValueRef QCborArray::first() + + Returns a reference to the first QCborValue of this array. The array must + not be empty. + + QCborValueRef has the exact same API as \l QCborValue, with one important + difference: if you assign new values to it, this map will be updated with + that new value. + + \sa operator[](), at(), last(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn QCborValueRef QCborArray::last() + + Returns a reference to the last QCborValue of this array. The array must + not be empty. + + QCborValueRef has the exact same API as \l QCborValue, with one important + difference: if you assign new values to it, this map will be updated with + that new value. + + \sa operator[](), at(), first(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn QCborValueRef QCborArray::operator[](qsizetype i) + + Returns a reference to the QCborValue element at position \a i in the + array. The array must have at least \a i elements. + + QCborValueRef has the exact same API as \l QCborValue, with one important + difference: if you assign new values to it, this map will be updated with + that new value. + + \sa at(), first(), last(), insert(), prepend(), append(), + removeAt(), takeAt() + */ + +/*! + \fn void QCborArray::insert(qsizetype i, const QCborValue &value) + \fn void QCborArray::insert(qsizetype i, QCborValue &&value) + + Inserts \a value into the array at position \a i in this array. The array + must have at least \a i elements before the insertion. + + \sa at(), operator[](), first(), last(), prepend(), append(), + removeAt(), takeAt(), extract() + */ +void QCborArray::insert(qsizetype i, const QCborValue &value) +{ + Q_ASSERT(size_t(i) <= size_t(size()) || i == -1); + if (i < 0) + i = size(); + detach(qMax(i + 1, size())); + d->insertAt(i, value); +} + +void QCborArray::insert(qsizetype i, QCborValue &&value) +{ + Q_ASSERT(size_t(i) <= size_t(size()) || i == -1); + if (i < 0) + i = size(); + detach(qMax(i + 1, size())); + d->insertAt(i, value, QCborContainerPrivate::MoveContainer); + QCborContainerPrivate::resetValue(value); +} + +/*! + \fn QCborValue QCborArray::extract(Iterator it) + \fn QCborValue QCborArray::extract(ConstIterator it) + + Extracts a value from the array at the position indicated by iterator \a it + and returns the value so extracted. + + \sa insert(), erase(), takeAt(), removeAt() + */ +QCborValue QCborArray::extract(iterator it) +{ + detach(); + + QCborValue v = d->extractAt(it.item.i); + d->removeAt(it.item.i); + return v; +} + +/*! + \fn void QCborArray::prepend(const QCborValue &value) + \fn void QCborArray::prepend(QCborValue &&value) + + Prepends \a value into the array before any other elements it may already + contain. + + \sa at(), operator[](), first(), last(), insert(), append(), + removeAt(), takeAt() + */ + +/*! + \fn void QCborArray::append(const QCborValue &value) + \fn void QCborArray::append(QCborValue &&value) + + Appends \a value into the array after all other elements it may already + contain. + + \sa at(), operator[](), first(), last(), insert(), prepend(), + removeAt(), takeAt() + */ + +/*! + Removes the item at position \a i from the array. The array must have more + than \a i elements before the removal. + + \sa takeAt(), removeFirst(), removeLast(), at(), operator[](), insert(), + prepend(), append() + */ +void QCborArray::removeAt(qsizetype i) +{ + detach(size()); + d->removeAt(i); +} + +/*! + \fn QCborValue QCborArray::takeAt(qsizetype i) + + Removes the item at position \a i from the array and returns it. The array + must have more than \a i elements before the removal. + + \sa removeAt(), removeFirst(), removeLast(), at(), operator[](), insert(), + prepend(), append() + */ + +/*! + \fn void QCborArray::removeFirst() + + Removes the first item in the array, making the second element become the + first. The array must not be empty before this call. + + \sa removeAt(), takeFirst(), removeLast(), at(), operator[](), insert(), + prepend(), append() + */ + +/*! + \fn void QCborArray::removeLast() + + Removes the last item in the array. The array must not be empty before this + call. + + \sa removeAt(), takeLast(), removeFirst(), at(), operator[](), insert(), + prepend(), append() + */ + +/*! + \fn void QCborArray::takeFirst() + + Removes the first item in the array and returns it, making the second + element become the first. The array must not be empty before this call. + + \sa takeAt(), removeFirst(), removeLast(), at(), operator[](), insert(), + prepend(), append() + */ + +/*! + \fn void QCborArray::takeLast() + + Removes the last item in the array and returns it. The array must not be + empty before this call. + + \sa takeAt(), removeLast(), removeFirst(), at(), operator[](), insert(), + prepend(), append() + */ + +/*! + Returns true if this array contains an element that is equal to \a value. + */ +bool QCborArray::contains(const QCborValue &value) const +{ + for (qsizetype i = 0; i < size(); ++i) { + int cmp = d->compareElement(i, value); + if (cmp == 0) + return true; + } + return false; +} + +/*! + \fn int QCborArray::compare(const QCborArray &other) const + + Compares this array and \a other, comparing each element in sequence, and + returns an integer that indicates whether this array should be sorted + before (if the result is negative) or after \a other (if the result is + positive). If this function returns 0, the two arrays are equal and contain + the same elements. + + For more information on CBOR sorting order, see QCborValue::compare(). + + \sa QCborValue::compare(), QCborMap::compare(), operator==() + */ + +/*! + \fn bool QCborArray::operator==(const QCborArray &other) const + + Compares this array and \a other, comparing each element in sequence, and + returns true if both arrays contains the same elements, false otherwise. + + For more information on CBOR equality in Qt, see, QCborValue::compare(). + + \sa compare(), QCborValue::operator==(), QCborMap::operator==(), + operator!=(), operator<() + */ + +/*! + \fn bool QCborArray::operator!=(const QCborArray &other) const + + Compares this array and \a other, comparing each element in sequence, and + returns true if the two arrays' contents are different, false otherwise. + + For more information on CBOR equality in Qt, see, QCborValue::compare(). + + \sa compare(), QCborValue::operator==(), QCborMap::operator==(), + operator==(), operator<() + */ + +/*! + \fn bool QCborArray::operator<(const QCborArray &other) const + + Compares this array and \a other, comparing each element in sequence, and + returns true if this array should be sorted before \a other, false + otherwise. + + For more information on CBOR sorting order, see QCborValue::compare(). + + \sa compare(), QCborValue::operator==(), QCborMap::operator==(), + operator==(), operator!=() + */ + +/*! + \typedef QCborArray::iterator + + A synonym to QCborArray::Iterator. + */ + +/*! + \typedef QCborArray::const_iterator + + A synonym to QCborArray::ConstIterator. + */ + +/*! + \fn QCborArray::iterator QCborArray::begin() + + Returns an array iterator pointing to the first item in this array. If the + array is empty, then this function returns the same as end(). + + \sa constBegin(), end() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::begin() const + + Returns an array iterator pointing to the first item in this array. If the + array is empty, then this function returns the same as end(). + + \sa constBegin(), constEnd() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::cbegin() const + + Returns an array iterator pointing to the first item in this array. If the + array is empty, then this function returns the same as end(). + + \sa constBegin(), constEnd() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::constBegin() const + + Returns an array iterator pointing to the first item in this array. If the + array is empty, then this function returns the same as end(). + + \sa begin(), constEnd() + */ + +/*! + \fn QCborArray::iterator QCborArray::end() + + Returns an array iterator pointing to just after the last element in this + array. + + \sa begin(), constEnd() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::end() const + + Returns an array iterator pointing to just after the last element in this + array. + + \sa constBegin(), constEnd() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::cend() const + + Returns an array iterator pointing to just after the last element in this + array. + + \sa constBegin(), constEnd() + */ + +/*! + \fn QCborArray::const_iterator QCborArray::constEnd() const + + Returns an array iterator pointing to just after the last element in this + array. + + \sa constBegin(), end() + */ + +/*! + \fn QCborArray::iterator QCborArray::insert(iterator before, const QCborValue &value) + \fn QCborArray::iterator QCborArray::insert(const_iterator before, const QCborValue &value) + \overload + + Inserts \a value into this array before element \a before and returns an + array iterator pointing to the just-inserted element. + + \sa erase(), removeAt(), prepend(), append() + */ + +/*! + \fn QCborArray::iterator QCborArray::erase(iterator it) + \fn QCborArray::iterator QCborArray::erase(const_iterator it) + + Removes the element pointed to by the array iterator \a it from this array, + then returns an iterator to the next element (the one that took the same + position in the array that \a it used to occupy). + + \sa insert(), removeAt(), takeAt(), takeFirst(), takeLast() + */ + +/*! + \fn void QCborArray::push_back(const QCborValue &t) + + Synonym for append(). This function is provided for compatibility with + generic code that uses the Standard Library API. + + Appends the element \a t to this array. + + \sa append(), push_front(), pop_back(), prepend(), insert() + */ + +/*! + \fn void QCborArray::push_front(const QCborValue &t) + + Synonym for prepend(). This function is provided for compatibility with + generic code that uses the Standard Library API. + + Prepends the element \a t to this array. + + \sa prepend(), push_back(), pop_front(), append(), insert() + */ + +/*! + \fn void QCborArray::pop_front() + + Synonym for removeFirst(). This function is provided for compatibility with + generic code that uses the Standard Library API. + + Removes the first element of this array. The array must not be empty before + the removal + + \sa removeFirst(), takeFirst(), pop_back(), push_front(), prepend(), insert() + */ + +/*! + \fn void QCborArray::pop_back() + + Synonym for removeLast(). This function is provided for compatibility with + generic code that uses the Standard Library API. + + Removes the last element of this array. The array must not be empty before + the removal + + \sa removeLast(), takeLast(), pop_front(), push_back(), append(), insert() + */ + +/*! + \fn bool QCborArray::empty() const + + Synonym for isEmpty(). This function is provided for compatibility with + generic code that uses the Standard Library API. + + Returns true if this array is empty (size() == 0). + + \sa isEmpty(), size() + */ + +/*! + \fn QCborArray QCborArray::operator+(const QCborValue &v) const + + Returns a new QCborArray containing the same elements as this array, plus + \a v appended as the last element. + + \sa operator+=(), operator<<(), append() + */ + +/*! + \fn QCborArray &QCborArray::operator+=(const QCborValue &v) + + Appends \a v to this array and returns a reference to this array. + + \sa append(), insert(), operator+(), operator<<() + */ + +/*! + \fn QCborArray &QCborArray::operator<<(const QCborValue &v) + + Appends \a v to this array and returns a reference to this array. + + \sa append(), insert(), operator+(), operator+=() + */ + +void QCborArray::detach(qsizetype reserved) +{ + d = QCborContainerPrivate::detach(d.data(), reserved ? reserved : size()); +} + +/*! + \class QCborArray::Iterator + \inmodule QtCore + \ingroup cbor + \since 5.12 + + \brief The QCborArray::Iterator class provides an STL-style non-const iterator for QCborArray. + + QCborArray::Iterator allows you to iterate over a QCborArray and to modify + the array item associated with the iterator. If you want to iterate over a + const QCborArray, use QCborArray::ConstIterator instead. It is generally a + good practice to use QCborArray::ConstIterator on a non-const QCborArray as + well, unless you need to change the QCborArray through the iterator. Const + iterators are slightly faster and improve code readability. + + Iterators are initialized by using a QCborArray function like + QCborArray::begin(), QCborArray::end(), or QCborArray::insert(). Iteration + is only possible after that. + + Most QCborArray functions accept an integer index rather than an iterator. + For that reason, iterators are rarely useful in connection with QCborArray. + 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 QCborArray will render all + existing iterators undefined. + + \sa QCborArray::ConstIterator +*/ + +/*! + \typedef QCborArray::Iterator::iterator_category + + A synonym for \e {std::random_access_iterator_tag} indicating this iterator + is a random access iterator. + */ + +/*! + \typedef QCborArray::Iterator::difference_type + \internal +*/ + +/*! + \typedef QCborArray::Iterator::value_type + \internal +*/ + +/*! + \typedef QCborArray::Iterator::reference + \internal +*/ + +/*! + \typedef QCborArray::Iterator::pointer + \internal +*/ + +/*! + \fn QCborArray::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 QCborArray::begin(), QCborArray::end() +*/ + +/*! + \fn QCborArray::Iterator::Iterator(const Iterator &other) + + Makes a copy of \a other. + */ + +/*! + \fn QCborArray::Iterator &QCborArray::Iterator::operator=(const Iterator &other) + + Makes this iterator a copy of \a other and returns a reference to this iterator. + */ + +/*! + \fn QCborValueRef QCborArray::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 QCborValueRef, a helper class for QCborArray + and QCborMap. When you get an object of type QCborValueRef, you can use it + as if it were a reference to a QCborValue. If you assign to it, the + assignment will apply to the element in the QCborArray or QCborMap from + which you got the reference. +*/ + +/*! + \fn QCborValueRef *QCborArray::Iterator::operator->() const + + Returns a pointer to a modifiable reference to the current item. +*/ + +/*! + \fn QCborValueRef QCborArray::Iterator::operator[](qsizetype j) + + Returns a modifiable reference to the item at a position \a j steps forward + from the item pointed to by this iterator. + + This function is provided to make QCborArray iterators behave like C++ + pointers. + + The return value is of type QCborValueRef, a helper class for QCborArray + and QCborMap. When you get an object of type QCborValueRef, you can use it + as if it were a reference to a QCborValue. If you assign to it, the + assignment will apply to the element in the QCborArray or QCborMap from + which you got the reference. + + \sa operator+() +*/ + +/*! + \fn bool QCborArray::Iterator::operator==(const Iterator &other) const + \fn bool QCborArray::Iterator::operator==(const ConstIterator &other) const + + Returns \c true if \a other points to the same entry in the array as this + iterator; otherwise returns \c false. + + \sa operator!=() +*/ + +/*! + \fn bool QCborArray::Iterator::operator!=(const Iterator &other) const + \fn bool QCborArray::Iterator::operator!=(const ConstIterator &other) const + + Returns \c true if \a other points to a different entry in the array than + this iterator; otherwise returns \c false. + + \sa operator==() +*/ + +/*! + \fn bool QCborArray::Iterator::operator<(const Iterator& other) const + \fn bool QCborArray::Iterator::operator<(const ConstIterator& other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs before the entry pointed to by the \a other iterator. +*/ + +/*! + \fn bool QCborArray::Iterator::operator<=(const Iterator& other) const + \fn bool QCborArray::Iterator::operator<=(const ConstIterator& other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs before or is the same entry as is pointed to by the \a other + iterator. +*/ + +/*! + \fn bool QCborArray::Iterator::operator>(const Iterator& other) const + \fn bool QCborArray::Iterator::operator>(const ConstIterator& other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs after the entry pointed to by the \a other iterator. + */ + +/*! + \fn bool QCborArray::Iterator::operator>=(const Iterator& other) const + \fn bool QCborArray::Iterator::operator>=(const ConstIterator& other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs after or is the same entry as is pointed to by the \a other + iterator. +*/ + +/*! + \fn QCborArray::Iterator &QCborArray::Iterator::operator++() + + The prefix ++ operator, \c{++it}, advances the iterator to the next item in + the array and returns this iterator. + + Calling this function on QCborArray::end() leads to undefined results. + + \sa operator--() +*/ + +/*! + \fn QCborArray::Iterator QCborArray::Iterator::operator++(int) + \overload + + The postfix ++ operator, \c{it++}, advances the iterator to the next item + in the array and returns an iterator to the previously current item. +*/ + +/*! + \fn QCborArray::Iterator &QCborArray::Iterator::operator--() + + The prefix -- operator, \c{--it}, makes the preceding item current and + returns this iterator. + + Calling this function on QCborArray::begin() leads to undefined results. + + \sa operator++() +*/ + +/*! + \fn QCborArray::Iterator QCborArray::Iterator::operator--(int) + \overload + + The postfix -- operator, \c{it--}, makes the preceding item current and + returns an iterator to the previously current item. +*/ + +/*! + \fn QCborArray::Iterator &QCborArray::Iterator::operator+=(qsizetype j) + + Advances the iterator by \a j positions. If \a j is negative, the iterator + goes backward. Returns a reference to this iterator. + + \sa operator-=(), operator+() +*/ + +/*! + \fn QCborArray::Iterator &QCborArray::Iterator::operator-=(qsizetype j) + + Makes the iterator go back by \a j positions. If \a j is negative, the + iterator goes forward. Returns a reference to this iterator. + + \sa operator+=(), operator-() +*/ + +/*! + \fn QCborArray::Iterator QCborArray::Iterator::operator+(qsizetype j) const + + Returns an iterator to the item at position \a j steps forward from this + iterator. If \a j is negative, the iterator goes backward. + + \sa operator-(), operator+=() +*/ + +/*! + \fn QCborArray::Iterator QCborArray::Iterator::operator-(qsizetype j) const + + Returns an iterator to the item at position \a j steps backward from this + iterator. If \a j is negative, the iterator goes forward. + + \sa operator+(), operator-=() +*/ + +/*! + \fn qsizetype QCborArray::Iterator::operator-(Iterator other) const + + Returns the offset of this iterator relative to \a other. +*/ + +/*! + \class QCborArray::ConstIterator + \inmodule QtCore + \ingroup cbor + \since 5.12 + + \brief The QCborArray::ConstIterator class provides an STL-style const iterator for QCborArray. + + QCborArray::ConstIterator allows you to iterate over a QCborArray. If you + want to modify the QCborArray as you iterate over it, use + QCborArray::Iterator instead. It is generally good practice to use + QCborArray::ConstIterator, even on a non-const QCborArray, when you don't + need to change the QCborArray through the iterator. Const iterators are + slightly faster and improves code readability. + + Iterators are initialized by using a QCborArray function like + QCborArray::begin() or QCborArray::end(). Iteration is only possible after + that. + + Most QCborArray functions accept an integer index rather than an iterator. + For that reason, iterators are rarely useful in connection with QCborArray. + 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 QCborArray will render all + existing iterators undefined. + + \sa QCborArray::Iterator +*/ + +/*! + \fn QCborArray::ConstIterator::ConstIterator() + + 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 QCborArray::constBegin(), QCborArray::constEnd() +*/ + +/*! + \fn QCborArray::ConstIterator &QCborArray::ConstIterator::operator=(const ConstIterator &other) + + Makes this iterator a copy of \a other and returns a reference to this iterator. +*/ + +/*! + \typedef QCborArray::ConstIterator::iterator_category + + A synonym for \e {std::random_access_iterator_tag} indicating this iterator + is a random access iterator. +*/ + +/*! + \typedef QCborArray::ConstIterator::difference_type + \internal +*/ + +/*! + \typedef QCborArray::ConstIterator::value_type + \internal +*/ + +/*! + \typedef QCborArray::ConstIterator::reference + \internal +*/ + +/*! + \typedef QCborArray::ConstIterator::pointer + \internal +*/ + +/*! + \fn QCborArray::ConstIterator::ConstIterator(const ConstIterator &other) + + Constructs a copy of \a other. +*/ + +/*! + \fn QCborValue QCborArray::ConstIterator::operator*() const + + Returns the current item. +*/ + +/*! + \fn const QCborValue *QCborArray::ConstIterator::operator->() const + + Returns a pointer to the current item. +*/ + +/*! + \fn const QCborValueRef QCborArray::ConstIterator::operator[](qsizetype j) + + Returns the item at a position \a j steps forward from the item pointed to + by this iterator. + + This function is provided to make QCborArray iterators behave like C++ + pointers. + + \sa operator+() +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator==(const Iterator &other) const + \fn bool QCborArray::ConstIterator::operator==(const ConstIterator &other) const + + Returns \c true if \a other points to the same entry in the array as this + iterator; otherwise returns \c false. + + \sa operator!=() +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator!=(const Iterator &o) const + \fn bool QCborArray::ConstIterator::operator!=(const ConstIterator &o) const + + Returns \c true if \a o points to a different entry in the array than + this iterator; otherwise returns \c false. + + \sa operator==() +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator<(const Iterator &other) const + \fn bool QCborArray::ConstIterator::operator<(const ConstIterator &other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs before the entry pointed to by the \a other iterator. +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator<=(const Iterator &other) const + \fn bool QCborArray::ConstIterator::operator<=(const ConstIterator &other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs before or is the same entry as is pointed to by the \a other + iterator. +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator>(const Iterator &other) const + \fn bool QCborArray::ConstIterator::operator>(const ConstIterator &other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs after the entry pointed to by the \a other iterator. +*/ + +/*! + \fn bool QCborArray::ConstIterator::operator>=(const Iterator &other) const + \fn bool QCborArray::ConstIterator::operator>=(const ConstIterator &other) const + + Returns \c true if the entry in the array pointed to by this iterator + occurs after or is the same entry as is pointed to by the \a other + iterator. +*/ + +/*! + \fn QCborArray::ConstIterator &QCborArray::ConstIterator::operator++() + + The prefix ++ operator, \c{++it}, advances the iterator to the next item in + the array and returns this iterator. + + Calling this function on QCborArray::end() leads to undefined results. + + \sa operator--() +*/ + +/*! + \fn QCborArray::ConstIterator QCborArray::ConstIterator::operator++(int) + \overload + + The postfix ++ operator, \c{it++}, advances the iterator to the next item + in the array and returns an iterator to the previously current item. +*/ + +/*! + \fn QCborArray::ConstIterator &QCborArray::ConstIterator::operator--() + + The prefix -- operator, \c{--it}, makes the preceding item current and + returns this iterator. + + Calling this function on QCborArray::begin() leads to undefined results. + + \sa operator++() +*/ + +/*! + \fn QCborArray::ConstIterator QCborArray::ConstIterator::operator--(int) + \overload + + The postfix -- operator, \c{it--}, makes the preceding item current and + returns an iterator to the previously current item. +*/ + +/*! + \fn QCborArray::ConstIterator &QCborArray::ConstIterator::operator+=(qsizetype j) + + Advances the iterator by \a j positions. If \a j is negative, the iterator + goes backward. Returns a reference to this iterator. + + \sa operator-=(), operator+() +*/ + +/*! + \fn QCborArray::ConstIterator &QCborArray::ConstIterator::operator-=(qsizetype j) + + Makes the iterator go back by \a j positions. If \a j is negative, the + iterator goes forward. Returns a reference to this iterator. + + \sa operator+=(), operator-() +*/ + +/*! + \fn QCborArray::ConstIterator QCborArray::ConstIterator::operator+(qsizetype j) const + + Returns an iterator to the item at a position \a j steps forward from this + iterator. If \a j is negative, the iterator goes backward. + + \sa operator-(), operator+=() +*/ + +/*! + \fn QCborArray::ConstIterator QCborArray::ConstIterator::operator-(qsizetype j) const + + Returns an iterator to the item at a position \a j steps backward from this + iterator. If \a j is negative, the iterator goes forward. + + \sa operator+(), operator-=() +*/ + +/*! + \fn qsizetype QCborArray::ConstIterator::operator-(ConstIterator other) const + + Returns the offset of this iterator relative to \a other. +*/ + +uint qHash(const QCborArray &array, uint seed) +{ + return qHashRange(array.begin(), array.end(), seed); +} + +#if !defined(QT_NO_DEBUG_STREAM) +QDebug operator<<(QDebug dbg, const QCborArray &a) +{ + QDebugStateSaver saver(dbg); + dbg.nospace() << "QCborArray{"; + const char *comma = ""; + for (auto v : a) { + dbg << comma << v; + comma = ", "; + } + return dbg << '}'; +} +#endif + +QT_END_NAMESPACE |