Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-09-17 09:09:10 

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