Switch QBitArray to qsizetype
To make it consistent with other containers in Qt6. Change-Id: I5578845390248baf80daa282237b706857e57661 Reviewed-by: Lars Knoll <lars.knoll@qt.io>bb10
Allan Sandfeld Jensen
parent
92e108bff8
commit
a45920c86c
|
|
@ -1,6 +1,6 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2016 The Qt Company Ltd.
|
||||
** Copyright (C) 2020 The Qt Company Ltd.
|
||||
** Copyright (C) 2019 Intel Corporation.
|
||||
** Contact: https://www.qt.io/licensing/
|
||||
**
|
||||
|
|
@ -137,14 +137,14 @@ QT_BEGIN_NAMESPACE
|
|||
* *d.constData() is the QByteArray's terminating NUL (0) byte.
|
||||
*
|
||||
* This allows for fast calculation of the bit array size:
|
||||
* inline int size() const { return (d.size() << 3) - *d.constData(); }
|
||||
* inline qsizetype size() const { return (d.size() << 3) - *d.constData(); }
|
||||
*/
|
||||
|
||||
/*!
|
||||
Constructs a bit array containing \a size bits. The bits are
|
||||
initialized with \a value, which defaults to false (0).
|
||||
*/
|
||||
QBitArray::QBitArray(int size, bool value)
|
||||
QBitArray::QBitArray(qsizetype size, bool value)
|
||||
: d(size <= 0 ? 0 : 1 + (size + 7)/8, Qt::Uninitialized)
|
||||
{
|
||||
Q_ASSERT_X(size >= 0, "QBitArray::QBitArray", "Size must be greater than or equal to 0.");
|
||||
|
|
@ -158,14 +158,14 @@ QBitArray::QBitArray(int size, bool value)
|
|||
*(c+1+size/8) &= (1 << (size & 7)) - 1;
|
||||
}
|
||||
|
||||
/*! \fn int QBitArray::size() const
|
||||
/*! \fn qsizetype QBitArray::size() const
|
||||
|
||||
Returns the number of bits stored in the bit array.
|
||||
|
||||
\sa resize()
|
||||
*/
|
||||
|
||||
/*! \fn int QBitArray::count() const
|
||||
/*! \fn qsizetype QBitArray::count() const
|
||||
|
||||
Same as size().
|
||||
*/
|
||||
|
|
@ -175,9 +175,9 @@ QBitArray::QBitArray(int size, bool value)
|
|||
1-bits stored in the bit array; otherwise the number
|
||||
of 0-bits is returned.
|
||||
*/
|
||||
int QBitArray::count(bool on) const
|
||||
qsizetype QBitArray::count(bool on) const
|
||||
{
|
||||
int numBits = 0;
|
||||
qsizetype numBits = 0;
|
||||
const quint8 *bits = reinterpret_cast<const quint8 *>(d.data()) + 1;
|
||||
|
||||
// the loops below will try to read from *end
|
||||
|
|
@ -187,20 +187,20 @@ int QBitArray::count(bool on) const
|
|||
while (bits + 7 <= end) {
|
||||
quint64 v = qFromUnaligned<quint64>(bits);
|
||||
bits += 8;
|
||||
numBits += int(qPopulationCount(v));
|
||||
numBits += qsizetype(qPopulationCount(v));
|
||||
}
|
||||
if (bits + 3 <= end) {
|
||||
quint32 v = qFromUnaligned<quint32>(bits);
|
||||
bits += 4;
|
||||
numBits += int(qPopulationCount(v));
|
||||
numBits += qsizetype(qPopulationCount(v));
|
||||
}
|
||||
if (bits + 1 < end) {
|
||||
quint16 v = qFromUnaligned<quint16>(bits);
|
||||
bits += 2;
|
||||
numBits += int(qPopulationCount(v));
|
||||
numBits += qsizetype(qPopulationCount(v));
|
||||
}
|
||||
if (bits < end)
|
||||
numBits += int(qPopulationCount(bits[0]));
|
||||
numBits += qsizetype(qPopulationCount(bits[0]));
|
||||
|
||||
return on ? numBits : size() - numBits;
|
||||
}
|
||||
|
|
@ -217,12 +217,12 @@ int QBitArray::count(bool on) const
|
|||
|
||||
\sa size()
|
||||
*/
|
||||
void QBitArray::resize(int size)
|
||||
void QBitArray::resize(qsizetype size)
|
||||
{
|
||||
if (!size) {
|
||||
d.resize(0);
|
||||
} else {
|
||||
int s = d.size();
|
||||
qsizetype s = d.size();
|
||||
d.resize(1 + (size+7)/8);
|
||||
uchar* c = reinterpret_cast<uchar*>(d.data());
|
||||
if (size > (s << 3))
|
||||
|
|
@ -256,7 +256,7 @@ void QBitArray::resize(int size)
|
|||
\sa isEmpty()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::fill(bool value, int size = -1)
|
||||
/*! \fn bool QBitArray::fill(bool value, qsizetype size = -1)
|
||||
|
||||
Sets every bit in the bit array to \a value, returning true if successful;
|
||||
otherwise returns \c false. If \a size is different from -1 (the default),
|
||||
|
|
@ -285,14 +285,14 @@ void QBitArray::resize(int size)
|
|||
\snippet code/src_corelib_tools_qbitarray.cpp 15
|
||||
*/
|
||||
|
||||
void QBitArray::fill(bool value, int begin, int end)
|
||||
void QBitArray::fill(bool value, qsizetype begin, qsizetype end)
|
||||
{
|
||||
while (begin < end && begin & 0x7)
|
||||
setBit(begin++, value);
|
||||
int len = end - begin;
|
||||
qsizetype len = end - begin;
|
||||
if (len <= 0)
|
||||
return;
|
||||
int s = len & ~0x7;
|
||||
qsizetype s = len & ~qsizetype(0x7);
|
||||
uchar *c = reinterpret_cast<uchar*>(d.data());
|
||||
memset(c + (begin >> 3) + 1, value ? 0xff : 0, s >> 3);
|
||||
begin += s;
|
||||
|
|
@ -391,7 +391,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa resize(), isEmpty()
|
||||
*/
|
||||
|
||||
/*! \fn void QBitArray::truncate(int pos)
|
||||
/*! \fn void QBitArray::truncate(qsizetype pos)
|
||||
|
||||
Truncates the bit array at index position \a pos.
|
||||
|
||||
|
|
@ -400,7 +400,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa resize()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::toggleBit(int i)
|
||||
/*! \fn bool QBitArray::toggleBit(qsizetype i)
|
||||
|
||||
Inverts the value of the bit at index position \a i, returning the
|
||||
previous value of that bit as either true (if it was set) or false (if
|
||||
|
|
@ -415,7 +415,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa setBit(), clearBit()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::testBit(int i) const
|
||||
/*! \fn bool QBitArray::testBit(qsizetype i) const
|
||||
|
||||
Returns \c true if the bit at index position \a i is 1; otherwise
|
||||
returns \c false.
|
||||
|
|
@ -426,7 +426,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa setBit(), clearBit()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::setBit(int i)
|
||||
/*! \fn bool QBitArray::setBit(qsizetype i)
|
||||
|
||||
Sets the bit at index position \a i to 1.
|
||||
|
||||
|
|
@ -436,14 +436,14 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa clearBit(), toggleBit()
|
||||
*/
|
||||
|
||||
/*! \fn void QBitArray::setBit(int i, bool value)
|
||||
/*! \fn void QBitArray::setBit(qsizetype i, bool value)
|
||||
|
||||
\overload
|
||||
|
||||
Sets the bit at index position \a i to \a value.
|
||||
*/
|
||||
|
||||
/*! \fn void QBitArray::clearBit(int i)
|
||||
/*! \fn void QBitArray::clearBit(qsizetype i)
|
||||
|
||||
Sets the bit at index position \a i to 0.
|
||||
|
||||
|
|
@ -453,7 +453,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa setBit(), toggleBit()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::at(int i) const
|
||||
/*! \fn bool QBitArray::at(qsizetype i) const
|
||||
|
||||
Returns the value of the bit at index position \a i.
|
||||
|
||||
|
|
@ -463,7 +463,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa operator[]()
|
||||
*/
|
||||
|
||||
/*! \fn QBitRef QBitArray::operator[](int i)
|
||||
/*! \fn QBitRef QBitArray::operator[](qsizetype i)
|
||||
|
||||
Returns the bit at index position \a i as a modifiable reference.
|
||||
|
||||
|
|
@ -484,17 +484,7 @@ quint32 QBitArray::toUInt32(QSysInfo::Endian endianness, bool *ok) const noexcep
|
|||
\sa at(), testBit(), setBit(), clearBit()
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::operator[](int i) const
|
||||
|
||||
\overload
|
||||
*/
|
||||
|
||||
/*! \fn QBitRef QBitArray::operator[](uint i)
|
||||
|
||||
\overload
|
||||
*/
|
||||
|
||||
/*! \fn bool QBitArray::operator[](uint i) const
|
||||
/*! \fn bool QBitArray::operator[](qsizetype i) const
|
||||
|
||||
\overload
|
||||
*/
|
||||
|
|
@ -567,8 +557,8 @@ QBitArray &QBitArray::operator&=(const QBitArray &other)
|
|||
resize(qMax(size(), other.size()));
|
||||
uchar *a1 = reinterpret_cast<uchar*>(d.data()) + 1;
|
||||
const uchar *a2 = reinterpret_cast<const uchar*>(other.d.constData()) + 1;
|
||||
int n = other.d.size() -1 ;
|
||||
int p = d.size() - 1 - n;
|
||||
qsizetype n = other.d.size() -1 ;
|
||||
qsizetype p = d.size() - 1 - n;
|
||||
while (n-- > 0)
|
||||
*a1++ &= *a2++;
|
||||
while (p-- > 0)
|
||||
|
|
@ -596,7 +586,7 @@ QBitArray &QBitArray::operator|=(const QBitArray &other)
|
|||
resize(qMax(size(), other.size()));
|
||||
uchar *a1 = reinterpret_cast<uchar*>(d.data()) + 1;
|
||||
const uchar *a2 = reinterpret_cast<const uchar *>(other.d.constData()) + 1;
|
||||
int n = other.d.size() - 1;
|
||||
qsizetype n = other.d.size() - 1;
|
||||
while (n-- > 0)
|
||||
*a1++ |= *a2++;
|
||||
return *this;
|
||||
|
|
@ -622,7 +612,7 @@ QBitArray &QBitArray::operator^=(const QBitArray &other)
|
|||
resize(qMax(size(), other.size()));
|
||||
uchar *a1 = reinterpret_cast<uchar*>(d.data()) + 1;
|
||||
const uchar *a2 = reinterpret_cast<const uchar *>(other.d.constData()) + 1;
|
||||
int n = other.d.size() - 1;
|
||||
qsizetype n = other.d.size() - 1;
|
||||
while (n-- > 0)
|
||||
*a1++ ^= *a2++;
|
||||
return *this;
|
||||
|
|
@ -640,11 +630,11 @@ QBitArray &QBitArray::operator^=(const QBitArray &other)
|
|||
|
||||
QBitArray QBitArray::operator~() const
|
||||
{
|
||||
int sz = size();
|
||||
qsizetype sz = size();
|
||||
QBitArray a(sz);
|
||||
const uchar *a1 = reinterpret_cast<const uchar *>(d.constData()) + 1;
|
||||
uchar *a2 = reinterpret_cast<uchar*>(a.d.data()) + 1;
|
||||
int n = d.size() - 1;
|
||||
qsizetype n = d.size() - 1;
|
||||
|
||||
while (n-- > 0)
|
||||
*a2++ = ~*a1++;
|
||||
|
|
@ -735,7 +725,7 @@ QBitArray operator^(const QBitArray &a1, const QBitArray &a2)
|
|||
It is not for use in any other context.
|
||||
*/
|
||||
|
||||
/*! \fn QBitRef::QBitRef (QBitArray& a, int i)
|
||||
/*! \fn QBitRef::QBitRef (QBitArray& a, qsizetype i)
|
||||
|
||||
Constructs a reference to element \a i in the QBitArray \a a.
|
||||
This is what QBitArray::operator[] constructs its return value
|
||||
|
|
@ -780,11 +770,19 @@ QBitArray operator^(const QBitArray &a1, const QBitArray &a2)
|
|||
|
||||
QDataStream &operator<<(QDataStream &out, const QBitArray &ba)
|
||||
{
|
||||
quint32 len = ba.size();
|
||||
out << len;
|
||||
if (len > 0)
|
||||
out.writeRawData(ba.d.constData() + 1, ba.d.size() - 1);
|
||||
return out;
|
||||
if (out.version() < QDataStream::Qt_6_0) {
|
||||
quint32 len = ba.size();
|
||||
out << len;
|
||||
if (len > 0)
|
||||
out.writeRawData(ba.d.constData() + 1, ba.d.size() - 1);
|
||||
return out;
|
||||
} else {
|
||||
quint64 len = ba.size();
|
||||
out << len;
|
||||
if (len > 0)
|
||||
out.writeRawData(ba.d.constData() + 1, ba.d.size() - 1);
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -798,19 +796,27 @@ QDataStream &operator<<(QDataStream &out, const QBitArray &ba)
|
|||
QDataStream &operator>>(QDataStream &in, QBitArray &ba)
|
||||
{
|
||||
ba.clear();
|
||||
quint32 len;
|
||||
in >> len;
|
||||
qsizetype len;
|
||||
if (in.version() < QDataStream::Qt_6_0) {
|
||||
quint32 tmp;
|
||||
in >> tmp;
|
||||
len = tmp;
|
||||
} else {
|
||||
quint64 tmp;
|
||||
in >> tmp;
|
||||
len = tmp;
|
||||
}
|
||||
if (len == 0) {
|
||||
ba.clear();
|
||||
return in;
|
||||
}
|
||||
|
||||
const quint32 Step = 8 * 1024 * 1024;
|
||||
quint32 totalBytes = (len + 7) / 8;
|
||||
quint32 allocated = 0;
|
||||
const qsizetype Step = 8 * 1024 * 1024;
|
||||
qsizetype totalBytes = (len + 7) / 8;
|
||||
qsizetype allocated = 0;
|
||||
|
||||
while (allocated < totalBytes) {
|
||||
int blockSize = qMin(Step, totalBytes - allocated);
|
||||
qsizetype blockSize = qMin(Step, totalBytes - allocated);
|
||||
ba.d.resize(allocated + blockSize + 1);
|
||||
if (in.readRawData(ba.d.data() + 1 + allocated, blockSize) != blockSize) {
|
||||
ba.clear();
|
||||
|
|
@ -820,7 +826,7 @@ QDataStream &operator>>(QDataStream &in, QBitArray &ba)
|
|||
allocated += blockSize;
|
||||
}
|
||||
|
||||
int paddingMask = ~((0x1 << (len & 0x7)) - 1);
|
||||
qsizetype paddingMask = ~((0x1 << (len & 0x7)) - 1);
|
||||
if (paddingMask != ~0x0 && (ba.d.constData()[ba.d.size() - 1] & paddingMask)) {
|
||||
ba.clear();
|
||||
in.setStatus(QDataStream::ReadCorruptData);
|
||||
|
|
@ -837,7 +843,7 @@ QDebug operator<<(QDebug dbg, const QBitArray &array)
|
|||
{
|
||||
QDebugStateSaver saver(dbg);
|
||||
dbg.nospace() << "QBitArray(";
|
||||
for (int i = 0; i < array.size();) {
|
||||
for (qsizetype i = 0; i < array.size();) {
|
||||
if (array.testBit(i))
|
||||
dbg << '1';
|
||||
else
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2016 The Qt Company Ltd.
|
||||
** Copyright (C) 2020 The Qt Company Ltd.
|
||||
** Contact: https://www.qt.io/licensing/
|
||||
**
|
||||
** This file is part of the QtCore module of the Qt Toolkit.
|
||||
|
|
@ -57,7 +57,7 @@ class Q_CORE_EXPORT QBitArray
|
|||
|
||||
public:
|
||||
inline QBitArray() noexcept {}
|
||||
explicit QBitArray(int size, bool val = false);
|
||||
explicit QBitArray(qsizetype size, bool val = false);
|
||||
QBitArray(const QBitArray &other) : d(other.d) {}
|
||||
inline QBitArray &operator=(const QBitArray &other) { d = other.d; return *this; }
|
||||
inline QBitArray(QBitArray &&other) noexcept : d(std::move(other.d)) {}
|
||||
|
|
@ -66,30 +66,28 @@ public:
|
|||
|
||||
inline void swap(QBitArray &other) noexcept { qSwap(d, other.d); }
|
||||
|
||||
inline int size() const { return (d.size() << 3) - *d.constData(); }
|
||||
inline int count() const { return (d.size() << 3) - *d.constData(); }
|
||||
int count(bool on) const;
|
||||
inline qsizetype size() const { return (d.size() << 3) - *d.constData(); }
|
||||
inline qsizetype count() const { return (d.size() << 3) - *d.constData(); }
|
||||
qsizetype count(bool on) const;
|
||||
|
||||
inline bool isEmpty() const { return d.isEmpty(); }
|
||||
inline bool isNull() const { return d.isNull(); }
|
||||
|
||||
void resize(int size);
|
||||
void resize(qsizetype size);
|
||||
|
||||
inline void detach() { d.detach(); }
|
||||
inline bool isDetached() const { return d.isDetached(); }
|
||||
inline void clear() { d.clear(); }
|
||||
|
||||
bool testBit(int i) const;
|
||||
void setBit(int i);
|
||||
void setBit(int i, bool val);
|
||||
void clearBit(int i);
|
||||
bool toggleBit(int i);
|
||||
bool testBit(qsizetype i) const;
|
||||
void setBit(qsizetype i);
|
||||
void setBit(qsizetype i, bool val);
|
||||
void clearBit(qsizetype i);
|
||||
bool toggleBit(qsizetype i);
|
||||
|
||||
bool at(int i) const;
|
||||
QBitRef operator[](int i);
|
||||
bool operator[](int i) const;
|
||||
QBitRef operator[](uint i);
|
||||
bool operator[](uint i) const;
|
||||
bool at(qsizetype i) const;
|
||||
QBitRef operator[](qsizetype i);
|
||||
bool operator[](qsizetype i) const;
|
||||
|
||||
QBitArray& operator&=(const QBitArray &);
|
||||
QBitArray& operator|=(const QBitArray &);
|
||||
|
|
@ -99,10 +97,10 @@ public:
|
|||
inline bool operator==(const QBitArray& other) const { return d == other.d; }
|
||||
inline bool operator!=(const QBitArray& other) const { return d != other.d; }
|
||||
|
||||
inline bool fill(bool val, int size = -1);
|
||||
void fill(bool val, int first, int last);
|
||||
inline bool fill(bool val, qsizetype size = -1);
|
||||
void fill(bool val, qsizetype first, qsizetype last);
|
||||
|
||||
inline void truncate(int pos) { if (pos < size()) resize(pos); }
|
||||
inline void truncate(qsizetype pos) { if (pos < size()) resize(pos); }
|
||||
|
||||
const char *bits() const { return isEmpty() ? nullptr : d.constData() + 1; }
|
||||
static QBitArray fromBits(const char *data, qsizetype len);
|
||||
|
|
@ -114,43 +112,42 @@ public:
|
|||
inline DataPtr &data_ptr() { return d.data_ptr(); }
|
||||
};
|
||||
|
||||
inline bool QBitArray::fill(bool aval, int asize)
|
||||
inline bool QBitArray::fill(bool aval, qsizetype asize)
|
||||
{ *this = QBitArray((asize < 0 ? this->size() : asize), aval); return true; }
|
||||
|
||||
Q_CORE_EXPORT QBitArray operator&(const QBitArray &, const QBitArray &);
|
||||
Q_CORE_EXPORT QBitArray operator|(const QBitArray &, const QBitArray &);
|
||||
Q_CORE_EXPORT QBitArray operator^(const QBitArray &, const QBitArray &);
|
||||
|
||||
inline bool QBitArray::testBit(int i) const
|
||||
{ Q_ASSERT(uint(i) < uint(size()));
|
||||
inline bool QBitArray::testBit(qsizetype i) const
|
||||
{ Q_ASSERT(size_t(i) < size_t(size()));
|
||||
return (*(reinterpret_cast<const uchar*>(d.constData())+1+(i>>3)) & (1 << (i & 7))) != 0; }
|
||||
|
||||
inline void QBitArray::setBit(int i)
|
||||
{ Q_ASSERT(uint(i) < uint(size()));
|
||||
inline void QBitArray::setBit(qsizetype i)
|
||||
{ Q_ASSERT(size_t(i) < size_t(size()));
|
||||
*(reinterpret_cast<uchar*>(d.data())+1+(i>>3)) |= uchar(1 << (i & 7)); }
|
||||
|
||||
inline void QBitArray::clearBit(int i)
|
||||
{ Q_ASSERT(uint(i) < uint(size()));
|
||||
inline void QBitArray::clearBit(qsizetype i)
|
||||
{ Q_ASSERT(size_t(i) < size_t(size()));
|
||||
*(reinterpret_cast<uchar*>(d.data())+1+(i>>3)) &= ~uchar(1 << (i & 7)); }
|
||||
|
||||
inline void QBitArray::setBit(int i, bool val)
|
||||
inline void QBitArray::setBit(qsizetype i, bool val)
|
||||
{ if (val) setBit(i); else clearBit(i); }
|
||||
|
||||
inline bool QBitArray::toggleBit(int i)
|
||||
{ Q_ASSERT(uint(i) < uint(size()));
|
||||
inline bool QBitArray::toggleBit(qsizetype i)
|
||||
{ Q_ASSERT(size_t(i) < size_t(size()));
|
||||
uchar b = uchar(1<<(i&7)); uchar* p = reinterpret_cast<uchar*>(d.data())+1+(i>>3);
|
||||
uchar c = uchar(*p&b); *p^=b; return c!=0; }
|
||||
|
||||
inline bool QBitArray::operator[](int i) const { return testBit(i); }
|
||||
inline bool QBitArray::operator[](uint i) const { return testBit(i); }
|
||||
inline bool QBitArray::at(int i) const { return testBit(i); }
|
||||
inline bool QBitArray::operator[](qsizetype i) const { return testBit(i); }
|
||||
inline bool QBitArray::at(qsizetype i) const { return testBit(i); }
|
||||
|
||||
class Q_CORE_EXPORT QBitRef
|
||||
{
|
||||
private:
|
||||
QBitArray& a;
|
||||
int i;
|
||||
inline QBitRef(QBitArray& array, int idx) : a(array), i(idx) {}
|
||||
qsizetype i;
|
||||
inline QBitRef(QBitArray& array, qsizetype idx) : a(array), i(idx) {}
|
||||
friend class QBitArray;
|
||||
public:
|
||||
inline operator bool() const { return a.testBit(i); }
|
||||
|
|
@ -159,11 +156,8 @@ public:
|
|||
QBitRef& operator=(bool val) { a.setBit(i, val); return *this; }
|
||||
};
|
||||
|
||||
inline QBitRef QBitArray::operator[](int i)
|
||||
inline QBitRef QBitArray::operator[](qsizetype i)
|
||||
{ Q_ASSERT(i >= 0); return QBitRef(*this, i); }
|
||||
inline QBitRef QBitArray::operator[](uint i)
|
||||
{ return QBitRef(*this, i); }
|
||||
|
||||
|
||||
#ifndef QT_NO_DATASTREAM
|
||||
Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QBitArray &);
|
||||
|
|
|
|||
|
|
@ -549,12 +549,12 @@ size_t qHash(QStringView key, size_t seed) noexcept
|
|||
|
||||
size_t qHash(const QBitArray &bitArray, size_t seed) noexcept
|
||||
{
|
||||
int m = bitArray.d.size() - 1;
|
||||
qsizetype m = bitArray.d.size() - 1;
|
||||
size_t result = qHashBits(reinterpret_cast<const uchar *>(bitArray.d.constData()), size_t(qMax(0, m)), seed);
|
||||
|
||||
// deal with the last 0 to 7 bits manually, because we can't trust that
|
||||
// the padding is initialized to 0 in bitArray.d
|
||||
int n = bitArray.size();
|
||||
qsizetype n = bitArray.size();
|
||||
if (n & 0x7)
|
||||
result = ((result << 4) + bitArray.d.at(m)) & ((1 << n) - 1);
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -3005,6 +3005,7 @@ void tst_QDataStream::status_QBitArray()
|
|||
QFETCH(QBitArray, expectedString);
|
||||
|
||||
QDataStream stream(&data, QIODevice::ReadOnly);
|
||||
stream.setVersion(QDataStream::Qt_5_15);
|
||||
QBitArray str;
|
||||
stream >> str;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue