Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-05-04 08:48:17 

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 QCBORARRAY_H
0006 #define QCBORARRAY_H
0007 
0008 #include <QtCore/qcborvalue.h>
0009 
0010 #include <initializer_list>
0011 
0012 QT_BEGIN_NAMESPACE
0013 
0014 class QJsonArray;
0015 class QDataStream;
0016 
0017 namespace QJsonPrivate { class Variant; }
0018 
0019 class QCborContainerPrivate;
0020 class Q_CORE_EXPORT QCborArray
0021 {
0022 public:
0023     class ConstIterator;
0024     class Iterator {
0025         QCborValueRef item {};
0026         friend class ConstIterator;
0027         friend class QCborArray;
0028         Iterator(QCborContainerPrivate *dd, qsizetype ii) : item(dd, ii) {}
0029     public:
0030         typedef std::random_access_iterator_tag iterator_category;
0031         typedef qsizetype difference_type;
0032         typedef QCborValue value_type;
0033         typedef QCborValueRef reference;
0034         typedef QCborValueRef *pointer;
0035 
0036         constexpr Iterator() = default;
0037         constexpr Iterator(const Iterator &) = default;
0038         Iterator &operator=(const Iterator &other)
0039         {
0040             // rebind the reference
0041             item.d = other.item.d;
0042             item.i = other.item.i;
0043             return *this;
0044         }
0045 
0046         QCborValueRef operator*() const { return item; }
0047         QCborValueRef *operator->() { return &item; }
0048         const QCborValueConstRef *operator->() const { return &item; }
0049         QCborValueRef operator[](qsizetype j) const { return { item.d, item.i + j }; }
0050 #if QT_CORE_REMOVED_SINCE(6, 8)
0051         bool operator==(const Iterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0052         bool operator!=(const Iterator &o) const { return !operator==(o); }
0053         bool operator<(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0054         bool operator<=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0055         bool operator>(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0056         bool operator>=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0057         bool operator==(const ConstIterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0058         bool operator!=(const ConstIterator &o) const { return !operator==(o); }
0059         bool operator<(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0060         bool operator<=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0061         bool operator>(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0062         bool operator>=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0063 #endif
0064         Iterator &operator++() { ++item.i; return *this; }
0065         Iterator operator++(int) { Iterator n = *this; ++item.i; return n; }
0066         Iterator &operator--() { item.i--; return *this; }
0067         Iterator operator--(int) { Iterator n = *this; item.i--; return n; }
0068         Iterator &operator+=(qsizetype j) { item.i += j; return *this; }
0069         Iterator &operator-=(qsizetype j) { item.i -= j; return *this; }
0070         Iterator operator+(qsizetype j) const { return Iterator({ item.d, item.i + j }); }
0071         Iterator operator-(qsizetype j) const { return Iterator({ item.d, item.i - j }); }
0072         qsizetype operator-(Iterator j) const { return item.i - j.item.i; }
0073     private:
0074         // Helper functions
0075         static bool comparesEqual_helper(const Iterator &lhs, const Iterator &rhs) noexcept
0076         {
0077             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0078         }
0079 
0080         static bool comparesEqual_helper(const Iterator &lhs, const ConstIterator &rhs) noexcept
0081         {
0082             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0083         }
0084 
0085         static Qt::strong_ordering compareThreeWay_helper(const Iterator &lhs,
0086                                                           const Iterator &rhs) noexcept
0087         {
0088             Q_ASSERT(lhs.item.d == rhs.item.d);
0089             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0090         }
0091 
0092         static Qt::strong_ordering compareThreeWay_helper(const Iterator &lhs,
0093                                                           const ConstIterator &rhs) noexcept
0094         {
0095             Q_ASSERT(lhs.item.d == rhs.item.d);
0096             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0097         }
0098 
0099         // Compare friends
0100         friend bool comparesEqual(const Iterator &lhs, const Iterator &rhs) noexcept
0101         {
0102             return comparesEqual_helper(lhs, rhs);
0103         }
0104         friend Qt::strong_ordering compareThreeWay(const Iterator &lhs,
0105                                                    const Iterator &rhs) noexcept
0106         {
0107             return compareThreeWay_helper(lhs, rhs);
0108         }
0109         Q_DECLARE_STRONGLY_ORDERED(Iterator)
0110         friend bool comparesEqual(const Iterator &lhs, const ConstIterator &rhs) noexcept
0111         {
0112             return comparesEqual_helper(lhs, rhs);
0113         }
0114         friend Qt::strong_ordering compareThreeWay(const Iterator &lhs,
0115                                                    const ConstIterator &rhs) noexcept
0116         {
0117             return compareThreeWay_helper(lhs, rhs);
0118         }
0119         Q_DECLARE_STRONGLY_ORDERED(Iterator, ConstIterator)
0120     };
0121 
0122     class ConstIterator {
0123         QCborValueConstRef item;
0124         friend class Iterator;
0125         friend class QCborArray;
0126         ConstIterator(QCborContainerPrivate *dd, qsizetype ii) : item(dd, ii) {}
0127     public:
0128         typedef std::random_access_iterator_tag iterator_category;
0129         typedef qsizetype difference_type;
0130         typedef const QCborValue value_type;
0131         typedef const QCborValueRef reference;
0132         typedef const QCborValueRef *pointer;
0133 
0134         constexpr ConstIterator() = default;
0135         constexpr ConstIterator(const ConstIterator &) = default;
0136         ConstIterator &operator=(const ConstIterator &other)
0137         {
0138             // rebind the reference
0139             item.d = other.item.d;
0140             item.i = other.item.i;
0141             return *this;
0142         }
0143 
0144         QCborValueConstRef operator*() const { return item; }
0145         const QCborValueConstRef *operator->() const { return &item; }
0146         QCborValueConstRef operator[](qsizetype j) const { return QCborValueRef{ item.d, item.i + j }; }
0147 #if QT_CORE_REMOVED_SINCE(6, 8)
0148         bool operator==(const Iterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0149         bool operator!=(const Iterator &o) const { return !operator==(o); }
0150         bool operator<(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0151         bool operator<=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0152         bool operator>(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0153         bool operator>=(const Iterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0154         bool operator==(const ConstIterator &o) const { return item.d == o.item.d && item.i == o.item.i; }
0155         bool operator!=(const ConstIterator &o) const { return !operator==(o); }
0156         bool operator<(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i < other.item.i; }
0157         bool operator<=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i <= other.item.i; }
0158         bool operator>(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i > other.item.i; }
0159         bool operator>=(const ConstIterator& other) const { Q_ASSERT(item.d == other.item.d); return item.i >= other.item.i; }
0160 #endif
0161         ConstIterator &operator++() { ++item.i; return *this; }
0162         ConstIterator operator++(int) { ConstIterator n = *this; ++item.i; return n; }
0163         ConstIterator &operator--() { item.i--; return *this; }
0164         ConstIterator operator--(int) { ConstIterator n = *this; item.i--; return n; }
0165         ConstIterator &operator+=(qsizetype j) { item.i += j; return *this; }
0166         ConstIterator &operator-=(qsizetype j) { item.i -= j; return *this; }
0167         ConstIterator operator+(qsizetype j) const { return ConstIterator({ item.d, item.i + j }); }
0168         ConstIterator operator-(qsizetype j) const { return ConstIterator({ item.d, item.i - j }); }
0169         qsizetype operator-(ConstIterator j) const { return item.i - j.item.i; }
0170     private:
0171         // Helper functions
0172         static bool comparesEqual_helper(const ConstIterator &lhs,
0173                                          const ConstIterator &rhs) noexcept
0174         {
0175             return lhs.item.d == rhs.item.d && lhs.item.i == rhs.item.i;
0176         }
0177         static Qt::strong_ordering compareThreeWay_helper(const ConstIterator &lhs,
0178                                                           const ConstIterator &rhs) noexcept
0179         {
0180             Q_ASSERT(lhs.item.d == rhs.item.d);
0181             return Qt::compareThreeWay(lhs.item.i, rhs.item.i);
0182         }
0183 
0184         // Compare friends
0185         friend bool comparesEqual(const ConstIterator &lhs, const ConstIterator &rhs) noexcept
0186         {
0187             return comparesEqual_helper(lhs, rhs);
0188         }
0189         friend Qt::strong_ordering compareThreeWay(const ConstIterator &lhs,
0190                                                    const ConstIterator &rhs) noexcept
0191         {
0192             return compareThreeWay_helper(lhs, rhs);
0193         }
0194         Q_DECLARE_STRONGLY_ORDERED(ConstIterator)
0195     };
0196 
0197     typedef qsizetype size_type;
0198     typedef QCborValue value_type;
0199     typedef value_type *pointer;
0200     typedef const value_type *const_pointer;
0201     typedef QCborValue &reference;
0202     typedef const QCborValue &const_reference;
0203     typedef qsizetype difference_type;
0204 
0205     QCborArray() noexcept;
0206     QCborArray(const QCborArray &other) noexcept;
0207     QCborArray(QCborArray &&other) noexcept = default;
0208     QCborArray &operator=(const QCborArray &other) noexcept;
0209     QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QCborArray)
0210     QCborArray(std::initializer_list<QCborValue> args)
0211         : QCborArray()
0212     {
0213         detach(qsizetype(args.size()));
0214         for (const QCborValue &v : args)
0215             append(v);
0216     }
0217     ~QCborArray();
0218 
0219     void swap(QCborArray &other) noexcept
0220     {
0221         d.swap(other.d);
0222     }
0223 
0224     QCborValue toCborValue() const { return *this; }
0225 
0226     qsizetype size() const noexcept;
0227     bool isEmpty() const { return size() == 0; }
0228     void clear();
0229 
0230     QCborValue at(qsizetype i) const;
0231     QCborValue first() const { return at(0); }
0232     QCborValue last() const { return at(size() - 1); }
0233     const QCborValue operator[](qsizetype i) const { return at(i); }
0234     QCborValueRef first() { Q_ASSERT(!isEmpty()); return begin()[0]; }
0235     QCborValueRef last() { Q_ASSERT(!isEmpty()); return begin()[size() - 1]; }
0236     QCborValueRef operator[](qsizetype i)
0237     {
0238         if (i >= size())
0239             insert(i, QCborValue());
0240         return begin()[i];
0241     }
0242 
0243     void insert(qsizetype i, const QCborValue &value);
0244     void insert(qsizetype i, QCborValue &&value);
0245     void prepend(const QCborValue &value) { insert(0, value); }
0246     void prepend(QCborValue &&value) { insert(0, std::move(value)); }
0247     void append(const QCborValue &value) { insert(-1, value); }
0248     void append(QCborValue &&value) { insert(-1, std::move(value)); }
0249     QCborValue extract(ConstIterator it) { return extract(Iterator{ it.item.d, it.item.i }); }
0250     QCborValue extract(Iterator it);
0251     void removeAt(qsizetype i);
0252     QCborValue takeAt(qsizetype i) { Q_ASSERT(i < size()); return extract(begin() + i); }
0253     void removeFirst() { removeAt(0); }
0254     void removeLast() { removeAt(size() - 1); }
0255     QCborValue takeFirst() { return takeAt(0); }
0256     QCborValue takeLast() { return takeAt(size() - 1); }
0257 
0258     bool contains(const QCborValue &value) const;
0259 
0260     int compare(const QCborArray &other) const noexcept Q_DECL_PURE_FUNCTION;
0261 #if QT_CORE_REMOVED_SINCE(6, 8)
0262     bool operator==(const QCborArray &other) const noexcept
0263     { return compare(other) == 0; }
0264     bool operator!=(const QCborArray &other) const noexcept
0265     { return !operator==(other); }
0266     bool operator<(const QCborArray &other) const
0267     { return compare(other) < 0; }
0268 #endif
0269 
0270     typedef Iterator iterator;
0271     typedef ConstIterator const_iterator;
0272     iterator begin() { detach(); return iterator{d.data(), 0}; }
0273     const_iterator constBegin() const { return const_iterator{d.data(), 0}; }
0274     const_iterator begin() const { return constBegin(); }
0275     const_iterator cbegin() const { return constBegin(); }
0276     iterator end() { detach(); return iterator{d.data(), size()}; }
0277     const_iterator constEnd() const { return const_iterator{d.data(), size()}; }
0278     const_iterator end() const { return constEnd(); }
0279     const_iterator cend() const { return constEnd(); }
0280     iterator insert(iterator before, const QCborValue &value)
0281     { insert(before.item.i, value); return iterator{d.data(), before.item.i}; }
0282     iterator insert(const_iterator before, const QCborValue &value)
0283     { insert(before.item.i, value); return iterator{d.data(), before.item.i}; }
0284     iterator erase(iterator it) { removeAt(it.item.i); return iterator{d.data(), it.item.i}; }
0285     iterator erase(const_iterator it) { removeAt(it.item.i); return iterator{d.data(), it.item.i}; }
0286 
0287     void push_back(const QCborValue &t) { append(t); }
0288     void push_front(const QCborValue &t) { prepend(t); }
0289     void pop_front() { removeFirst(); }
0290     void pop_back() { removeLast(); }
0291     bool empty() const { return isEmpty(); }
0292 
0293     // convenience
0294     QCborArray operator+(const QCborValue &v) const
0295     { QCborArray n = *this; n += v; return n; }
0296     QCborArray &operator+=(const QCborValue &v)
0297     { append(v); return *this; }
0298     QCborArray &operator<<(const QCborValue &v)
0299     { append(v); return *this; }
0300 
0301     static QCborArray fromStringList(const QStringList &list);
0302     static QCborArray fromVariantList(const QVariantList &list);
0303     static QCborArray fromJsonArray(const QJsonArray &array);
0304     static QCborArray fromJsonArray(QJsonArray &&array) noexcept;
0305     QVariantList toVariantList() const;
0306     QJsonArray toJsonArray() const;
0307 
0308 private:
0309     friend Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool
0310     comparesEqual(const QCborArray &lhs, const QCborArray &rhs) noexcept;
0311     friend Qt::strong_ordering compareThreeWay(const QCborArray &lhs,
0312                                                const QCborArray &rhs) noexcept
0313     {
0314         int c = lhs.compare(rhs);
0315         return Qt::compareThreeWay(c, 0);
0316     }
0317     Q_DECLARE_STRONGLY_ORDERED(QCborArray)
0318 
0319     static Q_DECL_PURE_FUNCTION bool
0320     comparesEqual_helper(const QCborArray &lhs, const QCborValue &rhs) noexcept;
0321     static Q_DECL_PURE_FUNCTION Qt::strong_ordering
0322     compareThreeWay_helper(const QCborArray &lhs, const QCborValue &rhs) noexcept;
0323     friend bool comparesEqual(const QCborArray &lhs,
0324                               const QCborValue &rhs) noexcept
0325     {
0326         return comparesEqual_helper(lhs, rhs);
0327     }
0328     friend Qt::strong_ordering compareThreeWay(const QCborArray &lhs,
0329                                                const QCborValue &rhs) noexcept
0330     {
0331         return compareThreeWay_helper(lhs, rhs);
0332     }
0333     Q_DECLARE_STRONGLY_ORDERED(QCborArray, QCborValue)
0334 
0335     static Q_DECL_PURE_FUNCTION bool
0336     comparesEqual_helper(const QCborArray &lhs, QCborValueConstRef rhs) noexcept;
0337     static Q_DECL_PURE_FUNCTION Qt::strong_ordering
0338     compareThreeWay_helper(const QCborArray &lhs, QCborValueConstRef rhs) noexcept;
0339     friend bool comparesEqual(const QCborArray &lhs,
0340                               const QCborValueConstRef &rhs) noexcept
0341     {
0342         return comparesEqual_helper(lhs, rhs);
0343     }
0344     friend Qt::strong_ordering compareThreeWay(const QCborArray &lhs,
0345                                                const QCborValueConstRef &rhs) noexcept
0346     {
0347         return compareThreeWay_helper(lhs, rhs);
0348     }
0349     Q_DECLARE_STRONGLY_ORDERED(QCborArray, QCborValueConstRef)
0350 
0351     void detach(qsizetype reserve = 0);
0352 
0353     friend QCborValue;
0354     friend QCborValueRef;
0355     friend class QJsonPrivate::Variant;
0356     explicit QCborArray(QCborContainerPrivate &dd) noexcept;
0357     QExplicitlySharedDataPointer<QCborContainerPrivate> d;
0358 };
0359 
0360 Q_DECLARE_SHARED(QCborArray)
0361 
0362 inline QCborValue::QCborValue(QCborArray &&a)
0363     : n(-1), container(a.d.take()), t(Array)
0364 {
0365 }
0366 
0367 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
0368 inline QCborArray QCborValueRef::toArray() const
0369 {
0370     return concrete().toArray();
0371 }
0372 
0373 inline QCborArray QCborValueRef::toArray(const QCborArray &a) const
0374 {
0375     return concrete().toArray(a);
0376 }
0377 #endif
0378 
0379 inline QCborArray QCborValueConstRef::toArray() const
0380 {
0381     return concrete().toArray();
0382 }
0383 
0384 inline QCborArray QCborValueConstRef::toArray(const QCborArray &a) const
0385 {
0386     return concrete().toArray(a);
0387 }
0388 
0389 Q_CORE_EXPORT size_t qHash(const QCborArray &array, size_t seed = 0);
0390 
0391 #if !defined(QT_NO_DEBUG_STREAM)
0392 Q_CORE_EXPORT QDebug operator<<(QDebug, const QCborArray &a);
0393 #endif
0394 
0395 #ifndef QT_NO_DATASTREAM
0396 #if QT_CONFIG(cborstreamwriter)
0397 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QCborArray &);
0398 #endif
0399 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QCborArray &);
0400 #endif
0401 
0402 QT_END_NAMESPACE
0403 
0404 #endif // QCBORARRAY_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!