44 #include "private/qtools_p.h"
49 #include "private/qnumeric_p.h"
50 #include "private/qsimd_p.h"
58 #ifndef QT_NO_COMPRESS
69 #define IS_RAW_DATA(d) ((d)->flags() & QArrayData::RawDataType)
73 const char QByteArray::_empty =
'\0';
78 return c >=
'a' &&
c <=
'z' ?
c & ~0x20 :
c;
83 return c >=
'A' &&
c <=
'Z' ?
c | 0x20 :
c;
88 const char *needle0,
qsizetype needleLen);
215 int qstrcmp(
const char *str1,
const char *str2)
217 return (str1 && str2) ?
strcmp(str1, str2)
218 : (str1 ? 1 : (str2 ? -1 : 0));
262 const uchar *
s1 =
reinterpret_cast<const uchar *
>(str1);
263 const uchar *
s2 =
reinterpret_cast<const uchar *
>(str2);
269 enum { Incomplete = 256 };
280 }
while (unlimited ||
offset < max);
281 return int(Incomplete);
284 #if defined(__SSE4_1__) && !(defined(__SANITIZE_ADDRESS__) || __has_feature(address_sanitizer))
285 enum { PageSize = 4096, PageMask = PageSize - 1 };
286 const __m128i
zero = _mm_setzero_si128();
293 size_t n = PageSize - ((
u1 |
u2) & PageMask);
296 for ( ;
offset + 16 <= maxoffset;
offset +=
sizeof(__m128i)) {
298 __m128i
a = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(
s1 +
offset));
299 __m128i
b = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(
s2 +
offset));
302 __m128i cmp = _mm_cmpeq_epi8(
a,
b);
305 cmp = _mm_min_epu8(cmp,
a);
306 cmp = _mm_cmpeq_epi8(cmp,
zero);
322 int res = innerCompare(
n,
false);
323 if (
res != Incomplete)
328 return innerCompare(-1,
true);
352 const uchar *
s1 =
reinterpret_cast<const uchar *
>(str1);
353 const uchar *
s2 =
reinterpret_cast<const uchar *
>(str2);
355 return s1 ? 1 : (
s2 ? -1 : 0);
358 if (
int res = asciiLower(
c) - asciiLower(*
s2))
378 const uchar *
s1 =
reinterpret_cast<const uchar *
>(str1);
379 const uchar *
s2 =
reinterpret_cast<const uchar *
>(str2);
384 return (!
s2 || !*
s2) ? 0 : -1;
389 return len1 == 0 ? 0 : 1;
394 for (
i = 0;
i < len1; ++
i) {
399 if (
int res = asciiLower(
s1[
i]) - asciiLower(
c))
402 return s2[
i] ? -1 : 0;
407 if (
int res = asciiLower(
s1[
i]) - asciiLower(
s2[
i]))
412 return len1 < len2 ? -1 : 1;
429 return lhs.
size() ==
rhs.size() ? 0 : lhs.
size() >
rhs.size() ? 1 : -1;
442 static void createCRC16Table()
446 unsigned short crc_tbl[16];
448 for (
i = 0;
i < 16;
i++) {
455 #define SET_BIT(x, b, v) (x) |= (v) << (b)
470 printf(
"static const quint16 crc_tbl[16] = {\n");
471 for (
int i = 0;
i < 16;
i +=4)
472 printf(
" 0x%04x, 0x%04x, 0x%04x, 0x%04x,\n", crc_tbl[
i], crc_tbl[
i+1], crc_tbl[
i+2], crc_tbl[
i+3]);
477 static const quint16 crc_tbl[16] = {
478 0x0000, 0x1081, 0x2102, 0x3183,
479 0x4204, 0x5285, 0x6306, 0x7387,
480 0x8408, 0x9489, 0xa50a, 0xb58b,
481 0xc60c, 0xd68d, 0xe70e, 0xf78f
513 crc = ((
crc >> 4) & 0x0fff) ^ crc_tbl[((
crc ^
c) & 15)];
515 crc = ((
crc >> 4) & 0x0fff) ^ crc_tbl[((
crc ^
c) & 15)];
555 #ifndef QT_NO_COMPRESS
562 qWarning(
"qCompress: Data is null");
565 if (compressionLevel < -1 || compressionLevel > 9)
566 compressionLevel = -1;
568 ulong len = nbytes + nbytes / 100 + 13;
578 bazip[0] = (nbytes & 0xff000000) >> 24;
579 bazip[1] = (nbytes & 0x00ff0000) >> 16;
580 bazip[2] = (nbytes & 0x0000ff00) >> 8;
581 bazip[3] = (nbytes & 0x000000ff);
584 qWarning(
"qCompress: Z_MEM_ERROR: Not enough memory");
620 #ifndef QT_NO_COMPRESS
623 qWarning(
"qUncompress: Input data is corrupted");
637 qWarning(
"qUncompress: Data is null");
642 qWarning(
"qUncompress: Input data is corrupted");
645 size_t expectedSize = size_t((
data[0] << 24) | (
data[1] << 16) |
647 size_t len = qMax(expectedSize, 1ul);
651 return invalidCompressedData();
656 return invalidCompressedData();
659 const auto alloc =
len;
667 d.data()[
len] =
'\0';
673 qWarning(
"qUncompress: Z_MEM_ERROR: Not enough memory");
680 return invalidCompressedData();
685 return invalidCompressedData();
690 qWarning(
"qUncompress: Z_DATA_ERROR: Input data is corrupted");
1236 || (
len <
size() &&
len < (capacityAtEnd >> 1)))
1795 ::memcpy(dd.data(), d.
data(), dd.size);
1796 dd.data()[dd.size] = 0;
1799 d->reallocate(alloc,
option);
1803 void QByteArray::reallocGrowData(
qsizetype n)
1812 dd.data()[dd.size] = 0;
1871 return (*
this =
ba);
1933 return (*
this =
ba);
2016 if (
i < 0 ||
size <= 0)
2169 if (QtPrivate::q_points_into_range(after.
data(), d.
data(), d.
data() + d.
size)) {
2220 const char *
b = before.
data();
2222 const char *
a = after.
data();
2225 if (
isNull() || (
b ==
a && bsize == asize))
2229 if (QtPrivate::q_points_into_range(
a, d.
data(), d.
data() + d.
size)) {
2233 if (QtPrivate::q_points_into_range(
b, d.
data(), d.
data() + d.
size)) {
2243 if (bsize == asize) {
2250 }
else if (asize < bsize) {
2252 size_t movestart = 0;
2265 memcpy(
d + to,
a, asize);
2281 while (
index != -1) {
2315 memmove(
d + moveto,
d + movestart, (moveend - movestart));
2317 memcpy(
d + insertstart,
a, asize);
2318 moveend = movestart - bsize;
2396 result.reserve(resultSize);
2397 if (
result.capacity() != resultSize)
2403 char *
end =
result.d.data() + sizeSoFar;
2405 const qsizetype halfResultSize = resultSize >> 1;
2406 while (sizeSoFar <= halfResultSize) {
2407 memcpy(
end,
result.d.data(), sizeSoFar);
2411 memcpy(
end,
result.d.data(), resultSize - sizeSoFar);
2412 result.d.data()[resultSize] =
'\0';
2413 result.d.size = resultSize;
2418 if (ol_minus_1 < sizeof(std::size_t) * CHAR_BIT) \
2419 hashHaystack -= std::size_t(a) << ol_minus_1; \
2425 from = qMax(from + haystack.size(),
qsizetype(0));
2426 if (from < haystack.size()) {
2427 const char *
const b = haystack.data();
2428 if (
const auto n =
static_cast<const char *
>(
2429 memchr(
b + from, needle,
static_cast<size_t>(haystack.size() - from)))) {
2438 const auto ol = needle.size();
2439 const auto l = haystack.size();
2442 return qMax(from +
l, 0);
2444 return from >
l ? -1 : from;
2448 return findCharHelper(haystack, from, needle.front());
2450 if (from >
l || ol + from >
l)
2453 return qFindByteArray(haystack.data(), haystack.size(), from, needle.data(), ol);
2490 auto delta =
l - ol;
2493 if (from < 0 || from >
l)
2498 const char *
end = haystack;
2500 const auto ol_minus_1 = std::size_t(ol - 1);
2501 const char *
n = needle + ol_minus_1;
2502 const char *
h = haystack + ol_minus_1;
2503 std::size_t hashNeedle = 0, hashHaystack = 0;
2506 hashNeedle = ((hashNeedle<<1) + *(
n-
idx));
2507 hashHaystack = ((hashHaystack<<1) + *(
h-
idx));
2509 hashHaystack -= *haystack;
2510 while (haystack >=
end) {
2511 hashHaystack += *haystack;
2512 if (hashHaystack == hashNeedle && memcmp(needle, haystack, ol) == 0)
2513 return haystack -
end;
2515 REHASH(*(haystack + ol));
2523 if (haystack.size() == 0)
2526 from += haystack.size();
2527 else if (from > haystack.size())
2528 from = haystack.size() - 1;
2530 const char *
b = haystack.data();
2531 const char *
n =
b + from + 1;
2542 if (haystack.isEmpty()) {
2543 if (needle.isEmpty() && from == 0)
2547 const auto ol = needle.size();
2549 return lastIndexOfCharHelper(haystack, from, needle.front());
2551 return lastIndexOfHelper(haystack.data(), haystack.size(), needle.data(), ol, from);
2612 for (
char ch : haystack) {
2621 if (needle.size() == 0)
2622 return haystack.size() + 1;
2624 if (needle.size() == 1)
2625 return countCharHelper(haystack, needle[0]);
2629 if (haystack.size() > 500 && needle.size() > 5) {
2631 while ((
i = matcher.
indexIn(haystack,
i + 1)) != -1)
2634 while ((
i = haystack.indexOf(needle,
i + 1)) != -1)
2659 return static_cast<int>(countCharHelper(*
this,
ch));
2683 if (haystack.size() < needle.size())
2685 if (haystack.data() == needle.data() || needle.size() == 0)
2687 return memcmp(haystack.data(), needle.data(), needle.size()) == 0;
2712 if (haystack.size() < needle.size())
2714 if (haystack.end() == needle.end() || needle.size() == 0)
2716 return memcmp(haystack.end() - needle.size(), needle.data(), needle.size()) == 0;
2743 static constexpr
inline bool isUpperCaseAscii(
char c)
2745 return c >=
'A' &&
c <=
'Z';
2751 static constexpr
inline bool isLowerCaseAscii(
char c)
2753 return c >=
'a' &&
c <=
'z';
2862 switch (QContainerImplHelper::mid(
size(), &
p, &
l)) {
2865 case QContainerImplHelper::Empty:
2869 case QContainerImplHelper::Full:
2871 case QContainerImplHelper::Subset:
2962 template <
typename T>
2968 const char *firstBad = orig_begin;
2969 const char *
e =
input.constEnd();
2970 for ( ; firstBad !=
e ; ++firstBad) {
2973 if (
ch != converted)
2978 return std::move(
input);
2982 char *
b =
s.begin();
2983 char *
p =
b + (firstBad - orig_begin);
2985 for ( ;
p !=
e; ++
p)
2992 return toCase_template(
a, asciiLower);
2997 return toCase_template(
a, asciiLower);
3014 return toCase_template(
a, asciiUpper);
3019 return toCase_template(
a, asciiUpper);
3034 #if !defined(QT_NO_DATASTREAM) || defined(QT_BOOTSTRAPPED)
3066 if (
len == 0xffffffff)
3069 const quint32 Step = 1024 * 1024;
3081 }
while (allocated <
len);
3437 auto stop =
view.end();
3523 #if defined(QT_CHECK_RANGE)
3525 qWarning(
"QByteArray::toIntegral: Invalid base %d",
base);
3541 #if defined(QT_CHECK_RANGE)
3543 qWarning(
"QByteArray::toIntegral: Invalid base %d",
base);
3811 bool nonNullOk =
false;
3874 const char alphabet_base64[] =
"ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
3875 "ghijklmn" "opqrstuv" "wxyz0123" "456789+/";
3876 const char alphabet_base64url[] =
"ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
3877 "ghijklmn" "opqrstuv" "wxyz0123" "456789-_";
3879 const char padchar =
'=';
3886 while (
i <
size()) {
3900 int j = (
chunk & 0x00fc0000) >> 18;
3901 int k = (
chunk & 0x0003f000) >> 12;
3902 int l = (
chunk & 0x00000fc0) >> 6;
3903 int m = (
chunk & 0x0000003f);
3983 #if defined(QT_CHECK_RANGE)
3989 const char b =
'a' - 10;
3993 *--
p =
c + (
c < 10 ?
'0' :
b);
4006 const int buffsize = 66;
4007 char buff[buffsize];
4031 const int buffsize = 66;
4032 char buff[buffsize];
4033 char *
p = qulltoa2(buff + buffsize,
n,
base);
4169 switch (asciiLower(
format)) {
4180 #if defined(QT_CHECK_RANGE)
4181 qWarning(
"QByteArray::setNum: Invalid format char '%c'",
format);
4249 struct fromBase64_helper_result {
4254 fromBase64_helper_result fromBase64_helper(
const char *
input,
qsizetype inputSize,
4256 QByteArray::Base64Options options)
4260 unsigned int buf = 0;
4268 if (
ch >=
'A' &&
ch <=
'Z') {
4270 }
else if (
ch >=
'a' &&
ch <=
'z') {
4272 }
else if (
ch >=
'0' &&
ch <=
'9') {
4287 if ((inputSize % 4) != 0) {
4290 }
else if ((
i == inputSize - 1) ||
4291 (
i == inputSize - 2 &&
input[++
i] ==
'=')) {
4354 if (base64.isDetached()) {
4355 const auto base64result = fromBase64_helper(base64.data(),
4359 base64.truncate(
int(base64result.decodedLength));
4360 return { std::move(base64), base64result.status };
4369 const auto base64Size = base64.
size();
4371 const auto base64result = fromBase64_helper(base64.
data(),
4373 const_cast<char *
>(
result.constData()),
4375 result.truncate(
int(base64result.decodedLength));
4376 return { std::move(
result), base64result.status };
4406 return std::move(
result.decoded);
4426 bool odd_digit =
true;
4467 char *hexData =
hex.data();
4473 if ((separator) && (
o <
length))
4474 hexData[
o++] = separator;
4485 const char *inputPtr =
data;
4494 if (
c == percent &&
i + 2 <
len) {
4498 if (
a >=
'0' &&
a <=
'9')
a -=
'0';
4499 else if (
a >=
'a' &&
a <=
'f')
a =
a -
'a' + 10;
4500 else if (
a >=
'A' &&
a <=
'F')
a =
a -
'A' + 10;
4502 if (
b >=
'0' &&
b <=
'9')
b -=
'0';
4503 else if (
b >=
'a' &&
b <=
'f')
b =
b -
'a' + 10;
4504 else if (
b >=
'A' &&
b <=
'F')
b =
b -
'A' + 10;
4506 *
data++ = (char)((
a << 4) |
b);
4544 if (
input.isEmpty())
4573 static inline bool q_strchr(
const char str[],
char chr)
4575 if (!
str)
return false;
4577 const char *ptr =
str;
4579 while ((
c = *ptr++))
4592 const char *inputData =
input.constData();
4593 char *output =
nullptr;
4597 unsigned char c = *inputData++;
4598 if (((
c >= 0x61 &&
c <= 0x7A)
4599 || (
c >= 0x41 &&
c <= 0x5A)
4600 || (
c >= 0x30 &&
c <= 0x39)
4605 || q_strchr(dontEncode,
c))
4606 && !q_strchr(alsoEncode,
c)) {
4616 output[
length++] = percent;
4670 if ((percent >= 0x61 && percent <= 0x7A)
4671 || (percent >= 0x41 && percent <= 0x5A)
4672 || (percent >= 0x30 && percent <= 0x39)
4677 include2 += percent;
4880 return qHashMulti(seed,
key.decoded,
static_cast<int>(
key.decodingStatus));
small capitals from c petite p scientific f u
small capitals from c petite p scientific i
[1]
The QByteArray::FromBase64Result class holds the result of a call to QByteArray::fromBase64Encoding.
size_t qHash(const QByteArray::FromBase64Result &key, size_t seed) noexcept
The QByteArray class provides an array of bytes.
qulonglong toULongLong(bool *ok=nullptr, int base=10) const
qlonglong toLongLong(bool *ok=nullptr, int base=10) const
char * qstrncpy(char *dst, const char *src, size_t len)
const_iterator constBegin() const noexcept
QByteArray & prepend(char c)
size_t qstrlen(const char *str)
QByteArray repeated(qsizetype times) const
QDataStream & operator<<(QDataStream &out, const QByteArray &ba)
QDataStream & operator>>(QDataStream &in, QByteArray &ba)
QByteArray & operator=(const QByteArray &) noexcept
uint toUInt(bool *ok=nullptr, int base=10) const
QByteArray & fill(char c, qsizetype size=-1)
QByteArray qCompress(const uchar *data, qsizetype nbytes, int compressionLevel)
qsizetype size() const noexcept
quint16 qChecksum(QByteArrayView data, Qt::ChecksumType standard)
static QByteArray fromHex(const QByteArray &hexEncoded)
QByteArray qUncompress(const QByteArray &data)
QByteArray last(qsizetype n) const
const char * constData() const noexcept
QByteArray & setNum(short, int base=10)
int toInt(bool *ok=nullptr, int base=10) const
QList< QByteArray > split(char sep) const
int qstricmp(const char *str1, const char *str2)
static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent='%')
qsizetype indexOf(char c, qsizetype from=0) const
iterator erase(const_iterator first, const_iterator last)
qsizetype length() const noexcept
ushort toUShort(bool *ok=nullptr, int base=10) const
const char * const_iterator
long toLong(bool *ok=nullptr, int base=10) const
void truncate(qsizetype pos)
double toDouble(bool *ok=nullptr) const
static QByteArray fromBase64(const QByteArray &base64, Base64Options options=Base64Encoding)
@ AbortOnBase64DecodingErrors
QByteArray right(qsizetype len) const
char at(qsizetype i) const
QByteArray toPercentEncoding(const QByteArray &exclude=QByteArray(), const QByteArray &include=QByteArray(), char percent='%') const
int qstrnicmp(const char *str1, const char *str2, size_t len)
QByteArray & insert(qsizetype i, QByteArrayView data)
bool isEmpty() const noexcept
constexpr QByteArray() noexcept
short toShort(bool *ok=nullptr, int base=10) const
const_iterator cbegin() const noexcept
ulong toULong(bool *ok=nullptr, int base=10) const
static QByteArray number(int, int base=10)
qsizetype count() const noexcept
float toFloat(bool *ok=nullptr) const
char * qstrcpy(char *dst, const char *src)
QByteArray leftJustified(qsizetype width, char fill=' ', bool truncate=false) const
QByteArrayData DataPointer
int qstrcmp(const char *str1, const char *str2)
QByteArray left(qsizetype len) const
QByteArray rightJustified(qsizetype width, char fill=' ', bool truncate=false) const
qsizetype lastIndexOf(char c, qsizetype from=-1) const
qsizetype capacity() const
void resize(qsizetype size)
QByteArray & remove(qsizetype index, qsizetype len)
QByteArray & append(char c)
QByteArray toBase64(Base64Options options=Base64Encoding) const
char * qstrdup(const char *src)
qsizetype count(char c) const
QByteArray & setRawData(const char *a, qsizetype n)
QByteArray toHex(char separator='\0') const
bool isNull() const noexcept
QByteArray mid(qsizetype index, qsizetype len=-1) const
static FromBase64Result fromBase64Encoding(QByteArray &&base64, Base64Options options=Base64Encoding)
static QByteArray fromRawData(const char *data, qsizetype size)
QByteArray & replace(qsizetype index, qsizetype len, const char *s, qsizetype alen)
The QByteArrayMatcher class holds a sequence of bytes that can be quickly matched in a byte array.
Q_WEAK_OVERLOAD qsizetype indexIn(const QByteArray &ba, qsizetype from=0) const
constexpr bool isNull() const noexcept
constexpr qsizetype size() const noexcept
qsizetype lastIndexOf(QByteArrayView a) const noexcept
constexpr const_pointer data() const noexcept
qsizetype indexOf(QByteArrayView a, qsizetype from=0) const noexcept
double toDouble(bool *ok=nullptr) const
The QDataStream class provides serialization of binary data to a QIODevice.
int ZEXPORT compress2(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
auto it unsigned count const
register bit_buf_type register int int nbits
GeneratorWrapper< std::vector< T > > chunk(size_t size, GeneratorWrapper< T > &&generator)
constexpr Initialization Uninitialized
constexpr char toHexUpper(uint value) noexcept
constexpr char toHexLower(uint value) noexcept
constexpr int fromHex(uint c) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool endsWith(QByteArrayView haystack, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< qulonglong > toUnsignedInteger(QByteArrayView data, int base)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION QByteArrayView trimmed(QByteArrayView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< qlonglong > toSignedInteger(QByteArrayView data, int base)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool startsWith(QByteArrayView haystack, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype lastIndexOf(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype count(QByteArrayView haystack, QByteArrayView needle) noexcept
Q_CORE_EXPORT int compareMemory(QByteArrayView lhs, QByteArrayView rhs)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< float > toFloat(QByteArrayView a) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype findByteArray(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< double > toDouble(QByteArrayView a) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool isValidUtf8(QByteArrayView s) noexcept
constexpr struct q20::ranges::@311 none_of
int distance(TestIterator &a, TestIterator &b)
void *PRIV() memmove(void *d, const void *s, size_t n)
int PRIV() strcmp(PCRE2_SPTR str1, PCRE2_SPTR str2)
PCRE2_SIZE PRIV() strlen(PCRE2_SPTR str)
QT_POPCOUNT_RELAXED_CONSTEXPR uint qCountLeadingZeroBits(quint32 v) noexcept
constexpr uint qCountTrailingZeroBits(quint32 v) noexcept
void q_normalizePercentEncoding(QByteArray *ba, const char *exclude)
void q_fromPercentEncoding(QByteArray *ba)
qsizetype qFindByteArray(const char *haystack0, qsizetype haystackLen, qsizetype from, const char *needle0, qsizetype needleLen)
void q_toPercentEncoding(QByteArray *ba, const char *exclude, const char *include)
QByteArrayView qToByteArrayViewIgnoringNull(const QByteArrayLike &b) noexcept
typedef QByteArray(EGLAPIENTRYP PFNQGSGETDISPLAYSPROC)()
QT_BEGIN_INCLUDE_NAMESPACE typedef unsigned char uchar
constexpr QtPrivate::QHashMultiReturnType< T... > qHashMulti(size_t seed, const T &... args) noexcept(std::conjunction_v< QtPrivate::QNothrowHashable< T >... >)
GLenum GLuint GLenum GLsizei length
GLint GLfloat GLfloat GLfloat v2
GLboolean GLboolean GLboolean b
GLboolean GLboolean GLboolean GLboolean a
[7]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat s1
GLenum GLenum GLsizei count
GLenum GLuint GLenum GLsizei const GLchar * buf
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLenum GLuint GLintptr offset
GLint GLfloat GLfloat GLfloat GLfloat v3
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
GLint GLsizei GLsizei GLenum format
GLsizei GLenum const void * indices
GLfloat GLfloat GLfloat GLfloat h
GLenum GLenum GLenum input
GLenum GLint GLint * precision
Q_CHECK_PTR(a=new int[80])
QTextStream out(stdout)
[7]
void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data, QArrayDataPointer *old)
bool isNull() const noexcept
qsizetype freeSpaceAtBegin() const noexcept
bool needsDetach() const noexcept
qsizetype allocatedCapacity() noexcept
qsizetype freeSpaceAtEnd() const noexcept
qsizetype constAllocatedCapacity() const noexcept
void clear() noexcept(std::is_nothrow_destructible< T >::value)
static QArrayDataPointer fromRawData(const T *rawData, qsizetype length) noexcept
static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
bool isMutable() const noexcept
static quint64 bytearrayToUnsLongLong(QByteArrayView num, int base, bool *ok)
static float convertDoubleToFloat(double d, bool *ok)
static Q_CORE_EXPORT qint64 bytearrayToLongLong(QByteArrayView num, int base, bool *ok)
static StringType trimmed_helper(StringType &str)
static void trimmed_helper_positions(const Char *&begin, const Char *&end)
static StringType simplified_helper(StringType &str)
static QPair< QTypedArrayData *, T * > allocate(qsizetype capacity, AllocationOption option=QArrayData::KeepSize)
static ValidUtf8Result isValidUtf8(QByteArrayView in)
void copyAppend(const T *b, const T *e)
void erase(T *b, qsizetype n)
void insert(qsizetype i, const T *data, qsizetype n)
ByteArray detached(ByteArray b)
int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)