Revision control
++ // Copyright (C) 2020 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:significant reason:default
++
++ #include <QtCore/qiterable.h>
++ #include <QtCore/qloggingcategory.h>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_STATIC_LOGGING_CATEGORY(lcSynthesizedIterableAccess, "qt.iterable.synthesized", QtWarningMsg);
++
++ /*!
++ \class QBaseIterator
++ \inmodule QtCore
++ QBaseIterator\<Container\> forms the common base class for all iterators
++ operating on subclasses of QIterable, where \a Container is the meta-type
++ descriptor.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container>::QBaseIterator(const QIterable<Container> *iterable, void *iterator)
++
++ \internal
++ Creates a const QBaseIterator from an \a iterable and an \a iterator.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container>::QBaseIterator(QIterable<Container> *iterable, void *iterator)
++
++ \internal
++ Creates a non-const QBaseIterator from an \a iterable and an \a iterator.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container>::QBaseIterator(QBaseIterator<Container> &&other)
++
++ \internal
++ Move-constructs a QBaseIterator from \a other, preserving its const-ness.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container>::QBaseIterator(const QBaseIterator<Container> &other)
++
++ \internal
++ Copy-constructs a QBaseIterator from \a other, preserving its const-ness.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container>::~QBaseIterator()
++
++ \internal
++ Destroys a QBaseIterator.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator<Container> &QBaseIterator<Container>::operator=(const QBaseIterator<Container> &other)
++
++ \internal
++ Copy-assigns a QBaseIterator from \a other, preserving its const-ness.
++ */
++
++ /*!
++ \fn template<class Container> void QBaseIterator<Container>::initIterator(const void *copy)
++
++ \internal
++ Initializes the internal native iterator by duplicating \a copy, if given.
++ */
++
++ /*!
++ \fn template<class Container> void QBaseIterator<Container>::clearIterator()
++
++ \internal
++ Destroys the internal native iterator.
++ */
++
++
++ /*!
++ \fn QMetaContainer QBaseIterator<Container>::metaContainer() const
++
++ \internal
++ Returns the meta sequence.
++ */
++
++ /*!
++ \fn template<class Container> QIterable *QBaseIterator<Container>::mutableIterable() const
++
++ \internal
++ Returns a non-const pointer to the iterable, if the original iterable was
++ non-const. Otherwise returns nullptr.
++ */
++
++ /*!
++ \fn template<class Container> const QIterable *QBaseIterator<Container>::constIterable() const
++
++ \internal
++ Returns a const pointer to the iterable.
++ */
++
++ /*!
++ \fn template<class Container> void *QBaseIterator<Container>::mutableIterator()
++
++ Returns a non-const pointer to the internal native iterator.
++ */
++
++ /*!
++ \fn template<class Container> const void *QBaseIterator<Container>::constIterator() const
++
++ Returns a const pointer to the internal native iterator.
++ */
++
++ /*!
++ \fn template<class Container> QBaseIterator &QBaseIterator<Container>::operator=(QBaseIterator<Container> &&other)
++
++ \internal
++ Move-assigns a QBaseIterator from \a other, preserving its const-ness.
++ */
++
++ /*!
++ \class QIterator
++ \since 6.0
++ \inmodule QtCore
++ \brief The QIterator is a template class that allows iteration over a container in a QVariant.
++
++ QIterator\<Container\> provides mutable iteration over a container, where
++ \a Container is the meta-type descriptor (either QMetaSequence or
++ QMetaAssociation) that defines the container's iteration capabilities.
++
++ A QIterator can only be created by a QIterable instance, and can be used
++ in a way similar to other stl-style iterators. Generally, QIterator should
++ not be used directly, but through its derived classes provided by
++ QMetaSequence::Iterable and QMetaAssociation::Iterable.
++
++ \sa QIterable
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container>::QIterator(QIterable<Container> *iterable, void *iterator)
++
++ Creates an iterator from an \a iterable and a pointer to a native \a iterator.
++ */
++
++ /*!
++ \fn template<class Container> bool QIterator<Container>::operator==(const QIterator<Container> &other) const
++
++ Returns \c true if \a other points to the same item as this
++ iterator; otherwise returns \c false.
++
++ \sa operator!=()
++ */
++
++ /*!
++ \fn template<class Container> bool QIterator<Container>::operator!=(const QIterator<Container> &other) const
++
++ Returns \c true if \a other points to a different item than this
++ iterator; otherwise returns \c false.
++
++ \sa operator==()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> &QIterator<Container>::operator++()
++
++ The prefix \c{++} operator (\c{++it}) advances the iterator to the
++ next item in the container and returns an iterator to the new current
++ item.
++
++ Calling this function on QMetaSequence::Iterable::constEnd() leads to undefined results.
++
++ \sa operator--()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterator<Container>::operator++(int)
++ \overload
++
++ The postfix \c{++} operator (\c{it++}) advances the iterator to the
++ next item in the container and returns an iterator to the previously
++ current item.
++ */
++
++
++ /*!
++ \fn template<class Container> QIterator<Container> &QIterator<Container>::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 QMetaSequence::Iterable::constBegin() leads to undefined results.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator++(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterator<Container>::operator--(int)
++
++ \overload
++
++ The postfix \c{--} operator (\c{it--}) makes the preceding item
++ current and returns an iterator to the previously current item.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> &QIterator<Container>::operator+=(qsizetype j)
++
++ Advances the iterator by \a j items.
++
++ \sa operator-=(), operator+()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> &QIterator<Container>::operator-=(qsizetype j)
++
++ Makes the iterator go back by \a j items.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+=(), operator-(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterator<Container>::operator+(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions forward from
++ this iterator.
++
++ \sa operator-(), operator+=()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterator<Container>::operator-(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions backward from
++ this iterator.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> qsizetype QIterator<Container>::operator-(const QIterator<Container> &j) const
++ \overload
++
++ Returns the distance between the two iterators.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template <class Container> QIterator<Container> QIterator<Container>::operator+(qsizetype j, const QIterator<Container> &k)
++
++ Returns an iterator to the item at \a j positions forward from iterator \a k.
++ */
++
++ /*!
++ \struct QConstIterator
++ \since 6.0
++ \inmodule QtCore
++ \brief The QConstIterator allows iteration over a container in a QVariant.
++
++ QConstIterator\<Container\> provides const iteration over a container, where
++ \a Container is the meta-type descriptor (either QMetaSequence or
++ QMetaAssociation) that defines the container's iteration capabilities.
++
++ \sa QIterator, QIterable
++ */
++
++ /*!
++ \fn template <class Container> QConstIterator<Container>::QConstIterator(const QIterable<Container> *iterable, void *iterator)
++
++ Creates a QConstIterator to wrap \a iterator, operating on \a iterable.
++ */
++
++ /*!
++ \fn template<class Container> bool QConstIterator<Container>::operator==(const QConstIterator<Container> &other) const
++
++ Returns \c true if \a other points to the same item as this
++ iterator; otherwise returns \c false.
++
++ \sa operator!=()
++ */
++
++ /*!
++ \fn template<class Container> bool QConstIterator<Container>::operator!=(const QConstIterator<Container> &other) const
++
++ Returns \c true if \a other points to a different item than this
++ iterator; otherwise returns \c false.
++
++ \sa operator==()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> &QConstIterator<Container>::operator++()
++
++ The prefix \c{++} operator (\c{++it}) advances the iterator to the
++ next item in the container and returns an iterator to the new current
++ item.
++
++ Calling this function on QIterable<Container>::end() leads to undefined results.
++
++ \sa operator--()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QConstIterator<Container>::operator++(int)
++
++ \overload
++
++ The postfix \c{++} operator (\c{it++}) advances the iterator to the
++ next item in the container and returns an iterator to the previously
++ current item.
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> &QConstIterator<Container>::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 QIterable<Container>::begin() leads to undefined results.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator++(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QConstIterator<Container>::operator--(int)
++
++ \overload
++
++ The postfix \c{--} operator (\c{it--}) makes the preceding item
++ current and returns an iterator to the previously current item.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> &QConstIterator<Container>::operator+=(qsizetype j)
++
++ Advances the iterator by \a j items.
++
++ \sa operator-=(), operator+()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> &QConstIterator<Container>::operator-=(qsizetype j)
++
++ Makes the iterator go back by \a j items.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+=(), operator-(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QConstIterator<Container>::operator+(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions forward from
++ this iterator.
++
++ \sa operator-(), operator+=()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QConstIterator<Container>::operator-(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions backward from
++ this iterator.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template <class Container> qsizetype QConstIterator<Container>::operator-(const QConstIterator<Container> &j) const
++
++ \overload
++
++ Returns the distance between the two iterators.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \class QIterable
++ \inmodule QtCore
++ \since 6.0
++ \brief QIterable is a template class that is the base class for QMetaSequence::Iterable and QMetaAssociation::Iterable.
++
++ QIterable\<Container\> provides a common interface for iterating over
++ containers through QVariant, where \a Container is the meta-type descriptor
++ (either QMetaSequence or QMetaAssociation) that defines the container's
++ iteration capabilities.
++ */
++
++ /*!
++ \fn template <class Container> bool QIterable<Container>::canInputIterate() const
++
++ Returns whether the container has an input iterator. This corresponds to
++ the std::input_iterator_tag iterator trait of the iterator and
++ const_iterator of the container.
++ */
++
++ /*!
++ \fn template<class Container> bool QIterable<Container>::canForwardIterate() const
++
++ Returns whether it is possible to iterate over the container in forward
++ direction. This corresponds to the std::forward_iterator_tag iterator trait
++ of the iterator and const_iterator of the container.
++ */
++
++ /*!
++ \fn template<class Container> bool QIterable<Container>::canReverseIterate() const
++
++ Returns whether it is possible to iterate over the container in reverse. This
++ corresponds to the std::bidirectional_iterator_tag iterator trait of the
++ const_iterator of the container.
++ */
++
++ /*!
++ \fn template<class Container> bool QIterable<Container>::canRandomAccessIterate() const
++
++ Returns whether it is possible to efficiently skip over multiple values
++ using and iterator. This corresponds to the std::random_access_iterator_tag
++ iterator trait of the iterator and const_iterator of the container.
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QIterable<Container>::constBegin() const
++
++ Returns a QConstIterator for the beginning of the container. This
++ can be used in stl-style iteration.
++
++ \sa constEnd(), mutableBegin()
++ */
++
++ /*!
++ \fn template<class Container> QConstIterator<Container> QIterable<Container>::constEnd() const
++
++ Returns a Qterable::QConstIterator for the end of the container. This
++ can be used in stl-style iteration.
++
++ \sa constBegin(), mutableEnd()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterable<Container>::mutableBegin()
++
++ Returns a QIterator for the beginning of the container. This
++ can be used in stl-style iteration.
++
++ \sa mutableEnd(), constBegin()
++ */
++
++ /*!
++ \fn template<class Container> QIterator<Container> QIterable<Container>::mutableEnd()
++
++ Returns a QMetaSequence::Iterable::iterator for the end of the container. This
++ can be used in stl-style iteration.
++
++ \sa mutableBegin(), constEnd()
++ */
++
++ /*!
++ \fn template<class Container> qsizetype QIterable<Container>::size() const
++
++ Returns the number of values in the container.
++
++ \note If the underlying container does not provide a native way to query
++ the size, this method will synthesize the access using iterators.
++ This behavior is deprecated and will be removed in a future version
++ of Qt.
++ */
++
++ /*!
++ \fn template<class Container> void QIterable<Container>::clear()
++
++ Clears the container.
++ */
++
++ /*!
++ \class QTaggedIterator
++ \since 6.0
++ \inmodule QtCore
++ \brief QTaggedIterator is a template class that wraps an iterator and exposes standard iterator traits.
++
++ QTaggedIterator\<Iterator, IteratorCategory\> wraps an iterator, where
++ \a Iterator is the underlying iterator type (such as QIterator or
++ QConstIterator) and \a IteratorCategory is a standard iterator category tag
++ (such as std::forward_iterator_tag or std::random_access_iterator_tag).
++
++ In order to use an iterator any of the standard algorithms, its iterator
++ traits need to be known. As QMetaSequence::Iterable can work with many different
++ kinds of containers, we cannot declare the traits in the iterator classes
++ themselves. A QTaggedIterator gives you a way to explicitly declare a trait for
++ a concrete instance of an iterator or QConstIterator.
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::QTaggedIterator(Iterator &&it)
++
++ Constructs a QTaggedIterator from an iterator or QConstIterator \a it. Checks
++ whether the IteratorCategory passed as template argument matches the run
++ time capabilities of \a it; if there's no match, \a it is refused.
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> bool QTaggedIterator<Iterator, IteratorCategory>::operator==(const QTaggedIterator<Iterator, IteratorCategory> &other) const
++
++ Returns \c true if \a other points to the same item as this
++ iterator; otherwise returns \c false.
++
++ \sa operator!=()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> bool QTaggedIterator<Iterator, IteratorCategory>::operator!=(const QTaggedIterator<Iterator, IteratorCategory> &other) const
++
++ Returns \c true if \a other points to a different item than this
++ iterator; otherwise returns \c false.
++
++ \sa operator==()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> &QTaggedIterator<Iterator, IteratorCategory>::operator++()
++
++ The prefix \c{++} operator (\c{++it}) advances the iterator to the
++ next item in the container and returns an iterator to the new current
++ item.
++
++ Calling this function on QMetaSequence::Iterable::constEnd() leads to undefined results.
++
++ \sa operator--()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::operator++(int)
++ \overload
++
++ The postfix \c{++} operator (\c{it++}) advances the iterator to the
++ next item in the container and returns an iterator to the previously
++ current item.
++ */
++
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> &QTaggedIterator<Iterator, IteratorCategory>::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 QMetaSequence::Iterable::constBegin() leads to undefined results.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator++(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::operator--(int)
++ \overload
++
++ The postfix \c{--} operator (\c{it--}) makes the preceding item
++ current and returns an iterator to the previously current item.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa QIterable::canReverseIterate()
++ */
++
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> &QTaggedIterator<Iterator, IteratorCategory>::operator+=(qsizetype j)
++
++ Advances the iterator by \a j items.
++
++ \sa operator-=(), operator+()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> &QTaggedIterator<Iterator, IteratorCategory>::operator-=(qsizetype j)
++
++ Makes the iterator go back by \a j items.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+=(), operator-(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::operator+(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions forward from
++ this iterator.
++
++ \sa operator-(), operator+=()
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::operator+(qsizetype j, const QTaggedIterator &k)
++
++ Returns an iterator to the item at \a j positions forward from iterator \a k.
++ */
++
++ /*!
++ \fn template<class Iterator, typename IteratorCategory> QTaggedIterator<Iterator, IteratorCategory> QTaggedIterator<Iterator, IteratorCategory>::operator-(qsizetype j) const
++
++ Returns an iterator to the item at \a j positions backward from
++ this iterator.
++
++ If the container in the QVariant does not support bi-directional iteration, calling this function
++ leads to undefined results.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \fn template <class Iterator, typename IteratorCategory> qsizetype QTaggedIterator<Iterator, IteratorCategory>::operator-(const QTaggedIterator<Iterator, IteratorCategory> &j) const
++
++ Returns the distance between this iterator and \a j.
++
++ \sa operator+(), operator-=(), QIterable::canReverseIterate()
++ */
++
++ /*!
++ \internal
++ */
++ void QtPrivate::warnSynthesizedIterableAccess(QtPrivate::SynthesizedAccessFunction function)
++ {
++ switch (function) {
++ case QtPrivate::SynthesizedAccessFunction::IterableSize:
++ qCWarning(lcSynthesizedIterableAccess,
++ "size() called on an iterable without native size accessor. This is slow");
++ break;
++ case QtPrivate::SynthesizedAccessFunction::SequenceAt:
++ qCWarning(lcSynthesizedIterableAccess,
++ "at() called on an iterable without native indexed accessors. This is slow");
++ break;
++ }
++ }
++
++ QT_END_NAMESPACE