include/QtCore/qmetasequence.h

0001 // Copyright (C) 2025 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 QMETASEQUENCE_H
0006 #define QMETASEQUENCE_H
0007
0008 #if 0
0009 #pragma qt_class(QMetaSequence)
0010 #endif
0011
0012 #include <QtCore/qiterable.h>
0013 #include <QtCore/qiterable_impl.h>
0014 #include <QtCore/qmetacontainer.h>
0015 #include <QtCore/qvariant.h>
0016
0017 QT_BEGIN_NAMESPACE
0018
0019 namespace QtMetaContainerPrivate {
0020
0021 class SequentialIterator : public QIterator<QMetaSequence>
0022 {
0023 public:
0024     using value_type = QVariant;
0025     using reference = QVariant::Reference<SequentialIterator>;
0026     using pointer = QVariant::Pointer<SequentialIterator>;
0027
0028     static constexpr bool CanNoexceptAssignQVariant = false;
0029     static constexpr bool CanNoexceptConvertToQVariant = false;
0030
0031     SequentialIterator(QIterator &&it) : QIterator(std::move(it)) {}
0032
0033     reference operator*() const { return reference(*this); }
0034     pointer operator->() const { return pointer(*this); }
0035     reference operator[](qsizetype n) const { return reference(*this + n); }
0036 };
0037
0038 class SequentialConstIterator : public QConstIterator<QMetaSequence>
0039 {
0040 public:
0041     using value_type = QVariant;
0042     using reference = QVariant::ConstReference<SequentialConstIterator>;
0043     using pointer = QVariant::ConstPointer<SequentialConstIterator>;
0044
0045     static constexpr bool CanNoexceptConvertToQVariant = false;
0046
0047     SequentialConstIterator(QConstIterator &&it) : QConstIterator(std::move(it)) {}
0048
0049     value_type operator*() const;
0050     pointer operator->() const { return pointer(*this); }
0051     value_type operator[](qsizetype n) const;
0052 };
0053
0054 } // namespace QtMetaContainerPrivate
0055
0056 namespace QtPrivate {
0057 template<typename Indirect>
0058 QVariant sequentialIteratorToVariant(const Indirect &referred)
0059 {
0060     const auto metaSequence = referred.metaContainer();
0061     return QtIterablePrivate::retrieveElement(metaSequence.valueMetaType(), [&](void *dataPtr) {
0062         metaSequence.valueAtConstIterator(referred.constIterator(), dataPtr);
0063     });
0064 }
0065 } // namespace QtPrivate
0066
0067 template<>
0068 inline QVariant::Reference<QtMetaContainerPrivate::SequentialIterator>::operator QVariant() const
0069 {
0070     return QtPrivate::sequentialIteratorToVariant(m_referred);
0071 }
0072
0073 template<>
0074 inline QVariant::Reference<QtMetaContainerPrivate::SequentialIterator> &
0075 QVariant::Reference<QtMetaContainerPrivate::SequentialIterator>::operator=(const QVariant &value)
0076 {
0077     QtPrivate::QVariantTypeCoercer coercer;
0078     m_referred.metaContainer().setValueAtIterator(
0079             m_referred.mutableIterator(),
0080             coercer.coerce(value, m_referred.metaContainer().valueMetaType()));
0081     return *this;
0082 }
0083
0084 template<>
0085 inline QVariant::ConstReference<QtMetaContainerPrivate::SequentialConstIterator>::operator QVariant() const
0086 {
0087     return QtPrivate::sequentialIteratorToVariant(m_referred);
0088 }
0089
0090 namespace QtMetaContainerPrivate {
0091 inline SequentialConstIterator::value_type SequentialConstIterator::operator*() const
0092 {
0093     return reference(*this);
0094 }
0095
0096 inline SequentialConstIterator::value_type SequentialConstIterator::operator[](qsizetype n) const
0097 {
0098     return reference(*this + n);
0099 }
0100
0101 class Sequence : public QIterable<QMetaSequence>
0102 {
0103 public:
0104     using Iterator = QTaggedIterator<SequentialIterator, void>;
0105     using RandomAccessIterator
0106             = QTaggedIterator<SequentialIterator, std::random_access_iterator_tag>;
0107     using BidirectionalIterator
0108             = QTaggedIterator<SequentialIterator, std::bidirectional_iterator_tag>;
0109     using ForwardIterator
0110             = QTaggedIterator<SequentialIterator, std::forward_iterator_tag>;
0111     using InputIterator
0112             = QTaggedIterator<SequentialIterator, std::input_iterator_tag>;
0113
0114     using ConstIterator
0115             = QTaggedIterator<SequentialConstIterator, void>;
0116     using RandomAccessConstIterator
0117             = QTaggedIterator<SequentialConstIterator, std::random_access_iterator_tag>;
0118     using BidirectionalConstIterator
0119             = QTaggedIterator<SequentialConstIterator, std::bidirectional_iterator_tag>;
0120     using ForwardConstIterator
0121             = QTaggedIterator<SequentialConstIterator, std::forward_iterator_tag>;
0122     using InputConstIterator
0123             = QTaggedIterator<SequentialConstIterator, std::input_iterator_tag>;
0124
0125     using iterator = Iterator;
0126     using const_iterator = ConstIterator;
0127
0128     template<class T>
0129     Sequence(const T *p)
0130         : QIterable(QMetaSequence::fromContainer<T>(), p)
0131     {
0132         Q_UNUSED(m_revision);
0133     }
0134
0135     template<class T>
0136     Sequence(T *p)
0137         : QIterable(QMetaSequence::fromContainer<T>(), p)
0138     {
0139     }
0140
0141     Sequence()
0142         : QIterable(QMetaSequence(), nullptr)
0143     {
0144     }
0145
0146     template<typename Pointer>
0147     Sequence(const QMetaSequence &metaSequence, Pointer iterable)
0148         : QIterable(metaSequence, iterable)
0149     {
0150     }
0151
0152     Sequence(const QMetaSequence &metaSequence, QMetaType metaType, void *iterable)
0153         : QIterable(metaSequence, metaType.alignOf(), iterable)
0154     {
0155     }
0156
0157     Sequence(const QMetaSequence &metaSequence, QMetaType metaType, const void *iterable)
0158         : QIterable(metaSequence, metaType.alignOf(), iterable)
0159     {
0160     }
0161
0162     Sequence(QIterable<QMetaSequence> &&other) : QIterable(std::move(other)) {}
0163
0164     Sequence &operator=(QIterable<QMetaSequence> &&other)
0165     {
0166         QIterable::operator=(std::move(other));
0167         return *this;
0168     }
0169
0170     ConstIterator begin() const { return constBegin(); }
0171     ConstIterator end() const { return constEnd(); }
0172
0173     ConstIterator constBegin() const { return ConstIterator(QIterable::constBegin()); }
0174     ConstIterator constEnd() const { return ConstIterator(QIterable::constEnd()); }
0175
0176     Iterator mutableBegin() { return Iterator(QIterable::mutableBegin()); }
0177     Iterator mutableEnd() { return Iterator(QIterable::mutableEnd()); }
0178
0179     QVariant at(qsizetype idx) const
0180     {
0181         const QMetaSequence meta = metaContainer();
0182         return QtIterablePrivate::retrieveElement(meta.valueMetaType(), [&](void *dataPtr) {
0183             if (meta.canGetValueAtIndex()) {
0184                 meta.valueAtIndex(constIterable(), idx, dataPtr);
0185                 return;
0186             }
0187
0188 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
0189             // We shouldn't second-guess the underlying container.
0190             QtPrivate::warnSynthesizedIterableAccess(
0191                     QtPrivate::SynthesizedAccessFunction::SequenceAt);
0192             void *it = meta.constBegin(m_iterable.constPointer());
0193             meta.advanceConstIterator(it, idx);
0194             meta.valueAtConstIterator(it, dataPtr);
0195             meta.destroyConstIterator(it);
0196 #endif
0197         });
0198     }
0199
0200     void setAt(qsizetype idx, const QVariant &value)
0201     {
0202         const QMetaSequence meta = metaContainer();
0203         QtPrivate::QVariantTypeCoercer coercer;
0204         meta.setValueAtIndex(mutableIterable(), idx, coercer.coerce(value, meta.valueMetaType()));
0205     }
0206
0207     void append(const QVariant &value)
0208     {
0209         const QMetaSequence meta = metaContainer();
0210         QtPrivate::QVariantTypeCoercer coercer;
0211         meta.addValueAtEnd(mutableIterable(), coercer.coerce(value, meta.valueMetaType()));
0212     }
0213
0214     void prepend(const QVariant &value)
0215     {
0216         const QMetaSequence meta = metaContainer();
0217         QtPrivate::QVariantTypeCoercer coercer;
0218         meta.addValueAtBegin(mutableIterable(), coercer.coerce(value, meta.valueMetaType()));
0219     }
0220
0221     void removeLast()
0222     {
0223         metaContainer().removeValueAtEnd(mutableIterable());
0224     }
0225
0226     void removeFirst()
0227     {
0228         metaContainer().removeValueAtBegin(mutableIterable());
0229     }
0230
0231 #if QT_DEPRECATED_SINCE(6, 11)
0232     QT_WARNING_PUSH
0233     QT_WARNING_DISABLE_DEPRECATED
0234
0235     enum
0236     QT_DEPRECATED_VERSION_X_6_11("Use append(), prepend(), removeLast(), or removeFirst() instead.")
0237     Position: quint8
0238     {
0239         Unspecified, AtBegin, AtEnd
0240     };
0241
0242     QT_DEPRECATED_VERSION_X_6_11("Use append() or prepend() instead.")
0243     void addValue(const QVariant &value, Position position = Unspecified)
0244     {
0245         const QMetaSequence meta = metaContainer();
0246         QtPrivate::QVariantTypeCoercer coercer;
0247         const void *valuePtr = coercer.coerce(value, meta.valueMetaType());
0248
0249         switch (position) {
0250         case AtBegin:
0251             if (meta.canAddValueAtBegin())
0252                 meta.addValueAtBegin(mutableIterable(), valuePtr);
0253             break;
0254         case AtEnd:
0255             if (meta.canAddValueAtEnd())
0256                 meta.addValueAtEnd(mutableIterable(), valuePtr);
0257             break;
0258         case Unspecified:
0259             if (meta.canAddValue())
0260                 meta.addValue(mutableIterable(), valuePtr);
0261             break;
0262         }
0263     }
0264
0265     QT_DEPRECATED_VERSION_X_6_11("Use removeLast() or removeFirst() instead.")
0266     void removeValue(Position position = Unspecified)
0267     {
0268         const QMetaSequence meta = metaContainer();
0269
0270         switch (position) {
0271         case AtBegin:
0272             if (meta.canRemoveValueAtBegin())
0273                 meta.removeValueAtBegin(mutableIterable());
0274             break;
0275         case AtEnd:
0276             if (meta.canRemoveValueAtEnd())
0277                 meta.removeValueAtEnd(mutableIterable());
0278             break;
0279         case Unspecified:
0280             if (meta.canRemoveValue())
0281                 meta.removeValue(mutableIterable());
0282             break;
0283         }
0284     }
0285
0286     QT_DEPRECATED_VERSION_X_6_11("Use QMetaSequence::valueMetaType() instead.")
0287     QMetaType valueMetaType() const
0288     {
0289         return metaContainer().valueMetaType();
0290     }
0291
0292     void set(qsizetype idx, const QVariant &value)
0293             Q_DECL_EQ_DELETE_X("Use setAt() instead.");
0294
0295     QT_WARNING_POP
0296 #endif // QT_DEPRECATED_SINCE(6, 11)
0297 };
0298 } // namespace QtMetaContainerPrivate
0299
0300 QT_END_NAMESPACE
0301
0302 #endif // QMETASEQUENCE_H