include/QtCore/qsequentialiterable.h

0001 // Copyright (C) 2020 The Qt Company Ltd.
0002 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0003 // Qt-Security score:significant reason:default
0004
0005 #ifndef QSEQUENTIALITERABLE_H
0006 #define QSEQUENTIALITERABLE_H
0007
0008 #include <QtCore/qiterable.h>
0009 #include <QtCore/qvariant.h>
0010
0011 QT_BEGIN_NAMESPACE
0012
0013 #if QT_DEPRECATED_SINCE(6, 15)
0014 QT_WARNING_PUSH
0015 QT_WARNING_DISABLE_DEPRECATED
0016
0017 // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
0018 class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialIterator : public QIterator<QMetaSequence>
0019 {
0020 public:
0021     using value_type = QVariant;
0022     using reference = QVariantRef<QSequentialIterator>;
0023     using pointer = QVariantPointer<QSequentialIterator>;
0024
0025     QSequentialIterator(QIterator &&it)
0026         : QIterator(std::move(it))
0027     {}
0028
0029     QVariantRef<QSequentialIterator> operator*() const;
0030     QVariantPointer<QSequentialIterator> operator->() const;
0031 };
0032
0033 // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
0034 class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialConstIterator : public QConstIterator<QMetaSequence>
0035 {
0036 public:
0037     using value_type = QVariant;
0038     using reference = const QVariant &;
0039     using pointer = QVariantConstPointer;
0040
0041     QSequentialConstIterator(QConstIterator &&it)
0042         : QConstIterator(std::move(it))
0043     {}
0044
0045     QVariant operator*() const;
0046     QVariantConstPointer operator->() const;
0047 };
0048
0049 // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
0050 class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaSequence's iterables and iterators instead.") QSequentialIterable : public QIterable<QMetaSequence>
0051 {
0052 public:
0053     using iterator = QTaggedIterator<QSequentialIterator, void>;
0054     using const_iterator = QTaggedIterator<QSequentialConstIterator, void>;
0055
0056     using RandomAccessIterator = QTaggedIterator<iterator, std::random_access_iterator_tag>;
0057     using BidirectionalIterator = QTaggedIterator<iterator, std::bidirectional_iterator_tag>;
0058     using ForwardIterator = QTaggedIterator<iterator, std::forward_iterator_tag>;
0059     using InputIterator = QTaggedIterator<iterator, std::input_iterator_tag>;
0060
0061     using RandomAccessConstIterator = QTaggedIterator<const_iterator, std::random_access_iterator_tag>;
0062     using BidirectionalConstIterator = QTaggedIterator<const_iterator, std::bidirectional_iterator_tag>;
0063     using ForwardConstIterator = QTaggedIterator<const_iterator, std::forward_iterator_tag>;
0064     using InputConstIterator = QTaggedIterator<const_iterator, std::input_iterator_tag>;
0065
0066     template<class T>
0067     QSequentialIterable(const T *p)
0068         : QIterable(QMetaSequence::fromContainer<T>(), p)
0069     {
0070         Q_UNUSED(m_revision);
0071     }
0072
0073     template<class T>
0074     QSequentialIterable(T *p)
0075         : QIterable(QMetaSequence::fromContainer<T>(), p)
0076     {
0077     }
0078
0079     QSequentialIterable()
0080         : QIterable(QMetaSequence(), nullptr)
0081     {
0082     }
0083
0084     template<typename Pointer>
0085     QSequentialIterable(const QMetaSequence &metaSequence, Pointer iterable)
0086         : QIterable(metaSequence, iterable)
0087     {
0088     }
0089
0090     QSequentialIterable(const QMetaSequence &metaSequence, const QMetaType &metaType,
0091                         void *iterable)
0092         : QIterable(metaSequence, metaType.alignOf(), iterable)
0093     {
0094     }
0095
0096     QSequentialIterable(const QMetaSequence &metaSequence, const QMetaType &metaType,
0097                         const void *iterable)
0098         : QIterable(metaSequence, metaType.alignOf(), iterable)
0099     {
0100     }
0101
0102     QSequentialIterable(QIterable<QMetaSequence> &&other) : QIterable(std::move(other)) {}
0103
0104     QSequentialIterable &operator=(QIterable<QMetaSequence> &&other)
0105     {
0106         QIterable::operator=(std::move(other));
0107         return *this;
0108     }
0109
0110     const_iterator begin() const { return constBegin(); }
0111     const_iterator end() const { return constEnd(); }
0112
0113     const_iterator constBegin() const { return const_iterator(QIterable::constBegin()); }
0114     const_iterator constEnd() const { return const_iterator(QIterable::constEnd()); }
0115
0116     iterator mutableBegin() { return iterator(QIterable::mutableBegin()); }
0117     iterator mutableEnd() { return iterator(QIterable::mutableEnd()); }
0118
0119     QVariant at(qsizetype idx) const;
0120     void set(qsizetype idx, const QVariant &value);
0121
0122     enum Position { Unspecified, AtBegin, AtEnd };
0123     void addValue(const QVariant &value, Position position = Unspecified);
0124     void removeValue(Position position = Unspecified);
0125
0126     QMetaType valueMetaType() const;
0127
0128     // Random access iteration is broken on QSequentialIterator.
0129     // That's why this class is deprecated after all.
0130     constexpr bool canRandomAccessIterate() const { return false; }
0131 };
0132
0133 template<>
0134 inline QVariantRef<QSequentialIterator>::operator QVariant() const
0135 {
0136     if (m_pointer == nullptr)
0137         return QVariant();
0138     const QMetaType metaType(m_pointer->metaContainer().valueMetaType());
0139
0140     return [&] {
0141     QVariant v(metaType);
0142     void *dataPtr = metaType == QMetaType::fromType<QVariant>() ? &v : v.data();
0143     m_pointer->metaContainer().valueAtIterator(m_pointer->constIterator(), dataPtr);
0144     return v;
0145     }();
0146 }
0147
0148 template<>
0149 inline QVariantRef<QSequentialIterator> &QVariantRef<QSequentialIterator>::operator=(
0150         const QVariant &value)
0151 {
0152     if (m_pointer == nullptr)
0153         return *this;
0154
0155     QtPrivate::QVariantTypeCoercer coercer;
0156     m_pointer->metaContainer().setValueAtIterator(
0157                 m_pointer->constIterator(),
0158                 coercer.coerce(value, m_pointer->metaContainer().valueMetaType()));
0159     return *this;
0160 }
0161
0162 Q_DECLARE_TYPEINFO(QSequentialIterable, Q_RELOCATABLE_TYPE);
0163 Q_DECLARE_TYPEINFO(QSequentialIterable::iterator, Q_RELOCATABLE_TYPE);
0164 Q_DECLARE_TYPEINFO(QSequentialIterable::const_iterator, Q_RELOCATABLE_TYPE);
0165
0166 QT_WARNING_POP
0167 #endif // QT_DEPRECATED_SINCE(6, 15)
0168
0169 QT_END_NAMESPACE
0170
0171 #endif // QSEQUENTIALITERABLE_H