Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-01-08 10:23:54 

0001 // Copyright (C) 2022 Intel Corporation.
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:critical reason:data-parser
0004 
0005 #ifndef QCBORMAP_H
0006 #define QCBORMAP_H
0007 
0008 #include <QtCore/qcborvalue.h>
0009 #include <QtCore/qpair.h>
0010 
0011 #include <initializer_list>
0012 
0013 QT_BEGIN_NAMESPACE
0014 
0015 class QJsonObject;
0016 class QDataStream;
0017 
0018 namespace QJsonPrivate { class Variant; }
0019 
0020 namespace QtPrivate {
0021 
0022 template <typename T, typename Iterator>
0023 struct QCborMapKeyValues
0024 {
0025     static QCborValueConstRef key(const Iterator &it) { return it.keyRef(); }
0026     static QCborValueConstRef key(Iterator &it) { return it.keyRef(); }
0027     static T value(const Iterator &it) { return it.value(); }
0028     static T value(Iterator &it) { return it.value(); }
0029 };
0030 
0031 } // namespace QtPrivate
0032 
0033 class QCborContainerPrivate;
0034 class Q_CORE_EXPORT QCborMap
0035 {
0036 public:
0037     typedef std::pair<QCborValue, QCborValue> value_type;
0038     typedef QCborValue key_type;
0039     typedef QCborValue mapped_type;
0040     typedef qsizetype size_type;
0041 
0042     class ConstIterator;
0043     class Iterator {
0044         QCborValueRef item {};      // points to the value
0045         friend class ConstIterator;
0046         friend class QCborMap;
0047         Iterator(QCborContainerPrivate *dd, qsizetype ii) : item(dd, ii) {}
0048     public:
0049         typedef std::random_access_iterator_tag iterator_category;
0050         typedef qsizetype difference_type;
0051         typedef std::pair<QCborValueConstRef, QCborValueRef> value_type;
0052         typedef std::pair<QCborValueConstRef, QCborValueRef> reference;
0053         typedef std::pair<QCborValueConstRef, QCborValueRef> pointer;
0054 
0055         constexpr Iterator() = default;
0056         constexpr Iterator(const Iterator &) = default;
0057         ~Iterator() = default;
0058         Iterator &operator=(const Iterator &other)
0059         {
0060             // rebind the reference
0061             item.d = other.item.d;
0062             item.i = other.item.i;
0063             return *this;
0064         }
0065 
0066         value_type operator*() const { return { QCborValueRef{item.d, item.i - 1}, item }; }
0067         value_type operator[](qsizetype j) const { return *(*this + j); }
0068         QCborValueRef *operator->() { return &item; }
0069         const QCborValueConstRef *operator->() const { return &item; }
0070 #if QT_VERSION >= QT_VERSION_CHECK(7,0,0)
0071         QCborValueConstRef
0072 #else
0073         QCborValue
0074 #endif
0075         key() const { return QCborValueRef(item.d, item.i - 1); }
0076         QCborValueConstRef keyRef() const { return QCborValueRef(item.d, item.i - 1); }
0077         QCborValueRef value() const { return item; }
0078 
0079 #if QT_CORE_REMOVED_SINCE(6, 8)
0080         bool operator==(const Iterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0081         bool operator!=(const Iterator &o) const { return !operator==(o); }
0082         bool operator<(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0083         bool operator<=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0084         bool operator>(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0085         bool operator>=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0086         bool operator==(const ConstIterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0087         bool operator!=(const ConstIterator &o) const { return !operator==(o); }
0088         bool operator<(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0089         bool operator<=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0090         bool operator>(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0091         bool operator>=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0092 #endif
0093         Iterator &operator++() { item.i += 2; return *this; }
0094         Iterator operator++(int) { Iterator n = *this; item.i += 2; return n; }
0095         Iterator &operator--() { item.i -= 2; return *this; }
0096         Iterator operator--(int) { Iterator n = *this; item.i -= 2; return n; }
0097         Iterator &operator+=(qsizetype j) { item.i += 2 * j; return *this; }
0098         Iterator &operator-=(qsizetype j) { item.i -= 2 * j; return *this; }
0099         Iterator operator+(qsizetype j) const { return Iterator({ item.d, item.i + 2 * j }); }
0100         Iterator operator-(qsizetype j) const { return Iterator({ item.d, item.i - 2 * j }); }
0101         qsizetype operator-(Iterator j) const { return (item.i - j.item.i) / 2; }
0102 
0103     private:
0104         // Helper functions
0105         static bool comparesEqual_helper(const Iterator &lhs, const Iterator &rhs) noexcept
0106         {
0107             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0108         }
0109 
0110         static bool comparesEqual_helper(const Iterator &lhs, const ConstIterator &rhs) noexcept
0111         {
0112             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0113         }
0114 
0115         static Qt::strong_ordering compareThreeWay_helper(const Iterator &lhs,
0116                                                           const Iterator &rhs)
0117         {
0118             Q_ASSERT(lhs.item.d == rhs.item.d);
0119             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0120         }
0121 
0122         static Qt::strong_ordering compareThreeWay_helper(const Iterator &lhs,
0123                                                           const ConstIterator &rhs)
0124         {
0125             Q_ASSERT(lhs.item.d == rhs.item.d);
0126             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0127         }
0128 
0129         // Compare friends
0130         friend bool comparesEqual(const Iterator &lhs, const Iterator &rhs) noexcept
0131         {
0132             return comparesEqual_helper(lhs, rhs);
0133         }
0134         friend Qt::strong_ordering compareThreeWay(const Iterator &lhs,
0135                                                    const Iterator &rhs)
0136         {
0137             return compareThreeWay_helper(lhs, rhs);
0138         }
0139         Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(Iterator)
0140         friend bool comparesEqual(const Iterator &lhs, const ConstIterator &rhs) noexcept
0141         {
0142             return comparesEqual_helper(lhs, rhs);
0143         }
0144         friend Qt::strong_ordering compareThreeWay(const Iterator &lhs,
0145                                                    const ConstIterator &rhs)
0146         {
0147             return compareThreeWay_helper(lhs, rhs);
0148         }
0149         Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(Iterator, ConstIterator)
0150     };
0151 
0152     class ConstIterator {
0153         QCborValueConstRef item;     // points to the value
0154         friend class Iterator;
0155         friend class QCborMap;
0156         friend class QCborValue;
0157         friend class QCborValueRef;
0158         constexpr ConstIterator(QCborValueConstRef it) : item{it} {}
0159         ConstIterator(QCborContainerPrivate *dd, qsizetype ii) : item(dd, ii) {}
0160     public:
0161         typedef std::random_access_iterator_tag iterator_category;
0162         typedef qsizetype difference_type;
0163         typedef std::pair<QCborValueConstRef, QCborValueConstRef> value_type;
0164         typedef std::pair<QCborValueConstRef, QCborValueConstRef> reference;
0165         typedef std::pair<QCborValueConstRef, QCborValueConstRef> pointer;
0166 
0167         constexpr ConstIterator() = default;
0168         constexpr ConstIterator(const ConstIterator &) = default;
0169         ~ConstIterator() = default;
0170         ConstIterator &operator=(const ConstIterator &other)
0171         {
0172             // rebind the reference
0173             item.d = other.item.d;
0174             item.i = other.item.i;
0175             return *this;
0176         }
0177 
0178         value_type operator*() const { return { QCborValueRef(item.d, item.i - 1), item }; }
0179         value_type operator[](qsizetype j) const { return *(*this + j); }
0180         const QCborValueConstRef *operator->() const { return &item; }
0181 #if QT_VERSION >= QT_VERSION_CHECK(7,0,0)
0182         QCborValueConstRef
0183 #else
0184         QCborValue
0185 #endif
0186         key() const { return QCborValueRef(item.d, item.i - 1); }
0187         QCborValueConstRef keyRef() const { return QCborValueRef(item.d, item.i - 1); }
0188         QCborValueConstRef value() const { return item; }
0189 
0190 #if QT_CORE_REMOVED_SINCE(6, 8)
0191         bool operator==(const Iterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0192         bool operator!=(const Iterator &o) const { return !operator==(o); }
0193         bool operator<(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0194         bool operator<=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0195         bool operator>(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0196         bool operator>=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0197         bool operator==(const ConstIterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0198         bool operator!=(const ConstIterator &o) const { return !operator==(o); }
0199         bool operator<(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0200         bool operator<=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0201         bool operator>(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0202         bool operator>=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0203 #endif
0204         ConstIterator &operator++() { item.i += 2; return *this; }
0205         ConstIterator operator++(int) { ConstIterator n = *this; item.i += 2; return n; }
0206         ConstIterator &operator--() { item.i -= 2; return *this; }
0207         ConstIterator operator--(int) { ConstIterator n = *this; item.i -= 2; return n; }
0208         ConstIterator &operator+=(qsizetype j) { item.i += 2 * j; return *this; }
0209         ConstIterator &operator-=(qsizetype j) { item.i -= 2 * j; return *this; }
0210         ConstIterator operator+(qsizetype j) const { return ConstIterator{ item.d, item.i + 2 * j }; }
0211         ConstIterator operator-(qsizetype j) const { return ConstIterator{ item.d, item.i - 2 * j }; }
0212         qsizetype operator-(ConstIterator j) const { return (item.i - j.item.i) / 2; }
0213     private:
0214         // Helper functions
0215         static bool comparesEqual_helper(const ConstIterator &lhs,
0216                                          const ConstIterator &rhs) noexcept
0217         {
0218             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0219         }
0220         static Qt::strong_ordering compareThreeWay_helper(const ConstIterator &lhs,
0221                                                           const ConstIterator &rhs)
0222         {
0223             Q_ASSERT(lhs.item.d == rhs.item.d);
0224             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0225         }
0226 
0227         // Compare friends
0228         friend bool comparesEqual(const ConstIterator &lhs, const ConstIterator &rhs) noexcept
0229         {
0230             return comparesEqual_helper(lhs, rhs);
0231         }
0232         friend Qt::strong_ordering compareThreeWay(const ConstIterator &lhs,
0233                                                    const ConstIterator &rhs)
0234         {
0235             return compareThreeWay_helper(lhs, rhs);
0236         }
0237         Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(ConstIterator)
0238     };
0239 
0240     QCborMap()  noexcept;
0241     QCborMap(const QCborMap &other) noexcept;
0242     QCborMap(QCborMap &&other) noexcept = default;
0243     QCborMap &operator=(const QCborMap &other) noexcept;
0244     QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QCborMap)
0245     QCborMap(std::initializer_list<value_type> args)
0246         : QCborMap()
0247     {
0248         detach(args.size());
0249         for (const auto &pair : args)
0250            insert(pair.first, pair.second);
0251     }
0252     ~QCborMap();
0253 
0254     void swap(QCborMap &other) noexcept
0255     {
0256         d.swap(other.d);
0257     }
0258 
0259     QCborValue toCborValue() const { return *this; }
0260 
0261     qsizetype size() const noexcept Q_DECL_PURE_FUNCTION;
0262     bool isEmpty() const { return size() == 0; }
0263     void clear();
0264     QList<QCborValue> keys() const;
0265 
0266     QCborValue value(qint64 key) const
0267     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0268     QCborValue value(QLatin1StringView key) const
0269     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0270     QCborValue value(const QString & key) const
0271     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0272     QCborValue value(const QCborValue &key) const
0273     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0274 #if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
0275     template<size_t N> QT_ASCII_CAST_WARN const QCborValue value(const char (&key)[N]) const
0276     { return value(QString::fromUtf8(key, N - 1)); }
0277 #endif
0278     const QCborValue operator[](qint64 key) const
0279     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0280     const QCborValue operator[](QLatin1StringView key) const
0281     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0282     const QCborValue operator[](const QString & key) const
0283     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0284     const QCborValue operator[](const QCborValue &key) const
0285     { const_iterator it = find(key); return comparesEqual(it, end()) ? QCborValue() : it.value(); }
0286 #if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
0287     template<size_t N> QT_ASCII_CAST_WARN const QCborValue operator[](const char (&key)[N]) const
0288     { return operator[](QString::fromUtf8(key, N - 1)); }
0289 #endif
0290     QCborValueRef operator[](qint64 key);
0291     QCborValueRef operator[](QLatin1StringView key);
0292     QCborValueRef operator[](const QString & key);
0293     QCborValueRef operator[](const QCborValue &key);
0294 
0295     QCborValue take(qint64 key)
0296     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) return extract(it); return QCborValue(); }
0297     QCborValue take(QLatin1StringView key)
0298     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) return extract(it); return QCborValue(); }
0299     QCborValue take(const QString &key)
0300     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) return extract(it); return QCborValue(); }
0301     QCborValue take(const QCborValue &key)
0302     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) return extract(it); return QCborValue(); }
0303     void remove(qint64 key)
0304     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) erase(it); }
0305     void remove(QLatin1StringView key)
0306     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) erase(it); }
0307     void remove(const QString & key)
0308     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) erase(it); }
0309     void remove(const QCborValue &key)
0310     { const_iterator it = constFind(key); if (!comparesEqual(it, constEnd())) erase(it); }
0311     bool contains(qint64 key) const
0312     { const_iterator it = find(key); return !comparesEqual(it, end()); }
0313     bool contains(QLatin1StringView key) const
0314     { const_iterator it = find(key); return !comparesEqual(it, end()); }
0315     bool contains(const QString & key) const
0316     { const_iterator it = find(key); return !comparesEqual(it, end()); }
0317     bool contains(const QCborValue &key) const
0318     { const_iterator it = find(key); return !comparesEqual(it, end()); }
0319 
0320     int compare(const QCborMap &other) const noexcept Q_DECL_PURE_FUNCTION;
0321 #if QT_CORE_REMOVED_SINCE(6, 8)
0322     bool operator==(const QCborMap &other) const noexcept
0323     { return compare(other) == 0; }
0324     bool operator!=(const QCborMap &other) const noexcept
0325     { return !operator==(other); }
0326     bool operator<(const QCborMap &other) const
0327     { return compare(other) < 0; }
0328 #endif
0329 
0330     typedef Iterator iterator;
0331     typedef ConstIterator const_iterator;
0332     iterator begin() { detach(); return iterator{d.data(), 1}; }
0333     const_iterator constBegin() const { return const_iterator{d.data(), 1}; }
0334     const_iterator begin() const { return constBegin(); }
0335     const_iterator cbegin() const { return constBegin(); }
0336     iterator end() { detach(); return iterator{d.data(), 2 * size() + 1}; }
0337     const_iterator constEnd() const { return const_iterator{d.data(), 2 * size() + 1}; }
0338     const_iterator end() const { return constEnd(); }
0339     const_iterator cend() const { return constEnd(); }
0340     iterator erase(iterator it);
0341     iterator erase(const_iterator it) { return erase(iterator{ it.item.d, it.item.i }); }
0342     QCborValue extract(iterator it);
0343     QCborValue extract(const_iterator it) { return extract(iterator{ it.item.d, it.item.i }); }
0344     bool empty() const { return isEmpty(); }
0345 
0346     typedef QKeyValueIterator<QCborValueConstRef, QCborValueConstRef, const_iterator,
0347                               QtPrivate::QCborMapKeyValues<QCborValueConstRef, ConstIterator>>
0348             const_key_value_iterator;
0349     typedef QKeyValueIterator<QCborValueConstRef, QCborValueRef, iterator,
0350                               QtPrivate::QCborMapKeyValues<QCborValueRef, Iterator>>
0351             key_value_iterator;
0352 
0353     key_value_iterator keyValueBegin() { return key_value_iterator(begin()); }
0354     key_value_iterator keyValueEnd() { return key_value_iterator(end()); }
0355     const_key_value_iterator keyValueBegin() const { return const_key_value_iterator(begin()); }
0356     const_key_value_iterator constKeyValueBegin() const
0357     {
0358         return const_key_value_iterator(begin());
0359     }
0360     const_key_value_iterator keyValueEnd() const { return const_key_value_iterator(end()); }
0361     const_key_value_iterator constKeyValueEnd() const { return const_key_value_iterator(end()); }
0362 
0363     auto asKeyValueRange() & { return QtPrivate::QKeyValueRange<QCborMap &>(*this); }
0364     auto asKeyValueRange() const & { return QtPrivate::QKeyValueRange<const QCborMap &>(*this); }
0365     auto asKeyValueRange() && { return QtPrivate::QKeyValueRange<QCborMap>(std::move(*this)); }
0366     auto asKeyValueRange() const &&
0367     {
0368         return QtPrivate::QKeyValueRange<QCborMap>(std::move(*this));
0369     }
0370 
0371     iterator find(qint64 key);
0372     iterator find(QLatin1StringView key);
0373     iterator find(const QString & key);
0374     iterator find(const QCborValue &key);
0375     const_iterator constFind(qint64 key) const;
0376     const_iterator constFind(QLatin1StringView key) const;
0377     const_iterator constFind(const QString & key) const;
0378     const_iterator constFind(const QCborValue &key) const;
0379     const_iterator find(qint64 key) const { return constFind(key); }
0380     const_iterator find(QLatin1StringView key) const { return constFind(key); }
0381     const_iterator find(const QString & key) const { return constFind(key); }
0382     const_iterator find(const QCborValue &key) const { return constFind(key); }
0383 
0384     iterator insert(qint64 key, const QCborValue &value_)
0385     {
0386         QCborValueRef v = operator[](key);  // detaches
0387         v = value_;
0388         return { d.data(), v.i };
0389     }
0390     iterator insert(QLatin1StringView key, const QCborValue &value_)
0391     {
0392         QCborValueRef v = operator[](key);  // detaches
0393         v = value_;
0394         return { d.data(), v.i };
0395     }
0396     iterator insert(const QString &key, const QCborValue &value_)
0397     {
0398         QCborValueRef v = operator[](key);  // detaches
0399         v = value_;
0400         return { d.data(), v.i };
0401     }
0402     iterator insert(const QCborValue &key, const QCborValue &value_)
0403     {
0404         QCborValueRef v = operator[](key);  // detaches
0405         v = value_;
0406         return { d.data(), v.i };
0407     }
0408     iterator insert(value_type v) { return insert(v.first, v.second); }
0409 
0410     static QCborMap fromVariantMap(const QVariantMap &map);
0411     static QCborMap fromVariantHash(const QVariantHash &hash);
0412     static QCborMap fromJsonObject(const QJsonObject &o);
0413     static QCborMap fromJsonObject(QJsonObject &&o) noexcept;
0414     QVariantMap toVariantMap() const;
0415     QVariantHash toVariantHash() const;
0416     QJsonObject toJsonObject() const;
0417 
0418 private:
0419     friend class QCborContainerPrivate;
0420     friend class QCborValue;
0421     friend class QCborValueRef;
0422     friend class QJsonPrivate::Variant;
0423     void detach(qsizetype reserve = 0);
0424 
0425     friend Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool
0426     comparesEqual(const QCborMap &lhs, const QCborMap &rhs) noexcept;
0427     friend Qt::strong_ordering compareThreeWay(const QCborMap &lhs,
0428                                                const QCborMap &rhs) noexcept
0429     {
0430         int c = lhs.compare(rhs);
0431         return Qt::compareThreeWay(c, 0);
0432     }
0433     Q_DECLARE_STRONGLY_ORDERED(QCborMap)
0434 
0435     static Q_DECL_PURE_FUNCTION bool
0436     comparesEqual_helper(const QCborMap &lhs, const QCborValue &rhs) noexcept;
0437     static Q_DECL_PURE_FUNCTION Qt::strong_ordering
0438     compareThreeWay_helper(const QCborMap &lhs, const QCborValue &rhs) noexcept;
0439     friend bool comparesEqual(const QCborMap &lhs,
0440                               const QCborValue &rhs) noexcept
0441     {
0442         return comparesEqual_helper(lhs, rhs);
0443     }
0444     friend Qt::strong_ordering compareThreeWay(const QCborMap &lhs,
0445                                                const QCborValue &rhs) noexcept
0446     {
0447         return compareThreeWay_helper(lhs, rhs);
0448     }
0449     Q_DECLARE_STRONGLY_ORDERED(QCborMap, QCborValue)
0450 
0451     static Q_DECL_PURE_FUNCTION bool
0452     comparesEqual_helper(const QCborMap &lhs, QCborValueConstRef rhs) noexcept;
0453     static Q_DECL_PURE_FUNCTION Qt::strong_ordering
0454     compareThreeWay_helper(const QCborMap &lhs, QCborValueConstRef rhs) noexcept;
0455     friend bool comparesEqual(const QCborMap &lhs,
0456                               const QCborValueConstRef &rhs) noexcept
0457     {
0458         return comparesEqual_helper(lhs, rhs);
0459     }
0460     friend Qt::strong_ordering compareThreeWay(const QCborMap &lhs,
0461                                                const QCborValueConstRef &rhs) noexcept
0462     {
0463         return compareThreeWay_helper(lhs, rhs);
0464     }
0465     Q_DECLARE_STRONGLY_ORDERED(QCborMap, QCborValueConstRef)
0466 
0467     explicit QCborMap(QCborContainerPrivate &dd) noexcept;
0468     QExplicitlySharedDataPointer<QCborContainerPrivate> d;
0469 };
0470 
0471 Q_DECLARE_SHARED(QCborMap)
0472 
0473 inline QCborValue::QCborValue(QCborMap &&m)
0474     : n(-1), container(m.d.take()), t(Map)
0475 {
0476 }
0477 
0478 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
0479 inline QCborMap QCborValueRef::toMap() const
0480 {
0481     return concrete().toMap();
0482 }
0483 
0484 inline QCborMap QCborValueRef::toMap(const QCborMap &m) const
0485 {
0486     return concrete().toMap(m);
0487 }
0488 #endif
0489 
0490 inline QCborMap QCborValueConstRef::toMap() const
0491 {
0492     return concrete().toMap();
0493 }
0494 
0495 inline QCborMap QCborValueConstRef::toMap(const QCborMap &m) const
0496 {
0497     return concrete().toMap(m);
0498 }
0499 
0500 Q_CORE_EXPORT size_t qHash(const QCborMap &map, size_t seed = 0);
0501 
0502 #if !defined(QT_NO_DEBUG_STREAM)
0503 Q_CORE_EXPORT QDebug operator<<(QDebug, const QCborMap &m);
0504 #endif
0505 
0506 #ifndef QT_NO_DATASTREAM
0507 #if QT_CONFIG(cborstreamwriter)
0508 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QCborMap &);
0509 #endif
0510 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QCborMap &);
0511 #endif
0512 
0513 
0514 QT_END_NAMESPACE
0515 
0516 #endif // QCBORMAP_H
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!