include/QtCore/qbitarray.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
0004 #ifndef QBITARRAY_H
0005 #define QBITARRAY_H
0006
0007 #include <QtCore/qbytearray.h>
0008
0009 QT_BEGIN_NAMESPACE
0010
0011 class QBitRef;
0012 class Q_CORE_EXPORT QBitArray
0013 {
0014     Q_CORE_EXPORT friend QBitArray operator&(const QBitArray &a1, const QBitArray &a2);
0015     friend QBitArray operator&(QBitArray &&a1, const QBitArray &a2)
0016     { return a1 &= a2; }
0017     friend QBitArray operator&(const QBitArray &a1, QBitArray &&a2)
0018     { return a2 &= a1; }
0019     friend QBitArray operator&(QBitArray &&a1, QBitArray &&a2)
0020     { return a1 &= a2; }
0021
0022     Q_CORE_EXPORT friend QBitArray operator|(const QBitArray &a1, const QBitArray &a2);
0023     friend QBitArray operator|(QBitArray &&a1, const QBitArray &a2)
0024     { return a1 |= a2; }
0025     friend QBitArray operator|(const QBitArray &a1, QBitArray &&a2)
0026     { return a2 |= a1; }
0027     friend QBitArray operator|(QBitArray &&a1, QBitArray &&a2)
0028     { return a1 |= a2; }
0029
0030     Q_CORE_EXPORT friend QBitArray operator^(const QBitArray &a1, const QBitArray &a2);
0031     friend QBitArray operator^(QBitArray &&a1, const QBitArray &a2)
0032     { return a1 ^= a2; }
0033     friend QBitArray operator^(const QBitArray &a1, QBitArray &&a2)
0034     { return a2 ^= a1; }
0035     friend QBitArray operator^(QBitArray &&a1, QBitArray &&a2)
0036     { return a1 ^= a2; }
0037
0038 #ifndef QT_NO_DATASTREAM
0039     friend Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QBitArray &);
0040     friend Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QBitArray &);
0041 #endif
0042     friend Q_CORE_EXPORT size_t qHash(const QBitArray &key, size_t seed) noexcept;
0043     friend QBitArray operator~(QBitArray a)
0044     { return std::move(a).inverted_inplace(); }
0045     QByteArray d;
0046
0047     QBitArray(QByteArrayData &&dd) : d(std::move(dd)) {}
0048
0049     template <typename BitArray> static auto bitLocation(BitArray &ba, qsizetype i)
0050     {
0051         Q_ASSERT(size_t(i) < size_t(ba.size()));
0052         struct R {
0053             decltype(ba.d[1]) byte;
0054             uchar bitMask;
0055         };
0056         qsizetype byteIdx = i >> 3;
0057         qsizetype bitIdx = i & 7;
0058         return R{ ba.d[1 + byteIdx], uchar(1U << bitIdx) };
0059     }
0060
0061     QBitArray inverted_inplace() &&;
0062
0063 public:
0064     inline QBitArray() noexcept {}
0065     explicit QBitArray(qsizetype size, bool val = false);
0066     // Rule Of Zero applies
0067 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
0068     QBitArray(const QBitArray &other) noexcept : d(other.d) {}
0069     inline QBitArray &operator=(const QBitArray &other) noexcept { d = other.d; return *this; }
0070     inline QBitArray(QBitArray &&other) noexcept : d(std::move(other.d)) {}
0071     QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QBitArray)
0072 #endif // Qt 6
0073
0074     void swap(QBitArray &other) noexcept { d.swap(other.d); }
0075
0076     qsizetype size() const { return qsizetype((size_t(d.size()) << 3) - *d.constData()); }
0077     qsizetype count() const { return size(); }
0078     qsizetype count(bool on) const;
0079
0080     inline bool isEmpty() const { return d.isEmpty(); }
0081     inline bool isNull() const { return d.isNull(); }
0082
0083     void resize(qsizetype size);
0084
0085     inline void detach() { d.detach(); }
0086     inline bool isDetached() const { return d.isDetached(); }
0087     inline void clear() { d.clear(); }
0088
0089     bool testBit(qsizetype i) const
0090     { auto r = bitLocation(*this, i); return r.byte & r.bitMask; }
0091     void setBit(qsizetype i)
0092     { auto r = bitLocation(*this, i); r.byte |= r.bitMask; }
0093     void setBit(qsizetype i, bool val)
0094     { if (val) setBit(i); else clearBit(i); }
0095     void clearBit(qsizetype i)
0096     { auto r = bitLocation(*this, i); r.byte &= ~r.bitMask; }
0097     bool toggleBit(qsizetype i)
0098     {
0099         auto r = bitLocation(*this, i);
0100         bool cl = r.byte & r.bitMask;
0101         r.byte ^= r.bitMask;
0102         return cl;
0103     }
0104
0105     bool at(qsizetype i) const { return testBit(i); }
0106     inline QBitRef operator[](qsizetype i);
0107     bool operator[](qsizetype i) const { return testBit(i); }
0108
0109     QBitArray &operator&=(QBitArray &&);
0110     QBitArray &operator|=(QBitArray &&);
0111     QBitArray &operator^=(QBitArray &&);
0112     QBitArray &operator&=(const QBitArray &);
0113     QBitArray &operator|=(const QBitArray &);
0114     QBitArray &operator^=(const QBitArray &);
0115 #if QT_CORE_REMOVED_SINCE(6, 7)
0116     QBitArray operator~() const;
0117 #endif
0118
0119 #if QT_CORE_REMOVED_SINCE(6, 8)
0120     inline bool operator==(const QBitArray &other) const { return comparesEqual(d, other.d); }
0121     inline bool operator!=(const QBitArray &other) const { return !operator==(other); }
0122 #endif
0123
0124     bool fill(bool aval, qsizetype asize = -1)
0125     { *this = QBitArray((asize < 0 ? this->size() : asize), aval); return true; }
0126     void fill(bool val, qsizetype first, qsizetype last);
0127
0128     inline void truncate(qsizetype pos) { if (pos < size()) resize(pos); }
0129
0130     const char *bits() const { return isEmpty() ? nullptr : d.constData() + 1; }
0131     static QBitArray fromBits(const char *data, qsizetype len);
0132
0133     quint32 toUInt32(QSysInfo::Endian endianness, bool *ok = nullptr) const noexcept;
0134
0135 public:
0136     typedef QByteArray::DataPointer DataPtr;
0137     inline DataPtr &data_ptr() { return d.data_ptr(); }
0138     inline const DataPtr &data_ptr() const { return d.data_ptr(); }
0139
0140 private:
0141     friend bool comparesEqual(const QBitArray &lhs, const QBitArray &rhs) noexcept
0142     {
0143         return lhs.d == rhs.d;
0144     }
0145     Q_DECLARE_EQUALITY_COMPARABLE(QBitArray)
0146 };
0147
0148 class QT6_ONLY(Q_CORE_EXPORT) QBitRef
0149 {
0150 private:
0151     QBitArray &a;
0152     qsizetype i;
0153     inline QBitRef(QBitArray &array, qsizetype idx) : a(array), i(idx) { }
0154     friend class QBitArray;
0155
0156 public:
0157     inline operator bool() const { return a.testBit(i); }
0158     inline bool operator!() const { return !a.testBit(i); }
0159     QBitRef &operator=(const QBitRef &val) { a.setBit(i, val); return *this; }
0160     QBitRef &operator=(bool val) { a.setBit(i, val); return *this; }
0161 };
0162
0163 QBitRef QBitArray::operator[](qsizetype i)
0164 { Q_ASSERT(i >= 0); return QBitRef(*this, i); }
0165
0166 #ifndef QT_NO_DATASTREAM
0167 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QBitArray &);
0168 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QBitArray &);
0169 #endif
0170
0171 #ifndef QT_NO_DEBUG_STREAM
0172 Q_CORE_EXPORT QDebug operator<<(QDebug, const QBitArray &);
0173 #endif
0174
0175 Q_DECLARE_SHARED(QBitArray)
0176
0177 QT_END_NAMESPACE
0178
0179 #endif // QBITARRAY_H