diff options
Diffstat (limited to 'src/corelib/text/qbytearray.cpp')
| -rw-r--r-- | src/corelib/text/qbytearray.cpp | 1044 |
1 files changed, 676 insertions, 368 deletions
diff --git a/src/corelib/text/qbytearray.cpp b/src/corelib/text/qbytearray.cpp index e6f8352d07..e6387e4bed 100644 --- a/src/corelib/text/qbytearray.cpp +++ b/src/corelib/text/qbytearray.cpp @@ -14,14 +14,17 @@ #include "private/qsimd_p.h" #include "qstringalgorithms_p.h" #include "qscopedpointer.h" -#include "qbytearray_p.h" #include "qstringconverter_p.h" #include <qdatastream.h> #include <qmath.h> +#if defined(Q_OS_WASM) +#include "private/qstdweb_p.h" +#endif #ifndef QT_NO_COMPRESS #include <zconf.h> #include <zlib.h> +#include <qxpfunctional.h> #endif #include <ctype.h> #include <limits.h> @@ -30,7 +33,13 @@ #include <algorithm> -#define IS_RAW_DATA(d) ((d)->flags() & QArrayData::RawDataType) +#ifdef Q_OS_WIN +# if !defined(QT_BOOTSTRAPPED) && (defined(QT_NO_CAST_FROM_ASCII) || defined(QT_NO_CAST_FROM_BYTEARRAY)) +// MSVC requires this, but let's apply it to MinGW compilers too, just in case +# error "This file cannot be compiled with QT_NO_CAST_{TO,FROM}_ASCII, " \ + "otherwise some QByteArray functions will not get exported." +# endif +#endif QT_BEGIN_NAMESPACE @@ -110,31 +119,30 @@ char *qstrcpy(char *dst, const char *src) A safe \c strncpy() function. Copies at most \a len bytes from \a src (stopping at \a len or the - terminating '\\0' whichever comes first) into \a dst and returns a - pointer to \a dst. Guarantees that \a dst is '\\0'-terminated. If - \a src or \a dst is \nullptr, returns \nullptr immediately. + terminating '\\0' whichever comes first) into \a dst. Guarantees that \a + dst is '\\0'-terminated, except when \a dst is \nullptr or \a len is 0. If + \a src is \nullptr, returns \nullptr, otherwise returns \a dst. This function assumes that \a dst is at least \a len characters long. \note If \a dst and \a src overlap, the behavior is undefined. + \note Unlike strncpy(), this function does \e not write '\\0' to all \a + len bytes of \a dst, but stops after the terminating '\\0'. In this sense, + it's similar to C11's strncpy_s(). + \sa qstrcpy() */ char *qstrncpy(char *dst, const char *src, size_t len) { - if (!src || !dst) - return nullptr; - if (len > 0) { -#ifdef Q_CC_MSVC - strncpy_s(dst, len, src, len - 1); -#else - strncpy(dst, src, len); -#endif - dst[len-1] = '\0'; + if (dst && len > 0) { + *dst = '\0'; + if (src) + std::strncat(dst, src, len - 1); } - return dst; + return src ? dst : nullptr; } /*! \fn size_t qstrlen(const char *str) @@ -275,7 +283,7 @@ int qstricmp(const char *str1, const char *str2) // yes, find out where uint start = qCountTrailingZeroBits(mask); uint end = sizeof(mask) * 8 - qCountLeadingZeroBits(mask); - Q_ASSUME(end >= start); + Q_ASSERT(end >= start); offset += start; n = end - start; break; @@ -508,7 +516,9 @@ quint16 qChecksum(QByteArrayView data, Qt::ChecksumType standard) \sa qUncompress(const QByteArray &data) */ -/*! \relates QByteArray +/*! + \fn QByteArray qCompress(const uchar* data, qsizetype nbytes, int compressionLevel) + \relates QByteArray \overload @@ -517,44 +527,196 @@ quint16 qChecksum(QByteArrayView data, Qt::ChecksumType standard) */ #ifndef QT_NO_COMPRESS +using CompressSizeHint_t = quint32; // 32-bit BE, historically + +enum class ZLibOp : bool { Compression, Decompression }; + +Q_DECL_COLD_FUNCTION +static const char *zlibOpAsString(ZLibOp op) +{ + switch (op) { + case ZLibOp::Compression: return "qCompress"; + case ZLibOp::Decompression: return "qUncompress"; + } + Q_UNREACHABLE_RETURN(nullptr); +} + +Q_DECL_COLD_FUNCTION +static QByteArray zlibError(ZLibOp op, const char *what) +{ + qWarning("%s: %s", zlibOpAsString(op), what); + return QByteArray(); +} + +Q_DECL_COLD_FUNCTION +static QByteArray dataIsNull(ZLibOp op) +{ + return zlibError(op, "Data is null"); +} + +Q_DECL_COLD_FUNCTION +static QByteArray lengthIsNegative(ZLibOp op) +{ + return zlibError(op, "Input length is negative"); +} + +Q_DECL_COLD_FUNCTION +static QByteArray tooMuchData(ZLibOp op) +{ + return zlibError(op, "Not enough memory"); +} + +Q_DECL_COLD_FUNCTION +static QByteArray invalidCompressedData() +{ + return zlibError(ZLibOp::Decompression, "Input data is corrupted"); +} + +Q_DECL_COLD_FUNCTION +static QByteArray unexpectedZlibError(ZLibOp op, int err, const char *msg) +{ + qWarning("%s unexpected zlib error: %s (%d)", + zlibOpAsString(op), + msg ? msg : "", + err); + return QByteArray(); +} + +static QByteArray xxflate(ZLibOp op, QArrayDataPointer<char> out, QByteArrayView input, + qxp::function_ref<int(z_stream *) const> init, + qxp::function_ref<int(z_stream *, size_t) const> processChunk, + qxp::function_ref<void(z_stream *) const> deinit) +{ + if (out.data() == nullptr) // allocation failed + return tooMuchData(op); + qsizetype capacity = out.allocatedCapacity(); + + const auto initalSize = out.size; + + z_stream zs = {}; + zs.next_in = reinterpret_cast<uchar *>(const_cast<char *>(input.data())); // 1980s C API... + if (const int err = init(&zs); err != Z_OK) + return unexpectedZlibError(op, err, zs.msg); + const auto sg = qScopeGuard([&] { deinit(&zs); }); + + using ZlibChunkSize_t = decltype(zs.avail_in); + static_assert(!std::is_signed_v<ZlibChunkSize_t>); + static_assert(std::is_same_v<ZlibChunkSize_t, decltype(zs.avail_out)>); + constexpr auto MaxChunkSize = std::numeric_limits<ZlibChunkSize_t>::max(); + [[maybe_unused]] + constexpr auto MaxStatisticsSize = std::numeric_limits<decltype(zs.total_out)>::max(); + + size_t inputLeft = size_t(input.size()); + + int res; + do { + Q_ASSERT(out.freeSpaceAtBegin() == 0); // ensure prepend optimization stays out of the way + Q_ASSERT(capacity == out.allocatedCapacity()); + + if (zs.avail_out == 0) { + Q_ASSERT(size_t(out.size) - initalSize > MaxStatisticsSize || // total_out overflow + size_t(out.size) - initalSize == zs.total_out); + Q_ASSERT(out.size <= capacity); + + qsizetype avail_out = capacity - out.size; + if (avail_out == 0) { + out->reallocateAndGrow(QArrayData::GrowsAtEnd, 1); // grow to next natural capacity + if (out.data() == nullptr) // reallocation failed + return tooMuchData(op); + capacity = out.allocatedCapacity(); + avail_out = capacity - out.size; + } + zs.next_out = reinterpret_cast<uchar *>(out.data()) + out.size; + zs.avail_out = size_t(avail_out) > size_t(MaxChunkSize) ? MaxChunkSize + : ZlibChunkSize_t(avail_out); + out.size += zs.avail_out; + + Q_ASSERT(zs.avail_out > 0); + } + + if (zs.avail_in == 0) { + // zs.next_in is kept up-to-date by processChunk(), so nothing to do + zs.avail_in = inputLeft > MaxChunkSize ? MaxChunkSize : ZlibChunkSize_t(inputLeft); + inputLeft -= zs.avail_in; + } + + res = processChunk(&zs, inputLeft); + } while (res == Z_OK); + + switch (res) { + case Z_STREAM_END: + out.size -= zs.avail_out; + Q_ASSERT(size_t(out.size) - initalSize > MaxStatisticsSize || // total_out overflow + size_t(out.size) - initalSize == zs.total_out); + Q_ASSERT(out.size <= out.allocatedCapacity()); + out.data()[out.size] = '\0'; + return QByteArray(std::move(out)); + + case Z_MEM_ERROR: + return tooMuchData(op); + + case Z_BUF_ERROR: + Q_UNREACHABLE(); // cannot happen - we supply a buffer that can hold the result, + // or else error out early + + case Z_DATA_ERROR: // can only happen on decompression + Q_ASSERT(op == ZLibOp::Decompression); + return invalidCompressedData(); + + default: + return unexpectedZlibError(op, res, zs.msg); + } +} + QByteArray qCompress(const uchar* data, qsizetype nbytes, int compressionLevel) { + constexpr qsizetype HeaderSize = sizeof(CompressSizeHint_t); if (nbytes == 0) { - return QByteArray(4, '\0'); - } - if (!data) { - qWarning("qCompress: Data is null"); - return QByteArray(); + return QByteArray(HeaderSize, '\0'); } + if (!data) + return dataIsNull(ZLibOp::Compression); + + if (nbytes < 0) + return lengthIsNegative(ZLibOp::Compression); + if (compressionLevel < -1 || compressionLevel > 9) compressionLevel = -1; - ulong len = nbytes + nbytes / 100 + 13; - QByteArray bazip; - int res; - do { - bazip.resize(len + 4); - res = ::compress2((uchar*)bazip.data()+4, &len, data, nbytes, compressionLevel); - - switch (res) { - case Z_OK: - bazip.resize(len + 4); - bazip[0] = (nbytes & 0xff000000) >> 24; - bazip[1] = (nbytes & 0x00ff0000) >> 16; - bazip[2] = (nbytes & 0x0000ff00) >> 8; - bazip[3] = (nbytes & 0x000000ff); - break; - case Z_MEM_ERROR: - qWarning("qCompress: Z_MEM_ERROR: Not enough memory"); - bazip.resize(0); - break; - case Z_BUF_ERROR: - len *= 2; - break; + QArrayDataPointer out = [&] { + constexpr qsizetype SingleAllocLimit = 256 * 1024; // the maximum size for which we use + // zlib's compressBound() to guarantee + // the output buffer size is sufficient + // to hold result + qsizetype capacity = HeaderSize; + if (nbytes < SingleAllocLimit) { + // use maximum size + capacity += compressBound(uLong(nbytes)); // cannot overflow (both times)! + return QArrayDataPointer<char>(capacity); } - } while (res == Z_BUF_ERROR); - return bazip; + // for larger buffers, assume it compresses optimally, and + // grow geometrically from there: + constexpr qsizetype MaxCompressionFactor = 1024; // max theoretical factor is 1032 + // cf. http://www.zlib.org/zlib_tech.html, + // but use a nearby power-of-two (faster) + capacity += std::max(qsizetype(compressBound(uLong(SingleAllocLimit))), + nbytes / MaxCompressionFactor); + return QArrayDataPointer<char>(capacity, 0, QArrayData::Grow); + }(); + + if (out.data() == nullptr) // allocation failed + return tooMuchData(ZLibOp::Compression); + + qToBigEndian(qt_saturate<CompressSizeHint_t>(nbytes), out.data()); + out.size = HeaderSize; + + return xxflate(ZLibOp::Compression, std::move(out), {data, nbytes}, + [=] (z_stream *zs) { return deflateInit(zs, compressionLevel); }, + [] (z_stream *zs, size_t inputLeft) { + return deflate(zs, inputLeft ? Z_NO_FLUSH : Z_FINISH); + }, + [] (z_stream *zs) { deflateEnd(zs); }); } #endif @@ -576,18 +738,21 @@ QByteArray qCompress(const uchar* data, qsizetype nbytes, int compressionLevel) data that was compressed using zlib, you first need to prepend a four byte header to the byte array containing the data. The header must contain the expected length (in bytes) of the uncompressed data, - expressed as an unsigned, big-endian, 32-bit integer. + expressed as an unsigned, big-endian, 32-bit integer. This number is + just a hint for the initial size of the output buffer size, + though. If the indicated size is too small to hold the result, the + output buffer size will still be increased until either the output + fits or the system runs out of memory. So, despite the 32-bit + header, this function, on 64-bit platforms, can produce more than + 4GiB of output. + + \note In Qt versions prior to Qt 6.5, more than 2GiB of data + worked unreliably; in Qt versions prior to Qt 6.0, not at all. \sa qCompress() */ #ifndef QT_NO_COMPRESS -static QByteArray invalidCompressedData() -{ - qWarning("qUncompress: Input data is corrupted"); - return QByteArray(); -} - /*! \relates QByteArray \overload @@ -597,64 +762,39 @@ static QByteArray invalidCompressedData() */ QByteArray qUncompress(const uchar* data, qsizetype nbytes) { - if (!data) { - qWarning("qUncompress: Data is null"); - return QByteArray(); - } - if (nbytes <= 4) { - if (nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) - qWarning("qUncompress: Input data is corrupted"); - return QByteArray(); - } - size_t expectedSize = size_t((data[0] << 24) | (data[1] << 16) | - (data[2] << 8) | (data[3] )); - size_t len = qMax(expectedSize, 1ul); - const size_t maxPossibleSize = MaxAllocSize - sizeof(QByteArray::Data); - if (Q_UNLIKELY(len >= maxPossibleSize)) { - // QByteArray does not support that huge size anyway. - return invalidCompressedData(); - } + if (!data) + return dataIsNull(ZLibOp::Decompression); - QByteArray::DataPointer d(QByteArray::Data::allocate(len)); - if (Q_UNLIKELY(d.data() == nullptr)) + if (nbytes < 0) + return lengthIsNegative(ZLibOp::Decompression); + + constexpr qsizetype HeaderSize = sizeof(CompressSizeHint_t); + if (nbytes < HeaderSize) return invalidCompressedData(); - forever { - const auto alloc = len; - int res = ::uncompress((uchar*)d.data(), reinterpret_cast<uLongf*>(&len), - data+4, nbytes-4); - - switch (res) { - case Z_OK: { - Q_ASSERT(len <= alloc); - Q_UNUSED(alloc); - d.data()[len] = '\0'; - d.size = len; - return QByteArray(d); - } + const auto expectedSize = qFromBigEndian<CompressSizeHint_t>(data); + if (nbytes == HeaderSize) { + if (expectedSize != 0) + return invalidCompressedData(); + return QByteArray(); + } - case Z_MEM_ERROR: - qWarning("qUncompress: Z_MEM_ERROR: Not enough memory"); - return QByteArray(); + constexpr auto MaxDecompressedSize = size_t(QByteArray::max_size()); + if constexpr (MaxDecompressedSize < std::numeric_limits<CompressSizeHint_t>::max()) { + if (expectedSize > MaxDecompressedSize) + return tooMuchData(ZLibOp::Decompression); + } - case Z_BUF_ERROR: - len *= 2; - if (Q_UNLIKELY(len >= maxPossibleSize)) { - // QByteArray does not support that huge size anyway. - return invalidCompressedData(); - } else { - // grow the block - d->reallocate(d->allocatedCapacity()*2, QArrayData::Grow); - if (Q_UNLIKELY(d.data() == nullptr)) - return invalidCompressedData(); - } - continue; + // expectedSize may be truncated, so always use at least nbytes + // (larger by at most 1%, according to zlib docs) + qsizetype capacity = std::max(qsizetype(expectedSize), // cannot overflow! + nbytes); - case Z_DATA_ERROR: - qWarning("qUncompress: Z_DATA_ERROR: Input data is corrupted"); - return QByteArray(); - } - } + QArrayDataPointer<char> d(capacity); + return xxflate(ZLibOp::Decompression, std::move(d), {data + HeaderSize, nbytes - HeaderSize}, + [] (z_stream *zs) { return inflateInit(zs); }, + [] (z_stream *zs, size_t) { return inflate(zs, Z_NO_FLUSH); }, + [] (z_stream *zs) { inflateEnd(zs); }); } #endif @@ -669,6 +809,14 @@ QByteArray qUncompress(const uchar* data, qsizetype nbytes) \reentrant + \compares strong + \compareswith strong {const char *} QByteArrayView + \endcompareswith + \compareswith strong QChar char16_t QString QStringView QLatin1StringView \ + QUtf8StringView + When comparing with string types, the content is interpreted as utf-8. + \endcompareswith + QByteArray can be used to store both raw bytes (including '\\0's) and traditional 8-bit '\\0'-terminated strings. Using QByteArray is much more convenient than using \c{const char *}. Behind the @@ -1138,6 +1286,22 @@ QByteArray::iterator QByteArray::erase(QByteArray::const_iterator first, QByteAr return begin() + start; } +/*! + \fn QByteArray::iterator QByteArray::erase(QByteArray::const_iterator it) + + \overload + \since 6.5 + + Removes the character denoted by \c it from the byte array. + Returns an iterator to the character immediately after the + erased character. + + \code + QByteArray ba = "abcdefg"; + auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b" + \endcode +*/ + /*! \fn QByteArray::QByteArray(const QByteArray &other) Constructs a copy of \a other. @@ -1185,6 +1349,9 @@ QByteArray &QByteArray::operator=(const QByteArray & other) noexcept \overload Assigns \a str to this byte array. + + \a str is assumed to point to a null-terminated string, and its length is + determined dynamically. */ QByteArray &QByteArray::operator=(const char *str) @@ -1194,14 +1361,7 @@ QByteArray &QByteArray::operator=(const char *str) } else if (!*str) { d = DataPointer::fromRawData(&_empty, 0); } else { - const qsizetype len = qsizetype(strlen(str)); - const auto capacityAtEnd = d->allocatedCapacity() - d.freeSpaceAtBegin(); - if (d->needsDetach() || len > capacityAtEnd - || (len < size() && len < (capacityAtEnd >> 1))) - // ### inefficient! reallocData() does copy the old data and we then overwrite it in the next line - reallocData(len, QArrayData::KeepSize); - memcpy(d.data(), str, len + 1); // include null terminator - d.size = len; + assign(str); } return *this; } @@ -1239,6 +1399,15 @@ QByteArray &QByteArray::operator=(const char *str) \sa isEmpty(), resize() */ +/*! \fn qsizetype QByteArray::max_size() + \since 6.8 + + This function is provided for STL compatibility. + It returns the maximum number of elements that the byte array can + theoretically hold. In practice, the number can be much smaller, + limited by the amount of memory available to the system. +*/ + /*! \fn bool QByteArray::isEmpty() const Returns \c true if the byte array has size 0; otherwise returns \c false. @@ -1652,7 +1821,7 @@ QByteArray::QByteArray(const char *data, qsizetype size) if (!size) { d = DataPointer::fromRawData(&_empty, 0); } else { - d = DataPointer(Data::allocate(size), size); + d = DataPointer(size, size); Q_CHECK_PTR(d.data()); memcpy(d.data(), data, size); d.data()[size] = '\0'; @@ -1671,7 +1840,7 @@ QByteArray::QByteArray(qsizetype size, char ch) if (size <= 0) { d = DataPointer::fromRawData(&_empty, 0); } else { - d = DataPointer(Data::allocate(size), size); + d = DataPointer(size, size); Q_CHECK_PTR(d.data()); memset(d.data(), ch, size); d.data()[size] = '\0'; @@ -1679,8 +1848,6 @@ QByteArray::QByteArray(qsizetype size, char ch) } /*! - \internal - Constructs a byte array of size \a size with uninitialized contents. */ @@ -1689,7 +1856,7 @@ QByteArray::QByteArray(qsizetype size, Qt::Initialization) if (size <= 0) { d = DataPointer::fromRawData(&_empty, 0); } else { - d = DataPointer(Data::allocate(size), size); + d = DataPointer(size, size); Q_CHECK_PTR(d.data()); d.data()[size] = '\0'; } @@ -1749,6 +1916,21 @@ void QByteArray::resize(qsizetype newSize, char c) } /*! + \since 6.8 + + Resizes the byte array to \a size bytes. If the size of the + byte array grows, the new bytes are uninitialized. + + The behavior is identical to \c{resize(size)}. + + \sa resize() +*/ +void QByteArray::resizeForOverwrite(qsizetype size) +{ + resize(size); +} + +/*! Sets every byte in the byte array to \a ch. If \a size is different from -1 (the default), the byte array is resized to size \a size beforehand. @@ -1778,7 +1960,7 @@ void QByteArray::reallocData(qsizetype alloc, QArrayData::AllocationOption optio const bool cannotUseReallocate = d.freeSpaceAtBegin() > 0; if (d->needsDetach() || cannotUseReallocate) { - DataPointer dd(Data::allocate(alloc, option), qMin(alloc, d.size)); + DataPointer dd(alloc, qMin(alloc, d.size), option); Q_CHECK_PTR(dd.data()); if (dd.size > 0) ::memcpy(dd.data(), d.data(), dd.size); @@ -1898,9 +2080,17 @@ QByteArray &QByteArray::prepend(const QByteArray &ba) QByteArray &QByteArray::append(const QByteArray &ba) { - if (size() == 0 && ba.size() > d->freeSpaceAtEnd() && ba.d.isMutable()) - return (*this = ba); - return append(QByteArrayView(ba)); + if (!ba.isNull()) { + if (isNull()) { + if (Q_UNLIKELY(!ba.d.isMutable())) + assign(ba); // fromRawData, so we do a deep copy + else + operator=(ba); + } else if (ba.size()) { + append(QByteArrayView(ba)); + } + } + return *this; } /*! @@ -1959,6 +2149,73 @@ QByteArray& QByteArray::append(char ch) } /*! + \fn QByteArray &QByteArray::assign(QByteArrayView v) + \since 6.6 + + Replaces the contents of this byte array with a copy of \a v and returns a + reference to this byte array. + + The size of this byte array will be equal to the size of \a v. + + This function only allocates memory if the size of \a v exceeds the capacity + of this byte array or this byte array is shared. +*/ + +/*! + \fn QByteArray &QByteArray::assign(qsizetype n, char c) + \since 6.6 + + Replaces the contents of this byte array with \a n copies of \a c and + returns a reference to this byte array. + + The size of this byte array will be equal to \a n, which has to be non-negative. + + This function will only allocate memory if \a n exceeds the capacity of this + byte array or this byte array is shared. + + \sa fill() +*/ + +/*! + \fn template <typename InputIterator, QByteArray::if_input_iterator<InputIterator>> QByteArray &QByteArray::assign(InputIterator first, InputIterator last) + \since 6.6 + + Replaces the contents of this byte array with a copy of the elements in the + iterator range [\a first, \a last) and returns a reference to this + byte array. + + The size of this byte array will be equal to the number of elements in the + range [\a first, \a last). + + This function will only allocate memory if the number of elements in the + range exceeds the capacity of this byte array or this byte array is shared. + + \note This function overload only participates in overload resolution if + \c InputIterator meets the requirements of a + \l {https://en.cppreference.com/w/cpp/named_req/InputIterator} {LegacyInputIterator}. + + \note The behavior is undefined if either argument is an iterator into *this or + [\a first, \a last) is not a valid range. +*/ + +QByteArray &QByteArray::assign(QByteArrayView v) +{ + const auto len = v.size(); + + if (len <= capacity() && isDetached()) { + const auto offset = d.freeSpaceAtBegin(); + if (offset) + d.setBegin(d.begin() - offset); + std::memcpy(d.begin(), v.data(), len); + d.size = len; + d.data()[d.size] = '\0'; + } else { + *this = v.toByteArray(); + } + return *this; +} + +/*! Inserts \a data at index position \a i and returns a reference to this byte array. @@ -2000,7 +2257,7 @@ QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data) return *this; } - if (!d->needsDetach() && QtPrivate::q_points_into_range(str, d.data(), d.data() + d.size)) { + if (!d->needsDetach() && QtPrivate::q_points_into_range(str, d)) { QVarLengthArray a(str, str + size); return insert(i, a); } @@ -2105,15 +2362,56 @@ QByteArray &QByteArray::remove(qsizetype pos, qsizetype len) { if (len <= 0 || pos < 0 || size_t(pos) >= size_t(size())) return *this; - detach(); if (pos + len > d->size) len = d->size - pos; - d->erase(d.begin() + pos, len); - d.data()[d.size] = '\0'; + + auto begin = d.begin(); + if (!d->isShared()) { + d->erase(begin + pos, len); + d.data()[d.size] = '\0'; + } else { + QByteArray copy{size() - len, Qt::Uninitialized}; + const auto toRemove_start = d.begin() + pos; + copy.d->copyRanges({{d.begin(), toRemove_start}, + {toRemove_start + len, d.end()}}); + swap(copy); + } return *this; } /*! + \fn QByteArray &QByteArray::removeAt(qsizetype pos) + + \since 6.5 + + Removes the character at index \a pos. If \a pos is out of bounds + (i.e. \a pos >= size()) this function does nothing. + + \sa remove() +*/ + +/*! + \fn QByteArray &QByteArray::removeFirst() + + \since 6.5 + + Removes the first character in this byte array. If the byte array is empty, + this function does nothing. + + \sa remove() +*/ +/*! + \fn QByteArray &QByteArray::removeLast() + + \since 6.5 + + Removes the last character in this byte array. If the byte array is empty, + this function does nothing. + + \sa remove() +*/ + +/*! \fn template <typename Predicate> QByteArray &QByteArray::removeIf(Predicate pred) \since 6.1 @@ -2135,7 +2433,7 @@ QByteArray &QByteArray::remove(qsizetype pos, qsizetype len) QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after) { - if (QtPrivate::q_points_into_range(after.data(), d.data(), d.data() + d.size)) { + if (QtPrivate::q_points_into_range(after.data(), d)) { QVarLengthArray copy(after.data(), after.data() + after.size()); return replace(pos, len, QByteArrayView{copy}); } @@ -2195,11 +2493,11 @@ QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after) return *this; // protect against before or after being part of this - if (QtPrivate::q_points_into_range(a, d.data(), d.data() + d.size)) { + if (QtPrivate::q_points_into_range(a, d)) { QVarLengthArray copy(a, a + asize); return replace(before, QByteArrayView{copy}); } - if (QtPrivate::q_points_into_range(b, d.data(), d.data() + d.size)) { + if (QtPrivate::q_points_into_range(b, d)) { QVarLengthArray copy(b, b + bsize); return replace(QByteArrayView{copy}, after); } @@ -2307,12 +2605,11 @@ QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after) QByteArray &QByteArray::replace(char before, char after) { - if (!isEmpty()) { - char *i = data(); - char *e = i + size(); - for (; i != e; ++i) - if (*i == before) - * i = after; + if (before != after) { + if (const auto pos = indexOf(before); pos >= 0) { + const auto detachedData = data(); + std::replace(detachedData + pos, detachedData + size(), before, after); + } } return *this; } @@ -2388,20 +2685,6 @@ QByteArray QByteArray::repeated(qsizetype times) const hashHaystack -= std::size_t(a) << ol_minus_1; \ hashHaystack <<= 1 -static inline qsizetype findCharHelper(QByteArrayView haystack, qsizetype from, char needle) noexcept -{ - if (from < 0) - from = qMax(from + haystack.size(), qsizetype(0)); - if (from < haystack.size()) { - const char *const b = haystack.data(); - if (const auto n = static_cast<const char *>( - memchr(b + from, needle, static_cast<size_t>(haystack.size() - from)))) { - return n - b; - } - } - return -1; -} - qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept { const auto ol = needle.size(); @@ -2414,7 +2697,7 @@ qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByt } if (ol == 1) - return findCharHelper(haystack, from, needle.front()); + return findByteArray(haystack, from, needle.front()); if (from > l || ol + from > l) return -1; @@ -2436,6 +2719,7 @@ qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByt */ /*! + \fn qsizetype QByteArray::indexOf(char ch, qsizetype from) const \overload Returns the index position of the start of the first occurrence of the @@ -2448,11 +2732,6 @@ qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByt \sa lastIndexOf(), contains() */ -qsizetype QByteArray::indexOf(char ch, qsizetype from) const -{ - return qToByteArrayViewIgnoringNull(*this).indexOf(ch, from); -} - static qsizetype lastIndexOfHelper(const char *haystack, qsizetype l, const char *needle, qsizetype ol, qsizetype from) { @@ -2506,6 +2785,11 @@ static inline qsizetype lastIndexOfCharHelper(QByteArrayView haystack, qsizetype return -1; } +qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, char needle) noexcept +{ + return lastIndexOfCharHelper(haystack, from, needle); +} + qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept { if (haystack.isEmpty()) { @@ -2525,9 +2809,11 @@ qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteA Returns the index position of the start of the last occurrence of the sequence of bytes viewed by \a bv in this byte array, searching backward - from index position \a from. If \a from is -1, the search starts at - the last character; if \a from is -2, at the next to last character - and so on. Returns -1 if no match is found. + from index position \a from. + + \include qstring.qdocinc negative-index-start-search-from-end + + Returns -1 if no match is found. Example: \snippet code/src_corelib_text_qbytearray.cpp 23 @@ -2557,6 +2843,7 @@ qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteA */ /*! + \fn qsizetype QByteArray::lastIndexOf(char ch, qsizetype from) const \overload Returns the index position of the start of the last occurrence of byte \a ch @@ -2570,11 +2857,6 @@ qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteA \sa indexOf(), contains() */ -qsizetype QByteArray::lastIndexOf(char ch, qsizetype from) const -{ - return qToByteArrayViewIgnoringNull(*this).lastIndexOf(ch, from); -} - static inline qsizetype countCharHelper(QByteArrayView haystack, char needle) noexcept { qsizetype num = 0; @@ -2766,6 +3048,9 @@ bool QByteArray::isLower() const */ /*! + \fn QByteArray QByteArray::left(qsizetype len) const & + \fn QByteArray QByteArray::left(qsizetype len) && + Returns a byte array that contains the first \a len bytes of this byte array. @@ -2780,16 +3065,10 @@ bool QByteArray::isLower() const \sa first(), last(), startsWith(), chopped(), chop(), truncate() */ -QByteArray QByteArray::left(qsizetype len) const -{ - if (len >= size()) - return *this; - if (len < 0) - len = 0; - return QByteArray(data(), len); -} - /*! + \fn QByteArray QByteArray::right(qsizetype len) const & + \fn QByteArray QByteArray::right(qsizetype len) && + Returns a byte array that contains the last \a len bytes of this byte array. If you know that \a len cannot be out of bounds, use last() instead in new @@ -2800,18 +3079,13 @@ QByteArray QByteArray::left(qsizetype len) const Returns an empty QByteArray if \a len is smaller than 0. - \sa endsWith(), last(), first(), sliced(), chopped(), chop(), truncate() + \sa endsWith(), last(), first(), sliced(), chopped(), chop(), truncate(), slice() */ -QByteArray QByteArray::right(qsizetype len) const -{ - if (len >= size()) - return *this; - if (len < 0) - len = 0; - return QByteArray(end() - len, len); -} /*! + \fn QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const & + \fn QByteArray QByteArray::mid(qsizetype pos, qsizetype len) && + Returns a byte array containing \a len bytes from this byte array, starting at position \a pos. @@ -2822,10 +3096,10 @@ QByteArray QByteArray::right(qsizetype len) const returns a byte array containing all bytes starting at position \a pos until the end of the byte array. - \sa first(), last(), sliced(), chopped(), chop(), truncate() + \sa first(), last(), sliced(), chopped(), chop(), truncate(), slice() */ -QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const +QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const & { qsizetype p = pos; qsizetype l = len; @@ -2840,14 +3114,33 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const case QContainerImplHelper::Full: return *this; case QContainerImplHelper::Subset: - return QByteArray(d.data() + p, l); + return sliced(p, l); } - Q_UNREACHABLE(); - return QByteArray(); + Q_UNREACHABLE_RETURN(QByteArray()); +} + +QByteArray QByteArray::mid(qsizetype pos, qsizetype len) && +{ + qsizetype p = pos; + qsizetype l = len; + using namespace QtPrivate; + switch (QContainerImplHelper::mid(size(), &p, &l)) { + case QContainerImplHelper::Null: + return QByteArray(); + case QContainerImplHelper::Empty: + resize(0); // keep capacity if we've reserve()d + [[fallthrough]]; + case QContainerImplHelper::Full: + return std::move(*this); + case QContainerImplHelper::Subset: + return std::move(*this).sliced(p, l); + } + Q_UNREACHABLE_RETURN(QByteArray()); } /*! - \fn QByteArray QByteArray::first(qsizetype n) const + \fn QByteArray QByteArray::first(qsizetype n) const & + \fn QByteArray QByteArray::first(qsizetype n) && \since 6.0 Returns the first \a n bytes of the byte array. @@ -2857,11 +3150,12 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const Example: \snippet code/src_corelib_text_qbytearray.cpp 27 - \sa last(), sliced(), startsWith(), chopped(), chop(), truncate() + \sa last(), sliced(), startsWith(), chopped(), chop(), truncate(), slice() */ /*! - \fn QByteArray QByteArray::last(qsizetype n) const + \fn QByteArray QByteArray::last(qsizetype n) const & + \fn QByteArray QByteArray::last(qsizetype n) && \since 6.0 Returns the last \a n bytes of the byte array. @@ -2871,11 +3165,12 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const Example: \snippet code/src_corelib_text_qbytearray.cpp 28 - \sa first(), sliced(), endsWith(), chopped(), chop(), truncate() + \sa first(), sliced(), endsWith(), chopped(), chop(), truncate(), slice() */ /*! - \fn QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) const + \fn QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) const & + \fn QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) && \since 6.0 Returns a byte array containing the \a n bytes of this object starting @@ -2887,11 +3182,20 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const Example: \snippet code/src_corelib_text_qbytearray.cpp 29 - \sa first(), last(), chopped(), chop(), truncate() + \sa first(), last(), chopped(), chop(), truncate(), slice() */ +QByteArray QByteArray::sliced_helper(QByteArray &a, qsizetype pos, qsizetype n) +{ + if (n == 0) + return fromRawData(&_empty, 0); + DataPointer d = std::move(a.d).sliced(pos, n); + d.data()[n] = 0; + return QByteArray(std::move(d)); +} /*! - \fn QByteArray QByteArray::sliced(qsizetype pos) const + \fn QByteArray QByteArray::sliced(qsizetype pos) const & + \fn QByteArray QByteArray::sliced(qsizetype pos) && \since 6.0 \overload @@ -2900,11 +3204,41 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const \note The behavior is undefined when \a pos < 0 or \a pos > size(). - \sa first(), last(), sliced(), chopped(), chop(), truncate() + \sa first(), last(), chopped(), chop(), truncate(), slice() */ /*! - \fn QByteArray QByteArray::chopped(qsizetype len) const + \fn QByteArray &QByteArray::slice(qsizetype pos, qsizetype n) + \since 6.8 + + Modifies this byte array to start at position \a pos, extending for \a n + bytes, and returns a reference to this byte array. + + \note The behavior is undefined if \a pos < 0, \a n < 0, + or \a pos + \a n > size(). + + Example: + \snippet code/src_corelib_text_qbytearray.cpp 57 + + \sa sliced(), first(), last(), chopped(), chop(), truncate() +*/ + +/*! + \fn QByteArray &QByteArray::slice(qsizetype pos) + \since 6.8 + \overload + + Modifies this byte array to start at position \a pos, extending to its + end, and returns a reference to this byte array. + + \note The behavior is undefined if \a pos < 0 or \a pos > size(). + + \sa sliced(), first(), last(), chopped(), chop(), truncate() +*/ + +/*! + \fn QByteArray QByteArray::chopped(qsizetype len) const & + \fn QByteArray QByteArray::chopped(qsizetype len) && \since 5.10 Returns a byte array that contains the leftmost size() - \a len bytes of @@ -2912,7 +3246,7 @@ QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const \note The behavior is undefined if \a len is negative or greater than size(). - \sa endsWith(), first(), last(), sliced(), chop(), truncate() + \sa endsWith(), first(), last(), sliced(), chop(), truncate(), slice() */ /*! @@ -2998,7 +3332,7 @@ void QByteArray::clear() d.clear(); } -#if !defined(QT_NO_DATASTREAM) || defined(QT_BOOTSTRAPPED) +#if !defined(QT_NO_DATASTREAM) /*! \relates QByteArray @@ -3011,7 +3345,7 @@ void QByteArray::clear() QDataStream &operator<<(QDataStream &out, const QByteArray &ba) { if (ba.isNull() && out.version() >= 6) { - out << (quint32)0xffffffff; + QDataStream::writeQSizeType(out, -1); return out; } return out.writeBytes(ba.constData(), ba.size()); @@ -3028,13 +3362,21 @@ QDataStream &operator<<(QDataStream &out, const QByteArray &ba) QDataStream &operator>>(QDataStream &in, QByteArray &ba) { ba.clear(); - quint32 len; - in >> len; - if (len == 0xffffffff) + + qint64 size = QDataStream::readQSizeType(in); + qsizetype len = size; + if (size != len || size < -1) { + ba.clear(); + in.setStatus(QDataStream::SizeLimitExceeded); + return in; + } + if (len == -1) { // null byte-array + ba = QByteArray(); return in; + } - const quint32 Step = 1024 * 1024; - quint32 allocated = 0; + constexpr qsizetype Step = 1024 * 1024; + qsizetype allocated = 0; do { qsizetype blockSize = qMin(Step, len - allocated); @@ -3051,253 +3393,169 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba) } #endif // QT_NO_DATASTREAM -/*! \fn bool QByteArray::operator==(const QString &str) const - - Returns \c true if this byte array is equal to the UTF-8 encoding of \a str; - otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator!=(const QString &str) const - - Returns \c true if this byte array is not equal to the UTF-8 encoding of \a - str; otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator<(const QString &str) const - - Returns \c true if this byte array is lexically less than the UTF-8 encoding - of \a str; otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator>(const QString &str) const - - Returns \c true if this byte array is lexically greater than the UTF-8 - encoding of \a str; otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator<=(const QString &str) const - - Returns \c true if this byte array is lexically less than or equal to the - UTF-8 encoding of \a str; otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator>=(const QString &str) const - - Returns \c true if this byte array is greater than or equal to the UTF-8 - encoding of \a str; otherwise returns \c false. - - The comparison is case sensitive. - - You can disable this operator by defining \c - QT_NO_CAST_FROM_ASCII when you compile your applications. You - then need to call QString::fromUtf8(), QString::fromLatin1(), - or QString::fromLocal8Bit() explicitly if you want to convert the byte - array to a QString before doing the comparison. -*/ - -/*! \fn bool QByteArray::operator==(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator==(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is equal to byte array \a a2; + Returns \c true if byte array \a lhs is equal to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator==(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator==(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is equal to the '\\0'-terminated string - \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is equal to the '\\0'-terminated string + \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator==(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator==(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is equal to byte array \a - a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is equal to byte array \a + rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator!=(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator!=(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is not equal to byte array \a a2; + Returns \c true if byte array \a lhs is not equal to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator!=(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator!=(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is not equal to the '\\0'-terminated - string \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is not equal to the '\\0'-terminated + string \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator!=(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator!=(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is not equal to byte array - \a a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is not equal to byte array + \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator<(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is lexically less than byte array - \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically less than byte array + \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator<(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is lexically less than the - '\\0'-terminated string \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically less than the + '\\0'-terminated string \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator<(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is lexically less than byte - array \a a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is lexically less than byte + array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<=(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator<=(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is lexically less than or equal - to byte array \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically less than or equal + to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<=(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator<=(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is lexically less than or equal to the - '\\0'-terminated string \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically less than or equal to the + '\\0'-terminated string \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator<=(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator<=(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is lexically less than or - equal to byte array \a a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is lexically less than or + equal to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator>(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is lexically greater than byte - array \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically greater than byte + array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator>(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is lexically greater than the - '\\0'-terminated string \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically greater than the + '\\0'-terminated string \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator>(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is lexically greater than - byte array \a a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is lexically greater than + byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>=(const QByteArray &a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator>=(const QByteArray &lhs, const QByteArray &rhs) \overload - Returns \c true if byte array \a a1 is lexically greater than or - equal to byte array \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically greater than or + equal to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>=(const QByteArray &a1, const char *a2) +/*! \fn bool QByteArray::operator>=(const QByteArray &lhs, const char * const &rhs) \overload - Returns \c true if byte array \a a1 is lexically greater than or equal to - the '\\0'-terminated string \a a2; otherwise returns \c false. + Returns \c true if byte array \a lhs is lexically greater than or equal to + the '\\0'-terminated string \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn bool QByteArray::operator>=(const char *a1, const QByteArray &a2) +/*! \fn bool QByteArray::operator>=(const char * const &lhs, const QByteArray &rhs) \overload - Returns \c true if '\\0'-terminated string \a a1 is lexically greater than - or equal to byte array \a a2; otherwise returns \c false. + Returns \c true if '\\0'-terminated string \a lhs is lexically greater than + or equal to byte array \a rhs; otherwise returns \c false. \sa QByteArray::compare() */ -/*! \fn const QByteArray operator+(const QByteArray &a1, const QByteArray &a2) +/*! \fn QByteArray operator+(const QByteArray &a1, const QByteArray &a2) \relates QByteArray Returns a byte array that is the result of concatenating byte @@ -3306,7 +3564,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba) \sa QByteArray::operator+=() */ -/*! \fn const QByteArray operator+(const QByteArray &a1, const char *a2) +/*! \fn QByteArray operator+(const QByteArray &a1, const char *a2) \relates QByteArray \overload @@ -3315,7 +3573,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba) and '\\0'-terminated string \a a2. */ -/*! \fn const QByteArray operator+(const QByteArray &a1, char a2) +/*! \fn QByteArray operator+(const QByteArray &a1, char a2) \relates QByteArray \overload @@ -3324,7 +3582,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba) array \a a1 and byte \a a2. */ -/*! \fn const QByteArray operator+(const char *a1, const QByteArray &a2) +/*! \fn QByteArray operator+(const char *a1, const QByteArray &a2) \relates QByteArray \overload @@ -3333,7 +3591,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba) string \a a1 and byte array \a a2. */ -/*! \fn const QByteArray operator+(char a1, const QByteArray &a2) +/*! \fn QByteArray operator+(char a1, const QByteArray &a2) \relates QByteArray \overload @@ -3400,9 +3658,7 @@ QByteArray QByteArray::trimmed_helper(QByteArray &a) QByteArrayView QtPrivate::trimmed(QByteArrayView view) noexcept { - auto start = view.begin(); - auto stop = view.end(); - QStringAlgorithms<QByteArrayView>::trimmed_helper_positions(start, stop); + const auto [start, stop] = QStringAlgorithms<QByteArrayView>::trimmed_helper_positions(view); return QByteArrayView(start, stop); } @@ -3491,10 +3747,9 @@ auto QtPrivate::toSignedInteger(QByteArrayView data, int base) -> ParsedNumber<q if (data.isEmpty()) return {}; - bool ok = false; - const auto i = QLocaleData::bytearrayToLongLong(data, base, &ok); - if (ok) - return ParsedNumber(i); + const QSimpleParsedNumber r = QLocaleData::bytearrayToLongLong(data, base); + if (r.ok()) + return ParsedNumber(r.result); return {}; } @@ -3509,10 +3764,9 @@ auto QtPrivate::toUnsignedInteger(QByteArrayView data, int base) -> ParsedNumber if (data.isEmpty()) return {}; - bool ok = false; - const auto u = QLocaleData::bytearrayToUnsLongLong(data, base, &ok); - if (ok) - return ParsedNumber(u); + const QSimpleParsedNumber r = QLocaleData::bytearrayToUnsLongLong(data, base); + if (r.ok()) + return ParsedNumber(r.result); return {}; } @@ -3794,11 +4048,9 @@ double QByteArray::toDouble(bool *ok) const auto QtPrivate::toDouble(QByteArrayView a) noexcept -> ParsedNumber<double> { - bool nonNullOk = false; - int processed = 0; - double d = qt_asciiToDouble(a.data(), a.size(), nonNullOk, processed, WhitespacesAllowed); - if (nonNullOk) - return ParsedNumber{d}; + auto r = qt_asciiToDouble(a.data(), a.size(), WhitespacesAllowed); + if (r.ok()) + return ParsedNumber{r.result}; else return {}; } @@ -3857,12 +4109,12 @@ auto QtPrivate::toFloat(QByteArrayView a) noexcept -> ParsedNumber<float> */ QByteArray QByteArray::toBase64(Base64Options options) const { - const char alphabet_base64[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef" - "ghijklmn" "opqrstuv" "wxyz0123" "456789+/"; - const char alphabet_base64url[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef" - "ghijklmn" "opqrstuv" "wxyz0123" "456789-_"; + constexpr char alphabet_base64[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef" + "ghijklmn" "opqrstuv" "wxyz0123" "456789+/"; + constexpr char alphabet_base64url[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef" + "ghijklmn" "opqrstuv" "wxyz0123" "456789-_"; const char *const alphabet = options & Base64UrlEncoding ? alphabet_base64url : alphabet_base64; - const char padchar = '='; + constexpr char padchar = '='; qsizetype padlen = 0; const qsizetype sz = size(); @@ -3974,7 +4226,7 @@ static char *qulltoa2(char *p, qulonglong n, int base) base = 10; } #endif - const char b = 'a' - 10; + constexpr char b = 'a' - 10; do { const int c = n % base; n /= base; @@ -3991,7 +4243,7 @@ static char *qulltoa2(char *p, qulonglong n, int base) */ QByteArray &QByteArray::setNum(qlonglong n, int base) { - const int buffsize = 66; // big enough for MAX_ULLONG in base 2 + constexpr int buffsize = 66; // big enough for MAX_ULLONG in base 2 char buff[buffsize]; char *p; @@ -4016,7 +4268,7 @@ QByteArray &QByteArray::setNum(qlonglong n, int base) QByteArray &QByteArray::setNum(qulonglong n, int base) { - const int buffsize = 66; // big enough for MAX_ULLONG in base 2 + constexpr int buffsize = 66; // big enough for MAX_ULLONG in base 2 char buff[buffsize]; char *p = qulltoa2(buff + buffsize, n, base); @@ -4652,6 +4904,60 @@ QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude, const QByteA return result; } +#if defined(Q_OS_WASM) || defined(Q_QDOC) + +/*! + Constructs a new QByteArray containing a copy of the Uint8Array \a uint8array. + + This function transfers data from a JavaScript data buffer - which + is not addressable from C++ code - to heap memory owned by a QByteArray. + The Uint8Array can be released once this function returns and a copy + has been made. + + The \a uint8array argument must an emscripten::val referencing an Uint8Array + object, e.g. obtained from a global JavaScript variable: + + \snippet code/src_corelib_text_qbytearray.cpp 55 + + This function returns a null QByteArray if the size of the Uint8Array + exceeds the maximum capacity of QByteArray, or if the \a uint8array + argument is not of the Uint8Array type. + + \since 6.5 + \ingroup platform-type-conversions + + \sa toEcmaUint8Array() +*/ + +QByteArray QByteArray::fromEcmaUint8Array(emscripten::val uint8array) +{ + return qstdweb::Uint8Array(uint8array).copyToQByteArray(); +} + +/*! + Creates a Uint8Array from a QByteArray. + + This function transfers data from heap memory owned by a QByteArray + to a JavaScript data buffer. The function allocates and copies into an + ArrayBuffer, and returns a Uint8Array view to that buffer. + + The JavaScript objects own a copy of the data, and this + QByteArray can be safely deleted after the copy has been made. + + \snippet code/src_corelib_text_qbytearray.cpp 56 + + \since 6.5 + \ingroup platform-type-conversions + + \sa toEcmaUint8Array() +*/ +emscripten::val QByteArray::toEcmaUint8Array() +{ + return qstdweb::Uint8Array::copyFrom(*this).val(); +} + +#endif + /*! \typedef QByteArray::ConstIterator \internal */ @@ -4900,3 +5206,5 @@ size_t qHash(const QByteArray::FromBase64Result &key, size_t seed) noexcept */ QT_END_NAMESPACE + +#undef REHASH |