diff options
Diffstat (limited to 'src/corelib/text/qbytearray.h')
| -rw-r--r-- | src/corelib/text/qbytearray.h | 944 |
1 files changed, 536 insertions, 408 deletions
diff --git a/src/corelib/text/qbytearray.h b/src/corelib/text/qbytearray.h index 5cbcecb956..3c8a3bba45 100644 --- a/src/corelib/text/qbytearray.h +++ b/src/corelib/text/qbytearray.h @@ -1,42 +1,6 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Copyright (C) 2016 Intel Corporation. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtCore module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2022 The Qt Company Ltd. +// Copyright (C) 2016 Intel Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #ifndef QBYTEARRAY_H #define QBYTEARRAY_H @@ -45,15 +9,22 @@ #include <QtCore/qnamespace.h> #include <QtCore/qarraydata.h> #include <QtCore/qarraydatapointer.h> +#include <QtCore/qcompare.h> #include <QtCore/qcontainerfwd.h> +#include <QtCore/qbytearrayalgorithms.h> +#include <QtCore/qbytearrayview.h> #include <stdlib.h> #include <string.h> -#include <stdarg.h> #include <string> #include <iterator> +#ifndef QT5_NULL_STRINGS +// Would ideally be off, but in practice breaks too much (Qt 6.0). +#define QT5_NULL_STRINGS 1 +#endif + #ifdef truncate #error qbytearray.h must be included before any header file that defines truncate #endif @@ -63,53 +34,15 @@ Q_FORWARD_DECLARE_CF_TYPE(CFData); Q_FORWARD_DECLARE_OBJC_CLASS(NSData); #endif -QT_BEGIN_NAMESPACE - - -/***************************************************************************** - Safe and portable C string functions; extensions to standard string.h - *****************************************************************************/ - -Q_CORE_EXPORT char *qstrdup(const char *); - -inline uint qstrlen(const char *str) -{ return str ? uint(strlen(str)) : 0; } - -inline uint qstrnlen(const char *str, uint maxlen) -{ - uint length = 0; - if (str) { - while (length < maxlen && *str++) - length++; - } - return length; -} - -Q_CORE_EXPORT char *qstrcpy(char *dst, const char *src); -Q_CORE_EXPORT char *qstrncpy(char *dst, const char *src, uint len); - -Q_CORE_EXPORT int qstrcmp(const char *str1, const char *str2); -Q_CORE_EXPORT int qstrcmp(const QByteArray &str1, const QByteArray &str2); -Q_CORE_EXPORT int qstrcmp(const QByteArray &str1, const char *str2); -static inline int qstrcmp(const char *str1, const QByteArray &str2) -{ return -qstrcmp(str2, str1); } - -inline int qstrncmp(const char *str1, const char *str2, uint len) -{ - return (str1 && str2) ? strncmp(str1, str2, len) - : (str1 ? 1 : (str2 ? -1 : 0)); +#if defined(Q_OS_WASM) || defined(Q_QDOC) +namespace emscripten { + class val; } -Q_CORE_EXPORT int qstricmp(const char *, const char *); -Q_CORE_EXPORT int qstrnicmp(const char *, const char *, uint len); -Q_CORE_EXPORT int qstrnicmp(const char *, qsizetype, const char *, qsizetype = -1); +#endif -// implemented in qvsnprintf.cpp -Q_CORE_EXPORT int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap); -Q_CORE_EXPORT int qsnprintf(char *str, size_t n, const char *fmt, ...); +class tst_QByteArray; -// qChecksum: Internet checksum -Q_CORE_EXPORT quint16 qChecksum(const char *s, uint len, - Qt::ChecksumType standard = Qt::ChecksumIso3309); +QT_BEGIN_NAMESPACE class QString; class QDataStream; @@ -117,16 +50,7 @@ class QDataStream; using QByteArrayData = QArrayDataPointer<char>; # define QByteArrayLiteral(str) \ - ([]() -> QByteArray { \ - enum { Size = sizeof(str) - 1 }; \ - static const QArrayData qbytearray_literal = { \ - Q_BASIC_ATOMIC_INITIALIZER(-1), QArrayData::StaticDataFlags, 0 }; \ - QByteArrayData holder = { \ - static_cast<QTypedArrayData<char> *>(const_cast<QArrayData *>(&qbytearray_literal)), \ - const_cast<char *>(str), \ - Size }; \ - return QByteArray(holder); \ - }()) \ + (QByteArray(QByteArrayData(nullptr, const_cast<char *>(str), sizeof(str) - 1))) \ /**/ class Q_CORE_EXPORT QByteArray @@ -137,6 +61,12 @@ private: typedef QTypedArrayData<char> Data; DataPointer d; + static const char _empty; + + friend class ::tst_QByteArray; + + template <typename InputIterator> + using if_input_iterator = QtPrivate::IfIsInputIterator<InputIterator>; public: enum Base64Option { @@ -158,29 +88,31 @@ public: IllegalPadding, }; - inline QByteArray() noexcept; - QByteArray(const char *, int size = -1); - QByteArray(int size, char c); - QByteArray(int size, Qt::Initialization); + inline constexpr QByteArray() noexcept; + QByteArray(const char *, qsizetype size = -1); + QByteArray(qsizetype size, char c); + QByteArray(qsizetype size, Qt::Initialization); + explicit QByteArray(QByteArrayView v) : QByteArray(v.data(), v.size()) {} inline QByteArray(const QByteArray &) noexcept; inline ~QByteArray(); QByteArray &operator=(const QByteArray &) noexcept; QByteArray &operator=(const char *str); inline QByteArray(QByteArray && other) noexcept - { qSwap(d, other.d); } - inline QByteArray &operator=(QByteArray &&other) noexcept - { qSwap(d, other.d); return *this; } + = default; + QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QByteArray) inline void swap(QByteArray &other) noexcept - { qSwap(d, other.d); } + { d.swap(other.d); } - inline bool isEmpty() const; - void resize(int size); + bool isEmpty() const noexcept { return size() == 0; } + void resize(qsizetype size); + void resize(qsizetype size, char c); + void resizeForOverwrite(qsizetype size); - QByteArray &fill(char c, int size = -1); + QByteArray &fill(char c, qsizetype size = -1); - inline int capacity() const; - inline void reserve(int size); + inline qsizetype capacity() const; + inline void reserve(qsizetype size); inline void squeeze(); #ifndef QT_NO_CAST_FROM_BYTEARRAY @@ -188,139 +120,255 @@ public: inline operator const void *() const; #endif inline char *data(); - inline const char *data() const; - inline const char *constData() const; + inline const char *data() const noexcept; + const char *constData() const noexcept { return data(); } inline void detach(); inline bool isDetached() const; - inline bool isSharedWith(const QByteArray &other) const + inline bool isSharedWith(const QByteArray &other) const noexcept { return data() == other.data() && size() == other.size(); } void clear(); - inline char at(int i) const; - inline char operator[](int i) const; - Q_REQUIRED_RESULT inline char &operator[](int i); - Q_REQUIRED_RESULT char front() const { return at(0); } - Q_REQUIRED_RESULT inline char &front(); - Q_REQUIRED_RESULT char back() const { return at(size() - 1); } - Q_REQUIRED_RESULT inline char &back(); - - int indexOf(char c, int from = 0) const; - int indexOf(const char *c, int from = 0) const; - int indexOf(const QByteArray &a, int from = 0) const; - int lastIndexOf(char c, int from = -1) const; - int lastIndexOf(const char *c, int from = -1) const; - int lastIndexOf(const QByteArray &a, int from = -1) const; + inline char at(qsizetype i) const; + inline char operator[](qsizetype i) const; + [[nodiscard]] inline char &operator[](qsizetype i); + [[nodiscard]] char front() const { return at(0); } + [[nodiscard]] inline char &front(); + [[nodiscard]] char back() const { return at(size() - 1); } + [[nodiscard]] inline char &back(); + + QT_CORE_INLINE_SINCE(6, 7) + qsizetype indexOf(char c, qsizetype from = 0) const; + qsizetype indexOf(QByteArrayView bv, qsizetype from = 0) const + { return QtPrivate::findByteArray(qToByteArrayViewIgnoringNull(*this), from, bv); } + + QT_CORE_INLINE_SINCE(6, 7) + qsizetype lastIndexOf(char c, qsizetype from = -1) const; + qsizetype lastIndexOf(QByteArrayView bv) const + { return lastIndexOf(bv, size()); } + qsizetype lastIndexOf(QByteArrayView bv, qsizetype from) const + { return QtPrivate::lastIndexOf(qToByteArrayViewIgnoringNull(*this), from, bv); } inline bool contains(char c) const; - inline bool contains(const char *a) const; - inline bool contains(const QByteArray &a) const; - int count(char c) const; - int count(const char *a) const; - int count(const QByteArray &a) const; - - inline int compare(const char *c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept; - inline int compare(const QByteArray &a, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept; - - Q_REQUIRED_RESULT QByteArray left(int len) const; - Q_REQUIRED_RESULT QByteArray right(int len) const; - Q_REQUIRED_RESULT QByteArray mid(int index, int len = -1) const; - - Q_REQUIRED_RESULT QByteArray first(qsizetype n) const - { Q_ASSERT(n >= 0); Q_ASSERT(n <= size()); return QByteArray(data(), int(n)); } - Q_REQUIRED_RESULT QByteArray last(qsizetype n) const - { Q_ASSERT(n >= 0); Q_ASSERT(n <= size()); return QByteArray(data() + size() - n, int(n)); } - Q_REQUIRED_RESULT QByteArray from(qsizetype pos) const - { Q_ASSERT(pos >= 0); Q_ASSERT(pos <= size()); return QByteArray(data() + pos, size() - int(pos)); } - Q_REQUIRED_RESULT QByteArray sliced(qsizetype pos, qsizetype n) const - { Q_ASSERT(pos >= 0); Q_ASSERT(n >= 0); Q_ASSERT(size_t(pos) + size_t(n) <= size_t(size())); return QByteArray(data() + pos, int(n)); } - Q_REQUIRED_RESULT QByteArray chopped(int len) const - { Q_ASSERT(len >= 0); Q_ASSERT(len <= size()); return first(size() - len); } - - bool startsWith(const QByteArray &a) const; - bool startsWith(char c) const; - bool startsWith(const char *c) const; - - bool endsWith(const QByteArray &a) const; - bool endsWith(char c) const; - bool endsWith(const char *c) const; + inline bool contains(QByteArrayView bv) const; + qsizetype count(char c) const; + qsizetype count(QByteArrayView bv) const + { return QtPrivate::count(qToByteArrayViewIgnoringNull(*this), bv); } + + inline int compare(QByteArrayView a, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept; + +#if QT_CORE_REMOVED_SINCE(6, 7) + QByteArray left(qsizetype len) const; + QByteArray right(qsizetype len) const; + QByteArray mid(qsizetype index, qsizetype len = -1) const; + QByteArray first(qsizetype n) const; + QByteArray last(qsizetype n) const; + QByteArray sliced(qsizetype pos) const; + QByteArray sliced(qsizetype pos, qsizetype n) const; + QByteArray chopped(qsizetype len) const; +#else + [[nodiscard]] QByteArray left(qsizetype n) const & + { + if (n >= size()) + return *this; + return first(qMax(n, 0)); + } + [[nodiscard]] QByteArray left(qsizetype n) && + { + if (n >= size()) + return std::move(*this); + return std::move(*this).first(qMax(n, 0)); + } + [[nodiscard]] QByteArray right(qsizetype n) const & + { + if (n >= size()) + return *this; + return last(qMax(n, 0)); + } + [[nodiscard]] QByteArray right(qsizetype n) && + { + if (n >= size()) + return std::move(*this); + return std::move(*this).last(qMax(n, 0)); + } + [[nodiscard]] QByteArray mid(qsizetype index, qsizetype len = -1) const &; + [[nodiscard]] QByteArray mid(qsizetype index, qsizetype len = -1) &&; + + [[nodiscard]] QByteArray first(qsizetype n) const & + { verify(0, n); return sliced(0, n); } + [[nodiscard]] QByteArray last(qsizetype n) const & + { verify(0, n); return sliced(size() - n, n); } + [[nodiscard]] QByteArray sliced(qsizetype pos) const & + { verify(pos, 0); return sliced(pos, size() - pos); } + [[nodiscard]] QByteArray sliced(qsizetype pos, qsizetype n) const & + { verify(pos, n); return QByteArray(d.data() + pos, n); } + [[nodiscard]] QByteArray chopped(qsizetype len) const & + { verify(0, len); return sliced(0, size() - len); } + + [[nodiscard]] QByteArray first(qsizetype n) && + { + verify(0, n); + resize(n); // may detach and allocate memory + return std::move(*this); + } + [[nodiscard]] QByteArray last(qsizetype n) && + { verify(0, n); return sliced_helper(*this, size() - n, n); } + [[nodiscard]] QByteArray sliced(qsizetype pos) && + { verify(pos, 0); return sliced_helper(*this, pos, size() - pos); } + [[nodiscard]] QByteArray sliced(qsizetype pos, qsizetype n) && + { verify(pos, n); return sliced_helper(*this, pos, n); } + [[nodiscard]] QByteArray chopped(qsizetype len) && + { verify(0, len); return std::move(*this).first(size() - len); } +#endif + + bool startsWith(QByteArrayView bv) const + { return QtPrivate::startsWith(qToByteArrayViewIgnoringNull(*this), bv); } + bool startsWith(char c) const { return size() > 0 && front() == c; } + + bool endsWith(char c) const { return size() > 0 && back() == c; } + bool endsWith(QByteArrayView bv) const + { return QtPrivate::endsWith(qToByteArrayViewIgnoringNull(*this), bv); } bool isUpper() const; bool isLower() const; - void truncate(int pos); - void chop(int n); - -#if defined(Q_COMPILER_REF_QUALIFIERS) && !defined(QT_COMPILING_QSTRING_COMPAT_CPP) && !defined(Q_CLANG_QDOC) -# if defined(Q_CC_GNU) && !defined(Q_CC_CLANG) && !defined(Q_CC_INTEL) && !__has_cpp_attribute(nodiscard) - // required due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61941 -# pragma push_macro("Q_REQUIRED_RESULT") -# undef Q_REQUIRED_RESULT -# define Q_REQUIRED_RESULT -# define Q_REQUIRED_RESULT_pushed -# endif - Q_REQUIRED_RESULT QByteArray toLower() const & + [[nodiscard]] bool isValidUtf8() const noexcept + { + return QtPrivate::isValidUtf8(qToByteArrayViewIgnoringNull(*this)); + } + + void truncate(qsizetype pos); + void chop(qsizetype n); + + QByteArray &slice(qsizetype pos) + { verify(pos, 0); return remove(0, pos); } + QByteArray &slice(qsizetype pos, qsizetype n) + { + verify(pos, n); + if (isNull()) + return *this; + resize(pos + n); + return remove(0, pos); + } + +#if !defined(Q_QDOC) + [[nodiscard]] QByteArray toLower() const & { return toLower_helper(*this); } - Q_REQUIRED_RESULT QByteArray toLower() && + [[nodiscard]] QByteArray toLower() && { return toLower_helper(*this); } - Q_REQUIRED_RESULT QByteArray toUpper() const & + [[nodiscard]] QByteArray toUpper() const & { return toUpper_helper(*this); } - Q_REQUIRED_RESULT QByteArray toUpper() && + [[nodiscard]] QByteArray toUpper() && { return toUpper_helper(*this); } - Q_REQUIRED_RESULT QByteArray trimmed() const & + [[nodiscard]] QByteArray trimmed() const & { return trimmed_helper(*this); } - Q_REQUIRED_RESULT QByteArray trimmed() && + [[nodiscard]] QByteArray trimmed() && { return trimmed_helper(*this); } - Q_REQUIRED_RESULT QByteArray simplified() const & + [[nodiscard]] QByteArray simplified() const & { return simplified_helper(*this); } - Q_REQUIRED_RESULT QByteArray simplified() && + [[nodiscard]] QByteArray simplified() && { return simplified_helper(*this); } -# ifdef Q_REQUIRED_RESULT_pushed -# pragma pop_macro("Q_REQUIRED_RESULT") -# endif #else - Q_REQUIRED_RESULT QByteArray toLower() const; - Q_REQUIRED_RESULT QByteArray toUpper() const; - Q_REQUIRED_RESULT QByteArray trimmed() const; - Q_REQUIRED_RESULT QByteArray simplified() const; + [[nodiscard]] QByteArray toLower() const; + [[nodiscard]] QByteArray toUpper() const; + [[nodiscard]] QByteArray trimmed() const; + [[nodiscard]] QByteArray simplified() const; #endif - Q_REQUIRED_RESULT QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; - Q_REQUIRED_RESULT QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; + [[nodiscard]] QByteArray leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const; + [[nodiscard]] QByteArray rightJustified(qsizetype width, char fill = ' ', bool truncate = false) const; - QByteArray &prepend(char c); - inline QByteArray &prepend(int count, char c); - QByteArray &prepend(const char *s); - QByteArray &prepend(const char *s, int len); + QByteArray &prepend(char c) + { return insert(0, QByteArrayView(&c, 1)); } + inline QByteArray &prepend(qsizetype count, char c); + QByteArray &prepend(const char *s) + { return insert(0, QByteArrayView(s, qsizetype(qstrlen(s)))); } + QByteArray &prepend(const char *s, qsizetype len) + { return insert(0, QByteArrayView(s, len)); } QByteArray &prepend(const QByteArray &a); + QByteArray &prepend(QByteArrayView a) + { return insert(0, a); } + QByteArray &append(char c); - inline QByteArray &append(int count, char c); - QByteArray &append(const char *s); - QByteArray &append(const char *s, int len); + inline QByteArray &append(qsizetype count, char c); + QByteArray &append(const char *s) + { return append(s, -1); } + QByteArray &append(const char *s, qsizetype len) + { return append(QByteArrayView(s, len < 0 ? qsizetype(qstrlen(s)) : len)); } QByteArray &append(const QByteArray &a); - QByteArray &insert(int i, char c); - QByteArray &insert(int i, int count, char c); - QByteArray &insert(int i, const char *s); - QByteArray &insert(int i, const char *s, int len); - QByteArray &insert(int i, const QByteArray &a); - QByteArray &remove(int index, int len); - QByteArray &replace(int index, int len, const char *s); - QByteArray &replace(int index, int len, const char *s, int alen); - QByteArray &replace(int index, int len, const QByteArray &s); - inline QByteArray &replace(char before, const char *after); - QByteArray &replace(char before, const QByteArray &after); - inline QByteArray &replace(const char *before, const char *after); - QByteArray &replace(const char *before, int bsize, const char *after, int asize); - QByteArray &replace(const QByteArray &before, const QByteArray &after); - inline QByteArray &replace(const QByteArray &before, const char *after); - QByteArray &replace(const char *before, const QByteArray &after); + QByteArray &append(QByteArrayView a) + { return insert(size(), a); } + + QByteArray &assign(QByteArrayView v); + QByteArray &assign(qsizetype n, char c) + { + Q_ASSERT(n >= 0); + return fill(c, n); + } + template <typename InputIterator, if_input_iterator<InputIterator> = true> + QByteArray &assign(InputIterator first, InputIterator last) + { + d.assign(first, last); + d.data()[d.size] = '\0'; + return *this; + } + + QByteArray &insert(qsizetype i, QByteArrayView data); + inline QByteArray &insert(qsizetype i, const char *s) + { return insert(i, QByteArrayView(s)); } + inline QByteArray &insert(qsizetype i, const QByteArray &data) + { return insert(i, QByteArrayView(data)); } + QByteArray &insert(qsizetype i, qsizetype count, char c); + QByteArray &insert(qsizetype i, char c) + { return insert(i, QByteArrayView(&c, 1)); } + QByteArray &insert(qsizetype i, const char *s, qsizetype len) + { return insert(i, QByteArrayView(s, len)); } + + QByteArray &remove(qsizetype index, qsizetype len); + QByteArray &removeAt(qsizetype pos) + { return size_t(pos) < size_t(size()) ? remove(pos, 1) : *this; } + QByteArray &removeFirst() { return !isEmpty() ? remove(0, 1) : *this; } + QByteArray &removeLast() { return !isEmpty() ? remove(size() - 1, 1) : *this; } + + template <typename Predicate> + QByteArray &removeIf(Predicate pred) + { + removeIf_helper(pred); + return *this; + } + + QByteArray &replace(qsizetype index, qsizetype len, const char *s, qsizetype alen) + { return replace(index, len, QByteArrayView(s, alen)); } + QByteArray &replace(qsizetype index, qsizetype len, QByteArrayView s); + QByteArray &replace(char before, QByteArrayView after) + { return replace(QByteArrayView(&before, 1), after); } + QByteArray &replace(const char *before, qsizetype bsize, const char *after, qsizetype asize) + { return replace(QByteArrayView(before, bsize), QByteArrayView(after, asize)); } + QByteArray &replace(QByteArrayView before, QByteArrayView after); QByteArray &replace(char before, char after); - inline QByteArray &operator+=(char c); - inline QByteArray &operator+=(const char *s); - inline QByteArray &operator+=(const QByteArray &a); + + QByteArray &operator+=(char c) + { return append(c); } + QByteArray &operator+=(const char *s) + { return append(s); } + QByteArray &operator+=(const QByteArray &a) + { return append(a); } + QByteArray &operator+=(QByteArrayView a) + { return append(a); } QList<QByteArray> split(char sep) const; - Q_REQUIRED_RESULT QByteArray repeated(int times) const; + [[nodiscard]] QByteArray repeated(qsizetype times) const; + +#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII) +#if QT_CORE_REMOVED_SINCE(6, 8) + QT_ASCII_CAST_WARN inline bool operator==(const QString &s2) const; + QT_ASCII_CAST_WARN inline bool operator!=(const QString &s2) const; + QT_ASCII_CAST_WARN inline bool operator<(const QString &s2) const; + QT_ASCII_CAST_WARN inline bool operator>(const QString &s2) const; + QT_ASCII_CAST_WARN inline bool operator<=(const QString &s2) const; + QT_ASCII_CAST_WARN inline bool operator>=(const QString &s2) const; +#endif // QT_CORE_REMOVED_SINCE(6, 8) +#endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII) short toShort(bool *ok = nullptr, int base = 10) const; ushort toUShort(bool *ok = nullptr, int base = 10) const; @@ -337,6 +385,7 @@ public: QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const; + [[nodiscard]] QByteArray percentDecoded(char percent = '%') const; inline QByteArray &setNum(short, int base = 10); inline QByteArray &setNum(ushort, int base = 10); @@ -346,25 +395,28 @@ public: inline QByteArray &setNum(ulong, int base = 10); QByteArray &setNum(qlonglong, int base = 10); QByteArray &setNum(qulonglong, int base = 10); - inline QByteArray &setNum(float, char f = 'g', int prec = 6); - QByteArray &setNum(double, char f = 'g', int prec = 6); - QByteArray &setRawData(const char *a, uint n); // ### Qt 6: use an int - - Q_REQUIRED_RESULT static QByteArray number(int, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(uint, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(long, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(ulong, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(qlonglong, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(qulonglong, int base = 10); - Q_REQUIRED_RESULT static QByteArray number(double, char f = 'g', int prec = 6); - Q_REQUIRED_RESULT static QByteArray fromRawData(const char *, int size); + inline QByteArray &setNum(float, char format = 'g', int precision = 6); + QByteArray &setNum(double, char format = 'g', int precision = 6); + QByteArray &setRawData(const char *a, qsizetype n); + + [[nodiscard]] static QByteArray number(int, int base = 10); + [[nodiscard]] static QByteArray number(uint, int base = 10); + [[nodiscard]] static QByteArray number(long, int base = 10); + [[nodiscard]] static QByteArray number(ulong, int base = 10); + [[nodiscard]] static QByteArray number(qlonglong, int base = 10); + [[nodiscard]] static QByteArray number(qulonglong, int base = 10); + [[nodiscard]] static QByteArray number(double, char format = 'g', int precision = 6); + [[nodiscard]] static QByteArray fromRawData(const char *data, qsizetype size) + { + return QByteArray(DataPointer(nullptr, const_cast<char *>(data), size)); + } class FromBase64Result; - Q_REQUIRED_RESULT static FromBase64Result fromBase64Encoding(QByteArray &&base64, Base64Options options = Base64Encoding); - Q_REQUIRED_RESULT static FromBase64Result fromBase64Encoding(const QByteArray &base64, Base64Options options = Base64Encoding); - Q_REQUIRED_RESULT static QByteArray fromBase64(const QByteArray &base64, Base64Options options = Base64Encoding); - Q_REQUIRED_RESULT static QByteArray fromHex(const QByteArray &hexEncoded); - Q_REQUIRED_RESULT static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%'); + [[nodiscard]] static FromBase64Result fromBase64Encoding(QByteArray &&base64, Base64Options options = Base64Encoding); + [[nodiscard]] static FromBase64Result fromBase64Encoding(const QByteArray &base64, Base64Options options = Base64Encoding); + [[nodiscard]] static QByteArray fromBase64(const QByteArray &base64, Base64Options options = Base64Encoding); + [[nodiscard]] static QByteArray fromHex(const QByteArray &hexEncoded); + [[nodiscard]] static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%'); #if defined(Q_OS_DARWIN) || defined(Q_QDOC) static QByteArray fromCFData(CFDataRef data); @@ -377,63 +429,145 @@ public: NSData *toRawNSData() const Q_DECL_NS_RETURNS_AUTORELEASED; #endif +#if defined(Q_OS_WASM) || defined(Q_QDOC) + static QByteArray fromEcmaUint8Array(emscripten::val uint8array); + emscripten::val toEcmaUint8Array(); +#endif + typedef char *iterator; typedef const char *const_iterator; typedef iterator Iterator; typedef const_iterator ConstIterator; typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; - inline iterator begin(); - inline const_iterator begin() const; - inline const_iterator cbegin() const; - inline const_iterator constBegin() const; - inline iterator end(); - inline const_iterator end() const; - inline const_iterator cend() const; - inline const_iterator constEnd() const; + iterator begin() { return data(); } + const_iterator begin() const noexcept { return d.data(); } + const_iterator cbegin() const noexcept { return begin(); } + const_iterator constBegin() const noexcept { return begin(); } + iterator end() { return begin() + size(); } + const_iterator end() const noexcept { return begin() + size(); } + const_iterator cend() const noexcept { return end(); } + const_iterator constEnd() const noexcept { return end(); } reverse_iterator rbegin() { return reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } - const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } - const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } - const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); } - const_reverse_iterator crend() const { return const_reverse_iterator(begin()); } + const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } + const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } + const_reverse_iterator crbegin() const noexcept { return rbegin(); } + const_reverse_iterator crend() const noexcept { return rend(); } // stl compatibility - typedef int size_type; + typedef qsizetype size_type; typedef qptrdiff difference_type; typedef const char & const_reference; typedef char & reference; typedef char *pointer; typedef const char *const_pointer; typedef char value_type; - inline void push_back(char c); - inline void push_back(const char *c); - inline void push_back(const QByteArray &a); - inline void push_front(char c); - inline void push_front(const char *c); - inline void push_front(const QByteArray &a); + void push_back(char c) + { append(c); } + void push_back(const char *s) + { append(s); } + void push_back(const QByteArray &a) + { append(a); } + void push_back(QByteArrayView a) + { append(a); } + void push_front(char c) + { prepend(c); } + void push_front(const char *c) + { prepend(c); } + void push_front(const QByteArray &a) + { prepend(a); } + void push_front(QByteArrayView a) + { prepend(a); } void shrink_to_fit() { squeeze(); } + iterator erase(const_iterator first, const_iterator last); + inline iterator erase(const_iterator it) { return erase(it, it + 1); } + static constexpr qsizetype max_size() noexcept + { + // -1 to deal with the NUL terminator + return Data::max_size() - 1; + } - static inline QByteArray fromStdString(const std::string &s); - inline std::string toStdString() const; + static QByteArray fromStdString(const std::string &s); + std::string toStdString() const; - inline int size() const { return d->size; } - inline int count() const { return size(); } - inline int length() const { return size(); } - bool isNull() const; + inline qsizetype size() const noexcept { return d->size; } +#if QT_DEPRECATED_SINCE(6, 4) + QT_DEPRECATED_VERSION_X_6_4("Use size() or length() instead.") + inline qsizetype count() const noexcept { return size(); } +#endif + inline qsizetype length() const noexcept { return size(); } + QT_CORE_INLINE_SINCE(6, 4) + bool isNull() const noexcept; + inline const DataPointer &data_ptr() const { return d; } inline DataPointer &data_ptr() { return d; } - explicit inline QByteArray(const DataPointer &dd) - : d(dd) - { - } +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + explicit inline QByteArray(const DataPointer &dd) : d(dd) {} +#endif + explicit inline QByteArray(DataPointer &&dd) : d(std::move(dd)) {} private: - operator QNoImplicitBoolCast() const; - void reallocData(uint alloc, Data::ArrayOptions options); - void expand(int i); - QByteArray nulTerminated() const; + friend bool comparesEqual(const QByteArray &lhs, const QByteArrayView &rhs) noexcept + { return QByteArrayView(lhs) == rhs; } + friend Qt::strong_ordering + compareThreeWay(const QByteArray &lhs, const QByteArrayView &rhs) noexcept + { + const int res = QtPrivate::compareMemory(QByteArrayView(lhs), rhs); + return Qt::compareThreeWay(res, 0); + } + Q_DECLARE_STRONGLY_ORDERED(QByteArray) + Q_DECLARE_STRONGLY_ORDERED(QByteArray, QByteArrayView) + Q_DECLARE_STRONGLY_ORDERED(QByteArray, const char *) +#if defined(__GLIBCXX__) && defined(__cpp_lib_three_way_comparison) + // libstdc++ has a bug [0] when `operator const void *()` is preferred over + // `operator<=>()` when calling std::less<> and other similar methods. + // Fix it by explicitly providing relational operators in such case. + // [0]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114153 + friend bool operator<(const QByteArray &lhs, const QByteArray &rhs) noexcept + { return is_lt(compareThreeWay(lhs, rhs)); } + friend bool operator<=(const QByteArray &lhs, const QByteArray &rhs) noexcept + { return is_lteq(compareThreeWay(lhs, rhs)); } + friend bool operator>(const QByteArray &lhs, const QByteArray &rhs) noexcept + { return is_gt(compareThreeWay(lhs, rhs)); } + friend bool operator>=(const QByteArray &lhs, const QByteArray &rhs) noexcept + { return is_gteq(compareThreeWay(lhs, rhs)); } +#endif // defined(__GLIBCXX__) && defined(__cpp_lib_three_way_comparison) + + // Check isEmpty() instead of isNull() for backwards compatibility. + friend bool comparesEqual(const QByteArray &lhs, std::nullptr_t) noexcept + { return lhs.isEmpty(); } + friend Qt::strong_ordering compareThreeWay(const QByteArray &lhs, std::nullptr_t) noexcept + { return lhs.isEmpty() ? Qt::strong_ordering::equivalent : Qt::strong_ordering::greater; } + Q_DECLARE_STRONGLY_ORDERED(QByteArray, std::nullptr_t) + + // defined in qstring.cpp + friend Q_CORE_EXPORT bool comparesEqual(const QByteArray &lhs, const QChar &rhs) noexcept; + friend Q_CORE_EXPORT Qt::strong_ordering + compareThreeWay(const QByteArray &lhs, const QChar &rhs) noexcept; + friend Q_CORE_EXPORT bool comparesEqual(const QByteArray &lhs, char16_t rhs) noexcept; + friend Q_CORE_EXPORT Qt::strong_ordering + compareThreeWay(const QByteArray &lhs, char16_t rhs) noexcept; +#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII) + Q_DECLARE_STRONGLY_ORDERED(QByteArray, QChar, QT_ASCII_CAST_WARN) + Q_DECLARE_STRONGLY_ORDERED(QByteArray, char16_t, QT_ASCII_CAST_WARN) +#endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII) + + + void reallocData(qsizetype alloc, QArrayData::AllocationOption option); + void reallocGrowData(qsizetype n); + void expand(qsizetype i); + + Q_ALWAYS_INLINE constexpr void verify([[maybe_unused]] qsizetype pos = 0, + [[maybe_unused]] qsizetype n = 1) const + { + Q_ASSERT(pos >= 0); + Q_ASSERT(pos <= d.size); + Q_ASSERT(n >= 0); + Q_ASSERT(n <= d.size - pos); + } + static QByteArray sliced_helper(QByteArray &a, qsizetype pos, qsizetype n); static QByteArray toLower_helper(const QByteArray &a); static QByteArray toLower_helper(QByteArray &a); static QByteArray toUpper_helper(const QByteArray &a); @@ -442,23 +576,32 @@ private: static QByteArray trimmed_helper(QByteArray &a); static QByteArray simplified_helper(const QByteArray &a); static QByteArray simplified_helper(QByteArray &a); + template <typename Predicate> + qsizetype removeIf_helper(Predicate pred) + { + const qsizetype result = d->eraseIf(pred); + if (result > 0) + d.data()[d.size] = '\0'; + return result; + } friend class QString; - friend Q_CORE_EXPORT QByteArray qUncompress(const uchar *data, int nbytes); + friend Q_CORE_EXPORT QByteArray qUncompress(const uchar *data, qsizetype nbytes); + + template <typename T> friend qsizetype erase(QByteArray &ba, const T &t); + template <typename Predicate> friend qsizetype erase_if(QByteArray &ba, Predicate pred); }; Q_DECLARE_OPERATORS_FOR_FLAGS(QByteArray::Base64Options) -inline QByteArray::QByteArray() noexcept {} +inline constexpr QByteArray::QByteArray() noexcept {} inline QByteArray::~QByteArray() {} -inline char QByteArray::at(int i) const -{ Q_ASSERT(uint(i) < uint(size())); return d.data()[i]; } -inline char QByteArray::operator[](int i) const -{ Q_ASSERT(uint(i) < uint(size())); return d.data()[i]; } +inline char QByteArray::at(qsizetype i) const +{ verify(i, 1); return d.data()[i]; } +inline char QByteArray::operator[](qsizetype i) const +{ verify(i, 1); return d.data()[i]; } -inline bool QByteArray::isEmpty() const -{ return size() == 0; } #ifndef QT_NO_CAST_FROM_BYTEARRAY inline QByteArray::operator const char *() const { return data(); } @@ -466,183 +609,122 @@ inline QByteArray::operator const void *() const { return data(); } #endif inline char *QByteArray::data() -{ detach(); return d.data(); } -inline const char *QByteArray::data() const -{ return d.data(); } -inline const char *QByteArray::constData() const -{ return d.data(); } +{ + detach(); + Q_ASSERT(d.data()); + return d.data(); +} +inline const char *QByteArray::data() const noexcept +{ +#if QT5_NULL_STRINGS == 1 + return d.data() ? d.data() : &_empty; +#else + return d.data(); +#endif +} inline void QByteArray::detach() -{ if (d->needsDetach()) reallocData(uint(size()) + 1u, d->detachFlags()); } +{ if (d->needsDetach()) reallocData(size(), QArrayData::KeepSize); } inline bool QByteArray::isDetached() const { return !d->isShared(); } inline QByteArray::QByteArray(const QByteArray &a) noexcept : d(a.d) {} -inline int QByteArray::capacity() const -{ const auto realCapacity = d->constAllocatedCapacity(); return realCapacity ? int(realCapacity) - 1 : 0; } +inline qsizetype QByteArray::capacity() const { return qsizetype(d->constAllocatedCapacity()); } -inline void QByteArray::reserve(int asize) +inline void QByteArray::reserve(qsizetype asize) { - if (d->needsDetach() || asize > capacity()) { - reallocData(qMax(uint(size()), uint(asize)) + 1u, d->detachFlags() | Data::CapacityReserved); - } else { - d->flags() |= Data::CapacityReserved; - } + if (d->needsDetach() || asize > capacity() - d->freeSpaceAtBegin()) + reallocData(qMax(size(), asize), QArrayData::KeepSize); + if (d->constAllocatedCapacity()) + d->setFlag(Data::CapacityReserved); } inline void QByteArray::squeeze() { - if ((d->flags() & Data::CapacityReserved) == 0) + if (!d.isMutable()) return; - if (d->needsDetach() || size() < capacity()) { - reallocData(uint(size()) + 1u, d->detachFlags() & ~Data::CapacityReserved); - } else { - d->flags() &= uint(~Data::CapacityReserved); - } + if (d->needsDetach() || size() < capacity()) + reallocData(size(), QArrayData::KeepSize); + if (d->constAllocatedCapacity()) + d->clearFlag(Data::CapacityReserved); } -inline char &QByteArray::operator[](int i) -{ Q_ASSERT(i >= 0 && i < size()); return data()[i]; } +inline char &QByteArray::operator[](qsizetype i) +{ verify(i, 1); return data()[i]; } inline char &QByteArray::front() { return operator[](0); } inline char &QByteArray::back() { return operator[](size() - 1); } -inline QByteArray::iterator QByteArray::begin() -{ return data(); } -inline QByteArray::const_iterator QByteArray::begin() const -{ return data(); } -inline QByteArray::const_iterator QByteArray::cbegin() const -{ return data(); } -inline QByteArray::const_iterator QByteArray::constBegin() const -{ return data(); } -inline QByteArray::iterator QByteArray::end() -{ return data() + size(); } -inline QByteArray::const_iterator QByteArray::end() const -{ return data() + size(); } -inline QByteArray::const_iterator QByteArray::cend() const -{ return data() + size(); } -inline QByteArray::const_iterator QByteArray::constEnd() const -{ return data() + size(); } -inline QByteArray &QByteArray::append(int n, char ch) +inline QByteArray &QByteArray::append(qsizetype n, char ch) { return insert(size(), n, ch); } -inline QByteArray &QByteArray::prepend(int n, char ch) +inline QByteArray &QByteArray::prepend(qsizetype n, char ch) { return insert(0, n, ch); } -inline QByteArray &QByteArray::operator+=(char c) -{ return append(c); } -inline QByteArray &QByteArray::operator+=(const char *s) -{ return append(s); } -inline QByteArray &QByteArray::operator+=(const QByteArray &a) -{ return append(a); } -inline void QByteArray::push_back(char c) -{ append(c); } -inline void QByteArray::push_back(const char *c) -{ append(c); } -inline void QByteArray::push_back(const QByteArray &a) -{ append(a); } -inline void QByteArray::push_front(char c) -{ prepend(c); } -inline void QByteArray::push_front(const char *c) -{ prepend(c); } -inline void QByteArray::push_front(const QByteArray &a) -{ prepend(a); } -inline bool QByteArray::contains(const QByteArray &a) const -{ return indexOf(a) != -1; } inline bool QByteArray::contains(char c) const { return indexOf(c) != -1; } -inline int QByteArray::compare(const char *c, Qt::CaseSensitivity cs) const noexcept -{ - return cs == Qt::CaseSensitive ? qstrcmp(*this, c) : - qstrnicmp(data(), size(), c, -1); -} -inline int QByteArray::compare(const QByteArray &a, Qt::CaseSensitivity cs) const noexcept +inline bool QByteArray::contains(QByteArrayView bv) const +{ return indexOf(bv) != -1; } +inline int QByteArray::compare(QByteArrayView a, Qt::CaseSensitivity cs) const noexcept { - return cs == Qt::CaseSensitive ? qstrcmp(*this, a) : + return cs == Qt::CaseSensitive ? QtPrivate::compareMemory(*this, a) : qstrnicmp(data(), size(), a.data(), a.size()); } -inline bool operator==(const QByteArray &a1, const QByteArray &a2) noexcept -{ return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); } -inline bool operator==(const QByteArray &a1, const char *a2) noexcept -{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); } -inline bool operator==(const char *a1, const QByteArray &a2) noexcept -{ return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); } -inline bool operator!=(const QByteArray &a1, const QByteArray &a2) noexcept -{ return !(a1==a2); } -inline bool operator!=(const QByteArray &a1, const char *a2) noexcept -{ return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); } -inline bool operator!=(const char *a1, const QByteArray &a2) noexcept -{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); } -inline bool operator<(const QByteArray &a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) < 0; } - inline bool operator<(const QByteArray &a1, const char *a2) noexcept -{ return qstrcmp(a1, a2) < 0; } -inline bool operator<(const char *a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) < 0; } -inline bool operator<=(const QByteArray &a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) <= 0; } -inline bool operator<=(const QByteArray &a1, const char *a2) noexcept -{ return qstrcmp(a1, a2) <= 0; } -inline bool operator<=(const char *a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) <= 0; } -inline bool operator>(const QByteArray &a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) > 0; } -inline bool operator>(const QByteArray &a1, const char *a2) noexcept -{ return qstrcmp(a1, a2) > 0; } -inline bool operator>(const char *a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) > 0; } -inline bool operator>=(const QByteArray &a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) >= 0; } -inline bool operator>=(const QByteArray &a1, const char *a2) noexcept -{ return qstrcmp(a1, a2) >= 0; } -inline bool operator>=(const char *a1, const QByteArray &a2) noexcept -{ return qstrcmp(a1, a2) >= 0; } #if !defined(QT_USE_QSTRINGBUILDER) -inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2) +inline QByteArray operator+(const QByteArray &a1, const QByteArray &a2) { return QByteArray(a1) += a2; } -inline const QByteArray operator+(const QByteArray &a1, const char *a2) +inline QByteArray operator+(QByteArray &&lhs, const QByteArray &rhs) +{ return std::move(lhs += rhs); } +inline QByteArray operator+(const QByteArray &a1, const char *a2) { return QByteArray(a1) += a2; } -inline const QByteArray operator+(const QByteArray &a1, char a2) +inline QByteArray operator+(QByteArray &&lhs, const char *rhs) +{ return std::move(lhs += rhs); } +inline QByteArray operator+(const QByteArray &a1, char a2) { return QByteArray(a1) += a2; } -inline const QByteArray operator+(const char *a1, const QByteArray &a2) +inline QByteArray operator+(QByteArray &&lhs, char rhs) +{ return std::move(lhs += rhs); } +inline QByteArray operator+(const char *a1, const QByteArray &a2) { return QByteArray(a1) += a2; } -inline const QByteArray operator+(char a1, const QByteArray &a2) +inline QByteArray operator+(char a1, const QByteArray &a2) { return QByteArray(&a1, 1) += a2; } #endif // QT_USE_QSTRINGBUILDER -inline bool QByteArray::contains(const char *c) const -{ return indexOf(c) != -1; } -inline QByteArray &QByteArray::replace(char before, const char *c) -{ return replace(&before, 1, c, qstrlen(c)); } -inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c) -{ return replace(before.constData(), before.size(), c, qstrlen(c)); } -inline QByteArray &QByteArray::replace(const char *before, const char *after) -{ return replace(before, qstrlen(before), after, qstrlen(after)); } inline QByteArray &QByteArray::setNum(short n, int base) -{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(ushort(n)), base); } +{ return setNum(qlonglong(n), base); } inline QByteArray &QByteArray::setNum(ushort n, int base) { return setNum(qulonglong(n), base); } inline QByteArray &QByteArray::setNum(int n, int base) -{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(uint(n)), base); } +{ return setNum(qlonglong(n), base); } inline QByteArray &QByteArray::setNum(uint n, int base) { return setNum(qulonglong(n), base); } inline QByteArray &QByteArray::setNum(long n, int base) -{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(ulong(n)), base); } +{ return setNum(qlonglong(n), base); } inline QByteArray &QByteArray::setNum(ulong n, int base) { return setNum(qulonglong(n), base); } -inline QByteArray &QByteArray::setNum(float n, char f, int prec) -{ return setNum(double(n),f,prec); } +inline QByteArray &QByteArray::setNum(float n, char format, int precision) +{ return setNum(double(n), format, precision); } -inline std::string QByteArray::toStdString() const -{ return std::string(constData(), length()); } - -inline QByteArray QByteArray::fromStdString(const std::string &s) -{ return QByteArray(s.data(), int(s.size())); } +#if QT_CORE_INLINE_IMPL_SINCE(6, 4) +bool QByteArray::isNull() const noexcept +{ + return d->isNull(); +} +#endif +#if QT_CORE_INLINE_IMPL_SINCE(6, 7) +qsizetype QByteArray::indexOf(char ch, qsizetype from) const +{ + return qToByteArrayViewIgnoringNull(*this).indexOf(ch, from); +} +qsizetype QByteArray::lastIndexOf(char ch, qsizetype from) const +{ + return qToByteArrayViewIgnoringNull(*this).lastIndexOf(ch, from); +} +#endif -#if !defined(QT_NO_DATASTREAM) || (defined(QT_BOOTSTRAPPED) && !defined(QT_BUILD_QMAKE)) +#if !defined(QT_NO_DATASTREAM) || defined(QT_BOOTSTRAPPED) Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QByteArray &); Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QByteArray &); #endif #ifndef QT_NO_COMPRESS -Q_CORE_EXPORT QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1); -Q_CORE_EXPORT QByteArray qUncompress(const uchar* data, int nbytes); +Q_CORE_EXPORT QByteArray qCompress(const uchar* data, qsizetype nbytes, int compressionLevel = -1); +Q_CORE_EXPORT QByteArray qUncompress(const uchar* data, qsizetype nbytes); inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1) { return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); } inline QByteArray qUncompress(const QByteArray& data) @@ -659,8 +741,8 @@ public: void swap(QByteArray::FromBase64Result &other) noexcept { - qSwap(decoded, other.decoded); - qSwap(decodingStatus, other.decodingStatus); + decoded.swap(other.decoded); + std::swap(decodingStatus, other.decodingStatus); } explicit operator bool() const noexcept { return decodingStatus == QByteArray::Base64DecodingStatus::Ok; } @@ -673,27 +755,73 @@ public: QByteArray &operator*() noexcept { return decoded; } const QByteArray &operator*() const noexcept { return decoded; } #endif + + friend inline bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept + { + if (lhs.decodingStatus != rhs.decodingStatus) + return false; + + if (lhs.decodingStatus == QByteArray::Base64DecodingStatus::Ok && lhs.decoded != rhs.decoded) + return false; + + return true; + } + + friend inline bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept + { + return !(lhs == rhs); + } }; Q_DECLARE_SHARED(QByteArray::FromBase64Result) -inline bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept + +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QByteArray::FromBase64Result &key, size_t seed = 0) noexcept; + +template <typename T> +qsizetype erase(QByteArray &ba, const T &t) +{ + return ba.removeIf_helper([&t](const auto &e) { return t == e; }); +} + +template <typename Predicate> +qsizetype erase_if(QByteArray &ba, Predicate pred) +{ + return ba.removeIf_helper(pred); +} + +// +// QByteArrayView members that require QByteArray: +// +QByteArray QByteArrayView::toByteArray() const { - if (lhs.decodingStatus != rhs.decodingStatus) - return false; + return QByteArray(*this); +} - if (lhs.decodingStatus == QByteArray::Base64DecodingStatus::Ok && lhs.decoded != rhs.decoded) - return false; +namespace Qt { +inline namespace Literals { +inline namespace StringLiterals { - return true; +inline QByteArray operator""_ba(const char *str, size_t size) noexcept +{ + return QByteArray(QByteArrayData(nullptr, const_cast<char *>(str), qsizetype(size))); } -inline bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept +} // StringLiterals +} // Literals +} // Qt + +inline namespace QtLiterals { +#if QT_DEPRECATED_SINCE(6, 8) + +QT_DEPRECATED_VERSION_X_6_8("Use _ba from Qt::StringLiterals namespace instead.") +inline QByteArray operator""_qba(const char *str, size_t size) noexcept { - return !operator==(lhs, rhs); + return Qt::StringLiterals::operator""_ba(str, size); } -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QByteArray::FromBase64Result &key, size_t seed = 0) noexcept; +#endif // QT_DEPRECATED_SINCE(6, 8) +} // QtLiterals QT_END_NAMESPACE |