include/QtCore/qassociativeiterable.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 QASSOCIATIVEITERABLE_H
0006 #define QASSOCIATIVEITERABLE_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 QMetaAssociation's iterables and iterators instead.") QAssociativeIterator : public QIterator<QMetaAssociation>
0019 {
0020 public:
0021     using key_type = QVariant;
0022     using mapped_type = QVariant;
0023     using reference = QVariantRef<QAssociativeIterator>;
0024     using pointer = QVariantPointer<QAssociativeIterator>;
0025
0026     QAssociativeIterator(QIterator &&it)
0027         : QIterator(std::move(it))
0028     {}
0029
0030     QVariant key() const;
0031     QVariantRef<QAssociativeIterator> value() const;
0032
0033     QVariantRef<QAssociativeIterator> operator*() const;
0034     QVariantPointer<QAssociativeIterator> operator->() const;
0035 };
0036
0037 // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
0038 class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaAssociation's iterables and iterators instead.") QAssociativeConstIterator : public QConstIterator<QMetaAssociation>
0039 {
0040 public:
0041     using key_type = QVariant;
0042     using mapped_type = QVariant;
0043     using reference = const QVariant &;
0044     using pointer = QVariantConstPointer;
0045
0046     QAssociativeConstIterator(QConstIterator &&it)
0047         : QConstIterator(std::move(it))
0048     {}
0049
0050     QVariant key() const;
0051     QVariant value() const;
0052
0053     QVariant operator*() const;
0054     QVariantConstPointer operator->() const;
0055 };
0056
0057 // Keep this a single long line, otherwise syncqt doesn't create a class forwarding header
0058 class Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_6_15("Use QMetaAssociation's iterables and iterators instead.") QAssociativeIterable : public QIterable<QMetaAssociation>
0059 {
0060 public:
0061     using iterator = QTaggedIterator<QAssociativeIterator, void>;
0062     using const_iterator = QTaggedIterator<QAssociativeConstIterator, void>;
0063
0064     using RandomAccessIterator = QTaggedIterator<iterator, std::random_access_iterator_tag>;
0065     using BidirectionalIterator = QTaggedIterator<iterator, std::bidirectional_iterator_tag>;
0066     using ForwardIterator = QTaggedIterator<iterator, std::forward_iterator_tag>;
0067     using InputIterator = QTaggedIterator<iterator, std::input_iterator_tag>;
0068
0069     using RandomAccessConstIterator = QTaggedIterator<const_iterator, std::random_access_iterator_tag>;
0070     using BidirectionalConstIterator = QTaggedIterator<const_iterator, std::bidirectional_iterator_tag>;
0071     using ForwardConstIterator = QTaggedIterator<const_iterator, std::forward_iterator_tag>;
0072     using InputConstIterator = QTaggedIterator<const_iterator, std::input_iterator_tag>;
0073
0074     template<class T>
0075     QAssociativeIterable(const T *p)
0076         : QIterable(QMetaAssociation::fromContainer<T>(), p)
0077     {
0078     }
0079
0080     template<class T>
0081     QAssociativeIterable(T *p)
0082         : QIterable(QMetaAssociation::fromContainer<T>(), p)
0083     {
0084     }
0085
0086     QAssociativeIterable()
0087         : QIterable(QMetaAssociation(), nullptr)
0088     {
0089     }
0090
0091     template<typename Pointer>
0092     QAssociativeIterable(const QMetaAssociation &metaAssociation, Pointer iterable)
0093         : QIterable(metaAssociation, iterable)
0094     {
0095     }
0096
0097     QAssociativeIterable(const QMetaAssociation &metaAssociation, const QMetaType &metaType,
0098                          void *iterable)
0099         : QIterable(metaAssociation, metaType.alignOf(), iterable)
0100     {
0101     }
0102
0103     QAssociativeIterable(const QMetaAssociation &metaAssociation, const QMetaType &metaType,
0104                          const void *iterable)
0105         : QIterable(metaAssociation, metaType.alignOf(), iterable)
0106     {
0107     }
0108
0109     QAssociativeIterable(QIterable<QMetaAssociation> &&other) : QIterable(std::move(other)) {}
0110
0111     QAssociativeIterable &operator=(QIterable<QMetaAssociation> &&other)
0112     {
0113         QIterable::operator=(std::move(other));
0114         return *this;
0115     }
0116
0117     const_iterator begin() const { return constBegin(); }
0118     const_iterator end() const { return constEnd(); }
0119
0120     const_iterator constBegin() const { return const_iterator(QIterable::constBegin()); }
0121     const_iterator constEnd() const { return const_iterator(QIterable::constEnd()); }
0122
0123     iterator mutableBegin() { return iterator(QIterable::mutableBegin()); }
0124     iterator mutableEnd() { return iterator(QIterable::mutableEnd()); }
0125
0126     const_iterator find(const QVariant &key) const;
0127     const_iterator constFind(const QVariant &key) const { return find(key); }
0128     iterator mutableFind(const QVariant &key);
0129
0130     bool containsKey(const QVariant &key);
0131     void insertKey(const QVariant &key);
0132     void removeKey(const QVariant &key);
0133
0134     QVariant value(const QVariant &key) const;
0135     void setValue(const QVariant &key, const QVariant &mapped);
0136
0137     // Random access iteration is broken on QAssociativeIterator.
0138     // That's why this class is deprecated after all.
0139     constexpr bool canRandomAccessIterate() const { return false; }
0140 };
0141
0142 template<>
0143 inline QVariantRef<QAssociativeIterator>::operator QVariant() const
0144 {
0145     if (m_pointer == nullptr)
0146         return QVariant();
0147
0148     const auto metaAssociation = m_pointer->metaContainer();
0149     const QMetaType metaType(metaAssociation.mappedMetaType());
0150     if (!metaType.isValid())
0151         return m_pointer->key();
0152
0153     return [&] {
0154     QVariant v(metaType);
0155     metaAssociation.mappedAtIterator(m_pointer->constIterator(),
0156                                      metaType == QMetaType::fromType<QVariant>() ? &v : v.data());
0157     return v;
0158     }();
0159 }
0160
0161 template<>
0162 inline QVariantRef<QAssociativeIterator> &QVariantRef<QAssociativeIterator>::operator=(
0163         const QVariant &value)
0164 {
0165     if (m_pointer == nullptr)
0166         return *this;
0167
0168     const auto metaAssociation = m_pointer->metaContainer();
0169     const QMetaType metaType(metaAssociation.mappedMetaType());
0170     if (metaType.isValid()) {
0171         QtPrivate::QVariantTypeCoercer coercer;
0172         metaAssociation.setMappedAtIterator(m_pointer->constIterator(),
0173                                             coercer.coerce(value, metaType));
0174     }
0175
0176     return *this;
0177 }
0178
0179 Q_DECLARE_TYPEINFO(QAssociativeIterable, Q_RELOCATABLE_TYPE);
0180 Q_DECLARE_TYPEINFO(QAssociativeIterable::iterator, Q_RELOCATABLE_TYPE);
0181 Q_DECLARE_TYPEINFO(QAssociativeIterable::const_iterator, Q_RELOCATABLE_TYPE);
0182
0183 QT_WARNING_POP
0184 #endif // QT_DEPRECATED_SINCE(6, 15)
0185
0186 QT_END_NAMESPACE
0187
0188 #endif // QASSOCIATIVEITERABLE_H