Revision control
Copy as Markdown
// 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