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
++
++ #ifndef QSEQUENTIALITERABLE_H
++ #define QSEQUENTIALITERABLE_H
++
++ #include <QtCore/qiterable.h>
++ #include <QtCore/qvariant.h>
++
++ QT_BEGIN_NAMESPACE
++
++ #if QT_DEPRECATED_SINCE(6, 15)
++ QT_WARNING_PUSH
++ QT_WARNING_DISABLE_DEPRECATED
++
++ // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
++ class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialIterator : public QIterator<QMetaSequence>
++ {
++ public:
++ using value_type = QVariant;
++ using reference = QVariantRef<QSequentialIterator>;
++ using pointer = QVariantPointer<QSequentialIterator>;
++
++ QSequentialIterator(QIterator &&it)
++ : QIterator(std::move(it))
++ {}
++
++ QVariantRef<QSequentialIterator> operator*() const;
++ QVariantPointer<QSequentialIterator> operator->() const;
++ };
++
++ // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
++ class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialConstIterator : public QConstIterator<QMetaSequence>
++ {
++ public:
++ using value_type = QVariant;
++ using reference = const QVariant &;
++ using pointer = QVariantConstPointer;
++
++ QSequentialConstIterator(QConstIterator &&it)
++ : QConstIterator(std::move(it))
++ {}
++
++ QVariant operator*() const;
++ QVariantConstPointer operator->() const;
++ };
++
++ // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
++ class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialIterable : public QIterable<QMetaSequence>
++ {
++ public:
++ using iterator = QTaggedIterator<QSequentialIterator, void>;
++ using const_iterator = QTaggedIterator<QSequentialConstIterator, void>;
++
++ using RandomAccessIterator = QTaggedIterator<iterator, std::random_access_iterator_tag>;
++ using BidirectionalIterator = QTaggedIterator<iterator, std::bidirectional_iterator_tag>;
++ using ForwardIterator = QTaggedIterator<iterator, std::forward_iterator_tag>;
++ using InputIterator = QTaggedIterator<iterator, std::input_iterator_tag>;
++
++ using RandomAccessConstIterator = QTaggedIterator<const_iterator, std::random_access_iterator_tag>;
++ using BidirectionalConstIterator = QTaggedIterator<const_iterator, std::bidirectional_iterator_tag>;
++ using ForwardConstIterator = QTaggedIterator<const_iterator, std::forward_iterator_tag>;
++ using InputConstIterator = QTaggedIterator<const_iterator, std::input_iterator_tag>;
++
++ template<class T>
++ QSequentialIterable(const T *p)
++ : QIterable(QMetaSequence::fromContainer<T>(), p)
++ {
++ Q_UNUSED(m_revision);
++ }
++
++ template<class T>
++ QSequentialIterable(T *p)
++ : QIterable(QMetaSequence::fromContainer<T>(), p)
++ {
++ }
++
++ QSequentialIterable()
++ : QIterable(QMetaSequence(), nullptr)
++ {
++ }
++
++ template<typename Pointer>
++ QSequentialIterable(const QMetaSequence &metaSequence, Pointer iterable)
++ : QIterable(metaSequence, iterable)
++ {
++ }
++
++ QSequentialIterable(const QMetaSequence &metaSequence, const QMetaType &metaType,
++ void *iterable)
++ : QIterable(metaSequence, metaType.alignOf(), iterable)
++ {
++ }
++
++ QSequentialIterable(const QMetaSequence &metaSequence, const QMetaType &metaType,
++ const void *iterable)
++ : QIterable(metaSequence, metaType.alignOf(), iterable)
++ {
++ }
++
++ QSequentialIterable(QIterable<QMetaSequence> &&other) : QIterable(std::move(other)) {}
++
++ QSequentialIterable &operator=(QIterable<QMetaSequence> &&other)
++ {
++ QIterable::operator=(std::move(other));
++ return *this;
++ }
++
++ const_iterator begin() const { return constBegin(); }
++ const_iterator end() const { return constEnd(); }
++
++ const_iterator constBegin() const { return const_iterator(QIterable::constBegin()); }
++ const_iterator constEnd() const { return const_iterator(QIterable::constEnd()); }
++
++ iterator mutableBegin() { return iterator(QIterable::mutableBegin()); }
++ iterator mutableEnd() { return iterator(QIterable::mutableEnd()); }
++
++ QVariant at(qsizetype idx) const;
++ void set(qsizetype idx, const QVariant &value);
++
++ enum Position { Unspecified, AtBegin, AtEnd };
++ void addValue(const QVariant &value, Position position = Unspecified);
++ void removeValue(Position position = Unspecified);
++
++ QMetaType valueMetaType() const;
++
++ // Random access iteration is broken on QSequentialIterator.
++ // That's why this class is deprecated after all.
++ constexpr bool canRandomAccessIterate() const { return false; }
++ };
++
++ template<>
++ inline QVariantRef<QSequentialIterator>::operator QVariant() const
++ {
++ if (m_pointer == nullptr)
++ return QVariant();
++ const QMetaType metaType(m_pointer->metaContainer().valueMetaType());
++
++ return [&] {
++ QVariant v(metaType);
++ void *dataPtr = metaType == QMetaType::fromType<QVariant>() ? &v : v.data();
++ m_pointer->metaContainer().valueAtIterator(m_pointer->constIterator(), dataPtr);
++ return v;
++ }();
++ }
++
++ template<>
++ inline QVariantRef<QSequentialIterator> &QVariantRef<QSequentialIterator>::operator=(
++ const QVariant &value)
++ {
++ if (m_pointer == nullptr)
++ return *this;
++
++ QtPrivate::QVariantTypeCoercer coercer;
++ m_pointer->metaContainer().setValueAtIterator(
++ m_pointer->constIterator(),
++ coercer.coerce(value, m_pointer->metaContainer().valueMetaType()));
++ return *this;
++ }
++
++ Q_DECLARE_TYPEINFO(QSequentialIterable, Q_RELOCATABLE_TYPE);
++ Q_DECLARE_TYPEINFO(QSequentialIterable::iterator, Q_RELOCATABLE_TYPE);
++ Q_DECLARE_TYPEINFO(QSequentialIterable::const_iterator, Q_RELOCATABLE_TYPE);
++
++ QT_WARNING_POP
++ #endif // QT_DEPRECATED_SINCE(6, 15)
++
++ QT_END_NAMESPACE
++
++ #endif // QSEQUENTIALITERABLE_H