Qt 4.8: QByteArray Class Reference

Data * d

Definition: qbytearray.h:386

QBasicAtomicInt ref

Definition: qbytearray.h:139

QBasicAtomicInt::ref

bool ref()

Definition: qatomic_alpha.h:495

QByteArray::shared_null

static Data shared_null

Definition: qbytearray.h:384

◆ QByteArray() [2/7]

QByteArray::QByteArray ( const char * str )

Constructs a byte array initialized with the string str.

QByteArray makes a deep copy of the string data.

Definition at line 1401 of file qbytearray.cpp.

 {
     if (!str) {
         d = &shared_null;
     } else if (!*str) {
         d = &shared_empty;
     } else {
         int len = qstrlen(str);
         d = static_cast<Data *>(qMalloc(sizeof(Data)+len));
         Q_CHECK_PTR(d);
         d->ref = 0;;
         d->alloc = d->size = len;
         d->data = d->array;
         memcpy(d->array, str, len+1); // include null terminator
     }
     d->ref.ref();
 }

◆ QByteArray() [3/7]

QByteArray::QByteArray	(	const char *	data,
		int	size
	)

Constructs a byte array containing the first size bytes of array data.

If data is 0, a null byte array is constructed.

QByteArray makes a deep copy of the string data.

See also: fromRawData()

Definition at line 1430 of file qbytearray.cpp.

 {
     if (!data) {
         d = &shared_null;
     } else if (size <= 0) {
         d = &shared_empty;
     } else {
         d = static_cast<Data *>(qMalloc(sizeof(Data) + size));
         Q_CHECK_PTR(d);
         d->ref = 0;
         d->alloc = d->size = size;
         d->data = d->array;
         memcpy(d->array, data, size);
         d->array[size] = '\0';
     }
     d->ref.ref();
 }

◆ QByteArray() [4/7]

QByteArray::QByteArray	(	int	size,
		char	ch
	)

Constructs a byte array of size size with every byte set to character ch.

See also: fill()

Definition at line 1455 of file qbytearray.cpp.

 {
     if (size <= 0) {
         d = &shared_null;
     } else {
         d = static_cast<Data *>(qMalloc(sizeof(Data)+size));
         Q_CHECK_PTR(d);
         d->ref = 0;
         d->alloc = d->size = size;
         d->data = d->array;
         d->array[size] = '\0';
         memset(d->array, ch, size);
     }
     d->ref.ref();
 }

◆ QByteArray() [5/7]

QByteArray::QByteArray	(	int	size,
		Qt::Initialization
	)

Constructs a byte array of size size with uninitialized contents.

Warning: This function is not part of the public interface.

Definition at line 1480 of file qbytearray.cpp.

 {
     if (size <= 0) {
         d = &shared_empty;
     } else {
         d = static_cast<Data *>(qMalloc(sizeof(Data)+size));
         Q_CHECK_PTR(d);
         d->ref = 0;
         d->alloc = d->size = size;
         d->data = d->array;
         d->array[size] = '\0';
     }
     d->ref.ref();
 }

◆ QByteArray() [6/7]

QByteArray::QByteArray ( const QByteArray & other )

inline

Constructs a copy of other.

This operation takes constant time, because QByteArray is implicitly shared. This makes returning a QByteArray from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), taking linear time.

See also: operator=()

Definition at line 439 of file qbytearray.h.

439 : d(a.d)

440 { d->ref.ref(); }

Data * d

Definition: qbytearray.h:386

QBasicAtomicInt ref

Definition: qbytearray.h:139

QBasicAtomicInt::ref

bool ref()

Definition: qatomic_alpha.h:495

long ASN1_INTEGER_get ASN1_INTEGER * a

Definition: qsslsocket_openssl_symbols.cpp:104

◆ ~QByteArray()

QByteArray::~QByteArray ( )

inline

Destroys the byte array.

Definition at line 401 of file qbytearray.h.

401 { if (!d->ref.deref()) qFree(d); }

Data * d

Definition: qbytearray.h:386

qFree

Q_CORE_EXPORT void qFree(void *ptr)

Definition: qmalloc.cpp:58

QBasicAtomicInt ref

Definition: qbytearray.h:139

QBasicAtomicInt::deref

bool deref()

Definition: qatomic_alpha.h:500

◆ QByteArray() [7/7]

QByteArray::QByteArray	(	Data *	dd,
		int	,
		int
	)

inlineprivate

Definition at line 387 of file qbytearray.h.

387 : d(dd) {}

Referenced by _q_dupEnvironment(), QFileSystemEngine::absoluteName(), QScript::QObjectConnectionManager::addSignalHandler(), QHttpNetworkReplyPrivate::appendCompressedReplyData(), QDeclarativeCompiler::buildDynamicMeta(), QUrlPrivate::canonicalHost(), QDeclarativeCompiler::compileAlias(), QDeclarativeListModelParser::compileProperty(), QDeclarativeObjectMethodScriptClass::connect(), QObject::connect(), ShaderEffectItem::connectPropertySignals(), QWindowsMimeURI::convertFromMime(), QDeclarativeObjectMethodScriptClass::disconnect(), QObject::disconnect(), QDeclarativeXMLHttpRequest::downloadProgress(), QDeclarativeCompiler::dumpStats(), QGLEngineSharedShaders::findProgramInCache(), QDeclarativeXMLHttpRequest::finished(), QGLPixmapConvolutionFilter::generateConvolutionShader(), generateGlyphTables(), QHttpNetworkReplyPrivate::getChunkSize(), QRegExpEngine::getEscape(), Maemo::getVariantFromDBusMessage(), QHttpNetworkReplyPrivate::gunzipBodyPartially(), QSslSocketBackendPrivate::initSslContext(), QMetaMethod::invoke(), QTextList::itemText(), QAxServerBase::Load(), QScriptEnginePrivate::newQObject(), QUrlPrivate::normalized(), QIBaseDriver::open(), operator+=(), QDeclarativeCompiledData::pack(), QDBusMetaObjectGenerator::parseMethods(), QDBusMetaObjectGenerator::parseSignals(), QWSDirectPainterSurface::permanentState(), QHttpNetworkConnectionChannel::pipelineInto(), prepend(), QPdfEnginePrivate::printString(), QDeclarativeBindingCompiler::program(), push_back(), qEncodeHmacMd5(), qEncodeLmv2Response(), qEncodeNtlmv2Response(), qGetBinaryData(), QGLEngineSharedShaders::QGLEngineSharedShaders(), QTest::qSignalDumperCallback(), qstring_to_xtp(), qt_socks5_set_host_address_and_port(), qt_socks5_set_host_name_and_port(), read_xpm_body(), QHttpNetworkReplyPrivate::readHeader(), QHttpNetworkReplyPrivate::readStatus(), QPacketProtocolPrivate::readyToRead(), QAuthDevice::recvReadyRead(), QScript::QObjectConnectionManager::removeSignalHandler(), QOstDevicePrivate::RunL(), runlengthEncode(), QWinSettingsPrivate::set(), QDeclarativeParser::Object::setBindingBit(), QNetworkHeadersPrivate::setRawHeaderInternal(), QSslSocketBackendPrivate::startHandshake(), QTest::toString(), QLocalePrivate::validateChars(), Maemo::IAPConfPrivate::valueToVariant(), QWindowsPipeWriter::write(), and write_pbm_image().

Data * d

Definition: qbytearray.h:386

Functions

◆ append() [1/5]

QByteArray & QByteArray::append ( char ch )

Appends the character ch to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1817 of file qbytearray.cpp.

 {
     if (d->ref != 1 || d->size + 1 > d->alloc)
         realloc(qAllocMore(d->size + 1, sizeof(Data)));
     d->data[d->size++] = ch;
     d->data[d->size] = '\0';
     return *this;
 }

◆ append() [2/5]

QByteArray & QByteArray::append ( const char * str )

Appends the string str to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1767 of file qbytearray.cpp.

 {
     if (str) {
         int len = qstrlen(str);
         if (d->ref != 1 || d->size + len > d->alloc)
             realloc(qAllocMore(d->size + len, sizeof(Data)));
         memcpy(d->data + d->size, str, len + 1); // include null terminator
         d->size += len;
     }
     return *this;
 }

◆ append() [3/5]

QByteArray & QByteArray::append	(	const char *	s,
		int	len
	)

Definition at line 1794 of file qbytearray.cpp.

 {
     if (len < 0)
         len = qstrlen(str);
     if (str && len) {
         if (d->ref != 1 || d->size + len > d->alloc)
             realloc(qAllocMore(d->size + len, sizeof(Data)));
         memcpy(d->data + d->size, str, len); // include null terminator
         d->size += len;
         d->data[d->size] = '\0';
     }
     return *this;
 }

◆ append() [4/5]

QByteArray & QByteArray::append ( const QByteArray & ba )

Appends the byte array ba onto the end of this byte array.

Example:

QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"

This is the same as insert(size(), ba).

Note: QByteArray is an implicitly shared class. Consequently, if this is an empty QByteArray, then this will just share the data held in ba. In this case, no copying of data is done, taking constant time. If a shared instance is modified, it will be copied (copy-on-write), taking linear time.

If this is not an empty QByteArray, a deep copy of the data is performed, taking linear time.

This operation typically does not suffer from allocation overhead, because QByteArray preallocates extra space at the end of the data so that it may grow without reallocating for each append operation.

See also: operator+=(), prepend(), insert()

Definition at line 1729 of file qbytearray.cpp.

 {
     if ((d == &shared_null || d == &shared_empty) && !IS_RAW_DATA(ba.d)) {
         *this = ba;
     } else if (ba.d != &shared_null) {
         if (d->ref != 1 || d->size + ba.d->size > d->alloc)
             realloc(qAllocMore(d->size + ba.d->size, sizeof(Data)));
         memcpy(d->data + d->size, ba.d->data, ba.d->size);
         d->size += ba.d->size;
         d->data[d->size] = '\0';
     }
     return *this;
 }

◆ append() [5/5]

QByteArray & QByteArray::append ( const QString & str )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Appends the string str to this byte array.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 996 of file qstring.h.

997 { return append(s.toAscii()); }

Referenced by QFontDatabasePrivate::addQPF2File(), MetaObjectGenerator::addSetterSlot(), QSocks5PasswordAuthenticator::continueAuthenticate(), QWindowsMimeHtml::convertToMime(), QDBusArgumentPrivate::createSignature(), QODBCResult::exec(), QDeclarativeImportedNamespace::find_helper(), fromBase64(), fromHex(), QUrl::fromPunycode(), QXmlInputSource::fromRawData(), QXmlStreamReaderPrivate::getChar_helper(), QSettingsPrivate::iniEscapedString(), QWSDisplay::Data::init(), QSettingsPrivate::iniUnescapedKey(), QSettingsPrivate::iniUnescapedStringList(), QDeclarativeCompiler::isAttachedPropertyName(), QDeclarativeCompiler::isSignalPropertyName(), matchLineFeed(), QXlibMime::mimeConvertToFormat(), nextField(), nextNonWhitespace(), QUrlPrivate::normalized(), normalizeTypeInternal(), QSocks5SocketEnginePrivate::parseAuthenticationMethodReply(), QHttpNetworkReplyPrivate::parseHeader(), parseHeaderName(), parseHttpOptionHeader(), QSocks5SocketEnginePrivate::parseRequestMethodReply(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QHttpNetworkReplyPrivate::parseStatus(), QPictureIO::pictureFormat(), qax_generateDocumentation(), qDecodeDataUrl(), qHash(), qt_read_xpm_image_or_array(), read_xpm_string(), MetaObjectGenerator::readFuncsInfo(), QConfFileSettingsPrivate::readIniFile(), QConfFileSettingsPrivate::readIniLine(), QConfFileSettingsPrivate::readIniSection(), QPlatformFontDatabase::registerQPF2Font(), QUrl::resolved(), QUrl::setEncodedQueryItems(), QUrlPrivate::setEncodedUrl(), QWSDirectPainterSurface::setPermanentState(), QProcess::setReadChannel(), size(), QPatternist::HexBinary::stringValue(), QChar::toAscii(), toType(), QIntValidator::validate(), variantToString(), and QX11Data::xdndMimeConvertToFormat().

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

◆ at()

char QByteArray::at ( int i ) const

inline

Returns the character at index position i in the byte array.

i must be a valid index position in the byte array (i.e., 0 <= i < size()).

See also: operator[]()

Definition at line 413 of file qbytearray.h.

414 { Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

#define Q_ASSERT(cond)

Definition: qglobal.h:1823

unsigned int uint

Definition: qglobal.h:996

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ begin() [1/2]

QByteArray::iterator QByteArray::begin ( )

inline

Warning: This function is not part of the public interface.

Definition at line 493 of file qbytearray.h.

Referenced by QDeclarativeComponentPrivate::beginCreate().

494 { detach(); return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

QByteArray::detach

void detach()

Definition: qbytearray.h:435

◆ begin() [2/2]

QByteArray::const_iterator QByteArray::begin ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 495 of file qbytearray.h.

496 { return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

◆ capacity()

int QByteArray::capacity ( ) const

inline

Returns the maximum number of bytes that can be stored in the byte array without forcing a reallocation.

The sole purpose of this function is to provide a means of fine tuning QByteArray's memory usage. In general, you will rarely ever need to call this function. If you want to know how many bytes are in the byte array, call size().

See also: reserve(), squeeze()

Definition at line 446 of file qbytearray.h.

447 { return d->alloc; }

QByteArray::Data::alloc

int alloc

Definition: qbytearray.h:140

Data * d

Definition: qbytearray.h:386

◆ chop()

void QByteArray::chop ( int n )

Removes n bytes from the end of the byte array.

If n is greater than size(), the result is an empty byte array.

Example:

QByteArray ba("STARTTLS\r\n");

ba.chop(2); // ba == "STARTTLS"

See also: truncate(), resize(), left()

Definition at line 1289 of file qbytearray.cpp.

Referenced by MetaObjectGenerator::addProperty(), qDecodeDataUrl(), qErrnoWarning(), QTest::qSignalDumperCallback(), qt_inflateGZipDataFrom(), QMimeDataPrivate::retrieveTypedData(), QSslCertificate::serialNumber(), and QUrlPrivate::toEncoded().

 {
     if (n > 0)
         resize(d->size - n);
 }

◆ clear()

void QByteArray::clear ( )

Clears the contents of the byte array and makes it empty.

See also: resize(), isEmpty()

Definition at line 2907 of file qbytearray.cpp.

 {
     if (!d->ref.deref())
         qFree(d);
     d = &shared_null;
     d->ref.ref();
 }

◆ constBegin()

QByteArray::const_iterator QByteArray::constBegin ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 497 of file qbytearray.h.

498 { return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

◆ constData()

const char * QByteArray::constData ( ) const

inline

Returns a pointer to the data stored in the byte array.

The pointer can be used to access the bytes that compose the array. The data is '\0'-terminated unless the QByteArray object was created from raw data. The pointer remains valid as long as the byte array isn't reallocated or destroyed.

This function is mostly useful to pass a byte array to a function that accepts a const char *.

Note: A QByteArray can store any byte values including '\0's, but most functions that take char * arguments assume that the data ends at the first '\0' they encounter.

See also: data(), operator[](), fromRawData()

Definition at line 433 of file qbytearray.h.

434 { return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

◆ constEnd()

QByteArray::const_iterator QByteArray::constEnd ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 503 of file qbytearray.h.

504 { return d->data + d->size; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

Referenced by addDefaultArguments(), buildSpec(), QAuthenticatorPrivate::calculateResponse(), QSvgIOHandler::canRead(), QByteDataBuffer::canReadLine(), QHttpNetworkConnectionChannel::detectPipeliningSupport(), fontFile(), QScript::QObjectDelegate::getOwnPropertyDescriptor(), QScript::QObjectDelegate::getOwnPropertySlot(), initializeDb(), QUrlPrivate::mergePaths(), QUrlPrivate::normalized(), QBBButtonEventNotifier::parsePPS(), QScript::QObjectDelegate::put(), qDetectCPUFeatures(), QPictureHandler::QPictureHandler(), qt_init(), read_xbm_body(), MetaObjectGenerator::readFuncsInfo(), QHttpNetworkReplyPrivate::readHeader(), setupLocaleMapper(), and QNetworkCookie::toRawForm().

int size

Definition: qbytearray.h:140

◆ contains() [1/3]

QBool QByteArray::contains ( char ch ) const

inline

Returns true if the byte array contains the character ch; otherwise returns false.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 525 of file qbytearray.h.

526 { return QBool(indexOf(c) != -1); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QBool

Definition: qglobal.h:2013

int indexOf(char c, int from=0) const

Returns the index position of the first occurrence of the character ch in the byte array...

Definition: qbytearray.cpp:2461

◆ contains() [2/3]

QBool QByteArray::contains ( const char * a ) const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns true if the byte array contains the string str; otherwise returns false.

Definition at line 575 of file qbytearray.h.

576 { return QBool(indexOf(c) != -1); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QBool

Definition: qglobal.h:2013

int indexOf(char c, int from=0) const

Returns the index position of the first occurrence of the character ch in the byte array...

Definition: qbytearray.cpp:2461

◆ contains() [3/3]

QBool QByteArray::contains ( const QByteArray & ba ) const

inline

Returns true if the byte array contains an occurrence of the byte array ba; otherwise returns false.

See also: indexOf(), count()

Definition at line 523 of file qbytearray.h.

524 { return QBool(indexOf(a) != -1); }

long ASN1_INTEGER_get ASN1_INTEGER * a

Definition: qsslsocket_openssl_symbols.cpp:104

QBool

Definition: qglobal.h:2013

Referenced by QFontDatabasePrivate::addQPF2File(), QXmlStreamWriterPrivate::checkIfASCIICompatibleCodec(), QDeclarativeListModelParser::compile(), QDeclarativeListModelParser::compileProperty(), QHttpNetworkReplyPrivate::parseHeader(), QNetworkAccessManagerPrivate::prepareMultipart(), QDeclarativeBindingCompiler::program(), q_fromPercentEncoding(), q_toPercentEncoding(), QHttpMultiPartPrivate::QHttpMultiPartPrivate(), QVariantToVARIANT(), QHttpMultiPartIODevice::readData(), QPlatformFontDatabase::registerQPF2Font(), QPatternist::HexBinary::stringValue(), and variantToString().

int indexOf(char c, int from=0) const

Returns the index position of the first occurrence of the character ch in the byte array...

Definition: qbytearray.cpp:2461

◆ count() [1/4]

int QByteArray::count ( char ch ) const

Returns the number of occurrences of character ch in the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: contains(), indexOf()

Definition at line 2654 of file qbytearray.cpp.

 {
     int num = 0;
     const char *i = d->data + d->size;
     const char *b = d->data;
     while (i != b)
         if (*--i == ch)
             ++num;
     return num;
 }

◆ count() [2/4]

int QByteArray::count ( const char * str ) const

Returns the number of (potentially overlapping) occurrences of string str in the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2637 of file qbytearray.cpp.

 {
     return count(fromRawData(str, qstrlen(str)));
 }

◆ count() [3/4]

int QByteArray::count ( const QByteArray & ba ) const

Returns the number of (potentially overlapping) occurrences of byte array ba in this byte array.

See also: contains(), indexOf()

Definition at line 2612 of file qbytearray.cpp.

 {
     int num = 0;
     int i = -1;
     if (d->size > 500 && ba.d->size > 5) {
         QByteArrayMatcher matcher(ba);
         while ((i = matcher.indexIn(*this, i + 1)) != -1)
             ++num;
     } else {
         while ((i = indexOf(ba, i + 1)) != -1)
             ++num;
     }
     return num;
 }

◆ count() [4/4]

int QByteArray::count ( ) const

inline

Same as size().

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 355 of file qbytearray.h.

Referenced by QDeclarativeComponentPrivate::beginCreate(), count(), and QDeclarativeComponent::QDeclarativeComponent().

355 { return d->size; }

Data * d

Definition: qbytearray.h:386

int size

Definition: qbytearray.h:140

◆ data() [1/2]

char * QByteArray::data ( )

inline

Returns a pointer to the data stored in the byte array.

The pointer can be used to access and modify the bytes that compose the array. The data is '\0'-terminated, i.e. the number of bytes in the returned character string is size() + 1 for the '\0' terminator.

Example:

QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
    cout << "[" << *data << "]" << endl;
    ++data;
}

The pointer remains valid as long as the byte array isn't reallocated or destroyed. For read-only access, constData() is faster because it never causes a deep copy to occur.

This function is mostly useful to pass a byte array to a function that accepts a const char *.

The following example makes a copy of the char* returned by data(), but it will corrupt the heap and cause a crash because it does not allocate a byte for the '\0' at the end:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()]
strcpy(data, text.data());
delete [] data; 

This one allocates the correct amount of space:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1]
strcpy(data, text.data());
delete [] data;

Note: A QByteArray can store any byte values including '\0's, but most functions that take char * arguments assume that the data ends at the first '\0' they encounter.

See also: constData(), operator[]()

Definition at line 429 of file qbytearray.h.

430 { detach(); return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

QByteArray::detach

void detach()

Definition: qbytearray.h:435

◆ data() [2/2]

const char * QByteArray::data ( ) const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 431 of file qbytearray.h.

432 { return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

◆ data_ptr()

DataPtr & QByteArray::data_ptr ( )

inline

Warning: This function is not part of the public interface.

Definition at line 397 of file qbytearray.h.

Referenced by QBitArray::data_ptr().

397 { return d; }

Data * d

Definition: qbytearray.h:386

◆ detach()

void QByteArray::detach ( )

inline

Warning: This function is not part of the public interface.

Definition at line 435 of file qbytearray.h.

Referenced by begin(), data(), QBitArray::detach(), end(), getData(), nulTerminated(), QByteRef::operator=(), remove(), replace(), and QMacPasteboard::retrieveData().

436 { if (d->ref != 1 || d->data != d->array) realloc(d->size); }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

QBasicAtomicInt ref

Definition: qbytearray.h:139

QByteArray::realloc

void realloc(int alloc)

Definition: qbytearray.cpp:1564

QByteArray::Data::array

char array[1]

Definition: qbytearray.h:145

int size

Definition: qbytearray.h:140

◆ end() [1/2]

QByteArray::iterator QByteArray::end ( )

inline

Warning: This function is not part of the public interface.

Definition at line 499 of file qbytearray.h.

Referenced by QConcatenable< QByteArray >::appendTo(), lastIndexOfHelper(), repeated(), split(), and trimmed().

500 { detach(); return d->data + d->size; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

QByteArray::detach

void detach()

Definition: qbytearray.h:435

int size

Definition: qbytearray.h:140

◆ end() [2/2]

QByteArray::const_iterator QByteArray::end ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 501 of file qbytearray.h.

502 { return d->data + d->size; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

Referenced by QFileSystemEngine::absoluteName(), MetaObjectGenerator::addProperty(), QScript::callQtMethod(), QCacheItem::canCompress(), QDeclarativeCompiler::compileAlias(), QDeclarativeListModelParser::compileProperty(), QScriptEnginePrivate::convertToNativeQObject(), convertTypes(), QScriptEnginePrivate::convertValue(), QScriptEnginePrivate::create(), MetaObjectGenerator::createPrototype(), QDeclarativePropertyPrivate::findSignalByName(), QHttpNetworkReplyPrivate::getChunkSize(), QDeclarativeCompiler::indexOfSignal(), QAxServerBase::Invoke(), QAxEventSink::Invoke(), QScriptEnginePrivate::jscValueToVariant(), QDeclarativeObjectMethodScriptClass::matchScore(), QAxMetaObject::paramType(), paramType(), qDBusParametersForMethod(), qDecodeDataUrl(), qErrnoWarning(), QTest::qSignalDumperCallback(), QAxServerBase::qt_metacall(), queuedConnectionTypes(), QVariantToVARIANT(), QDeclarativeXMLHttpRequest::readEncoding(), QHttpNetworkReplyPrivate::readHeader(), QHttpNetworkReplyPrivate::readStatus(), QMimeDataPrivate::retrieveTypedData(), QFtpDTP::socketReadyRead(), QProcessPrivate::startDetached(), QProcessPrivate::startProcess(), QUrlPrivate::toEncoded(), QNetworkCookie::toRawForm(), and QScript::variantFromValue().

int size

Definition: qbytearray.h:140

◆ endsWith() [1/3]

bool QByteArray::endsWith ( const QByteArray & ba ) const

Returns true if this byte array ends with byte array ba; otherwise returns false.

Example:

QByteArray url("http://qt.nokia.com/index.html");
if (url.endsWith(".html"))
    ...

See also: startsWith(), right()

Definition at line 2735 of file qbytearray.cpp.

 {
     if (d == ba.d || ba.d->size == 0)
         return true;
     if (d->size < ba.d->size)
         return false;
     return memcmp(d->data + d->size - ba.d->size, ba.d->data, ba.d->size) == 0;
 }

◆ endsWith() [2/3]

bool QByteArray::endsWith ( char ch ) const

Returns true if this byte array ends with character ch; otherwise returns false.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2770 of file qbytearray.cpp.

 {
     if (d->size == 0)
         return false;
     return d->data[d->size - 1] == ch;
 }

◆ endsWith() [3/3]

bool QByteArray::endsWith ( const char * str ) const

Returns true if this byte array ends with string str; otherwise returns false.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2752 of file qbytearray.cpp.

 {
     if (!str || !*str)
         return true;
     int len = qstrlen(str);
     if (d->size < len)
         return false;
     return qstrncmp(d->data + d->size - len, str, len) == 0;
 }

◆ expand()

void QByteArray::expand ( int i )

private

Definition at line 1587 of file qbytearray.cpp.

Referenced by QByteRef::operator=().

 {
     resize(qMax(i + 1, d->size));
 }

◆ fill()

QByteArray & QByteArray::fill	(	char	ch,
		int	size = `-1`
	)

Sets every byte in the byte array to character ch.

If size is different from -1 (the default), the byte array is resized to size size beforehand.

Example:

QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"
ba.fill('X', 2);
// ba == "XX"

See also: resize()

Definition at line 1556 of file qbytearray.cpp.

Referenced by dumpRecursive(), QByteArray(), QTest::qSignalDumperCallback(), QTest::qSignalDumperCallbackSlot(), and qStringFromUcs2Le().

 {
     resize(size < 0 ? d->size : size);
     if (d->size)
         memset(d->data, ch, d->size);
     return *this;
 }

◆ fromBase64()

QByteArray QByteArray::fromBase64 ( const QByteArray & base64 )

static

Returns a decoded copy of the Base64 array base64.

Input is not checked for validity; invalid characters in the input are skipped, enabling the decoding process to continue with subsequent characters.

For example:

QByteArray text = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh");

text.data(); // returns "Qt is great!"

The algorithm used to decode Base64-encoded data is defined in RFC 2045.

See also: toBase64()

Definition at line 4184 of file qbytearray.cpp.

Referenced by QDeclarativeEnginePrivate::atob(), QAuthenticatorPrivate::calculateResponse(), QSslCertificatePrivate::certificatesFromPem(), createImageNode(), QSslKeyPrivate::derFromPem(), and qDecodeDataUrl().

 {
     unsigned int buf = 0;
     int nbits = 0;
     QByteArray tmp((base64.size() * 3) / 4, Qt::Uninitialized);
 
     int offset = 0;
     for (int i = 0; i < base64.size(); ++i) {
     int ch = base64.at(i);
     int d;
 
     if (ch >= 'A' && ch <= 'Z')
         d = ch - 'A';
     else if (ch >= 'a' && ch <= 'z')
         d = ch - 'a' + 26;
     else if (ch >= '0' && ch <= '9')
         d = ch - '0' + 52;
     else if (ch == '+')
         d = 62;
     else if (ch == '/')
         d = 63;
     else
         d = -1;
 
     if (d != -1) {
         buf = (buf << 6) | d;
         nbits += 6;
         if (nbits >= 8) {
         nbits -= 8;
         tmp[offset++] = buf >> nbits;
         buf &= (1 << nbits) - 1;
         }
     }
     }
 
     tmp.truncate(offset);
     return tmp;
 }

◆ fromHex()

QByteArray QByteArray::fromHex ( const QByteArray & hexEncoded )

static

Returns a decoded copy of the hex encoded array hexEncoded.

Input is not checked for validity; invalid characters in the input are skipped, enabling the decoding process to continue with subsequent characters.

For example:

QByteArray text = QByteArray::fromHex("517420697320677265617421");

text.data(); // returns "Qt is great!"

See also: toHex()

Definition at line 4234 of file qbytearray.cpp.

 {
     QByteArray res((hexEncoded.size() + 1)/ 2, Qt::Uninitialized);
     uchar *result = (uchar *)res.data() + res.size();
 
     bool odd_digit = true;
     for (int i = hexEncoded.size() - 1; i >= 0; --i) {
         int ch = hexEncoded.at(i);
         int tmp;
         if (ch >= '0' && ch <= '9')
             tmp = ch - '0';
         else if (ch >= 'a' && ch <= 'f')
             tmp = ch - 'a' + 10;
         else if (ch >= 'A' && ch <= 'F')
             tmp = ch - 'A' + 10;
         else
             continue;
         if (odd_digit) {
             --result;
             *result = tmp;
             odd_digit = false;
         } else {
             *result |= tmp << 4;
             odd_digit = true;
         }
     }
 
     res.remove(0, result - (const uchar *)res.constData());
     return res;
 }

◆ fromPercentEncoding()

QByteArray QByteArray::fromPercentEncoding	(	const QByteArray &	input,
		char	percent = `'%'`
	)

static

Returns a decoded copy of the URI/URL-style percent-encoded input.

Since: 4.4

The percent parameter allows you to replace the '' character for another (for instance, '_' or '=').

For example:

QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");

text.data(); // returns "Qt is great!"

See also: toPercentEncoding(), QUrl::fromPercentEncoding()

Definition at line 4354 of file qbytearray.cpp.

Referenced by qDecodeDataUrl().

 {
     if (input.isNull())
         return QByteArray();       // preserve null
     if (input.isEmpty())
         return QByteArray(input.data(), 0);
 
     QByteArray tmp = input;
     q_fromPercentEncoding(&tmp, percent);
     return tmp;
 }

◆ fromRawData()

QByteArray QByteArray::fromRawData	(	const char *	data,
		int	size
	)

static

Constructs a QByteArray that uses the first size bytes of the data array.

The bytes are not copied. The QByteArray will contain the data pointer. The caller guarantees that data will not be deleted or modified as long as this QByteArray and any copies of it exist that have not been modified. In other words, because QByteArray is an implicitly shared class and the instance returned by this function contains the data pointer, the caller must not delete data or modify it directly as long as the returned QByteArray and any copies exist. However, QByteArray does not take ownership of data, so the QByteArray destructor will never delete the raw data, even when the last QByteArray referring to data is destroyed.

A subsequent attempt to modify the contents of the returned QByteArray or any copy made from it will cause it to create a deep copy of the data array before doing the modification. This ensures that the raw data array itself will never be modified by QByteArray.

Here is an example of how to read data using a QDataStream on raw data in memory without copying the raw data into a QByteArray:

 static const char mydata[] = {
    0x00, 0x00, 0x03, 0x84, 0x78, 0x9c, 0x3b, 0x76,
    0xec, 0x18, 0xc3, 0x31, 0x0a, 0xf1, 0xcc, 0x99,
    ...
    0x6d, 0x5b
};
QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
QDataStream in(&data, QIODevice::ReadOnly);
...

Warning: A byte array created with fromRawData() is not null-terminated, unless the raw data contains a 0 character at position size. While that does not matter for QDataStream or functions like indexOf(), passing the byte array to a function accepting a const char * expected to be '\0'-terminated will fail.

See also: setRawData(), data(), constData()

Definition at line 4121 of file qbytearray.cpp.

Referenced by QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QTiffHandler::canRead(), QSslCertificatePrivate::certificatesFromPem(), count(), QUrl::encodedQueryItemValue(), QTextStreamPrivate::fillReadBuffer(), QRasterPixmapData::fromData(), QVGPixmapData::fromData(), QPixmapData::fromData(), QGLPixmapData::fromData(), QImage::fromData(), getData(), QUrl::hasEncodedQueryItem(), ICOReader::iconAt(), QTextList::itemText(), QSvgIOHandlerPrivate::load(), QSslCertificatePrivate::QByteArray_from_X509(), QNonContiguousByteDeviceBufferImpl::QNonContiguousByteDeviceBufferImpl(), qt_socks5_set_host_address_and_port(), qt_socks5_set_host_name_and_port(), QXIMInputContext::QXIMInputContext(), read_xbm_body(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), replace(), QOstDevicePrivate::RunL(), QWSIMEvent::setData(), QWSIMInitEvent::setData(), QWSFontEvent::setData(), QWSIMResponseCommand::setData(), setRawData(), QBBButtonEventNotifier::updateButtonStates(), Maemo::IAPConfPrivate::valueToVariant(), and QSocks5SocketEngine::write().

 {
     Data *x = static_cast<Data *>(qMalloc(sizeof(Data)));
     Q_CHECK_PTR(x);
     if (data) {
         x->data = const_cast<char *>(data);
     } else {
         x->data = x->array;
         size = 0;
     }
     x->ref = 1;
     x->alloc = x->size = size;
     *x->array = '\0';
     return QByteArray(x, 0, 0);
 }

◆ indexOf() [1/4]

int QByteArray::indexOf	(	char	ch,
		int	from = `0`
	)		const

Returns the index position of the first occurrence of the character ch in the byte array, searching forward from index position from.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Returns -1 if ch could not be found.

Example:

QByteArray ba("ABCBA");
ba.indexOf("B");            // returns 1
ba.indexOf("B", 1);         // returns 1
ba.indexOf("B", 2);         // returns 3
ba.indexOf("X");            // returns -1

See also: lastIndexOf(), contains()

Definition at line 2461 of file qbytearray.cpp.

Referenced by addDefaultArguments(), QAxEventSink::addSignal(), QOpenGLPaintEngine::begin(), buildParameterNames(), QSslCertificatePrivate::certificatesFromPem(), QTextCodec::codecForHtml(), QDeclarativeCompiler::compileAlias(), contains(), QWindowsMimeHtml::convertFromMime(), QWindowsMimeHtml::convertToMime(), count(), QUrlPrivate::createErrorString(), QFileSystemEngine::currentPath(), QSslKeyPrivate::derFromPem(), QDeclarativeCompiler::evaluateEnum(), QGLTextureGlyphCache::fillTexture(), QDeclarativeImportsPrivate::find(), QDeclarativePropertyPrivate::findSignalByName(), findSlot(), fontFile(), for(), QNetworkHeadersPrivate::fromHttpDate(), QScript::functionConnect(), generateInterfaceXml(), QHttpNetworkReplyPrivate::getChunkSize(), indexOf(), init_plugins(), QAxServerBase::Invoke(), QAxServerBase::Load(), QHostInfo::localDomainName(), QTest::memberName(), QWindowsLocalCodec::mibEnum(), QJpUnicodeConv::newConverter(), QUrlPrivate::normalized(), QAudioInputPrivate::open(), QAudioOutputPrivate::open(), MetaObjectGenerator::paramList(), parseHttpOptionHeader(), QBBNavigatorEventNotifier::parsePPS(), QBBButtonEventNotifier::parsePPS(), QAxMetaObject::parsePrototype(), QHttpNetworkReplyPrivate::parseStatus(), QNetworkAccessHttpBackend::postRequest(), QDBusConnectionPrivate::prepareHook(), QApplicationPrivate::process_cmdline(), qDecodeDataUrl(), QMetaMethod_name(), qt_read_xpm_image_or_array(), QUrlPrivate::queryItem(), QXIMInputContext::QXIMInputContext(), read_xbm_body(), MetaObjectGenerator::readFuncsInfo(), QConfFileSettingsPrivate::readIniFile(), QDBusConnectionPrivate::relaySignal(), MetaObjectGenerator::replacePrototype(), MetaObjectGenerator::replaceType(), QUrlPrivate::setEncodedUrl(), setupDBusInterface(), setupLocaleMapper(), and split().

 {
     if (from < 0)
         from = qMax(from + d->size, 0);
     if (from < d->size) {
         const char *n = d->data + from - 1;
         const char *e = d->data + d->size;
         while (++n != e)
         if (*n == ch)
             return  n - d->data;
     }
     return -1;
 }

◆ indexOf() [2/4]

int QByteArray::indexOf	(	const char *	str,
		int	from = `0`
	)		const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns the index position of the first occurrence of the string str in the byte array, searching forward from index position from.

Returns -1 if str could not be found.

Definition at line 2430 of file qbytearray.cpp.

 {
     const int ol = qstrlen(c);
     if (ol == 1)
         return indexOf(*c, from);
     
     const int l = d->size;
     if (from > d->size || ol + from > l)
         return -1;
     if (ol == 0)
         return from;
 
     return qFindByteArray(d->data, d->size, from, c, ol);
 }

◆ indexOf() [3/4]

int QByteArray::indexOf	(	const QByteArray &	ba,
		int	from = `0`
	)		const

Returns the index position of the first occurrence of the byte array ba in this byte array, searching forward from index position from.

Returns -1 if ba could not be found.

Example:

QByteArray x("sticky question");
QByteArray y("sti");
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

See also: lastIndexOf(), contains(), count()

Definition at line 2388 of file qbytearray.cpp.

 {
     const int ol = ba.d->size;
     if (ol == 0)
         return from;
     if (ol == 1)
         return indexOf(*ba.d->data, from);
 
     const int l = d->size;
     if (from > d->size || ol + from > l)
         return -1;
 
     return qFindByteArray(d->data, d->size, from, ba.d->data, ol);
 }

◆ indexOf() [4/4]

int QByteArray::indexOf	(	const QString &	str,
		int	from = `0`
	)		const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns the index position of the first occurrence of the string str in the byte array, searching forward from index position from.

Returns -1 if str could not be found.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 1008 of file qstring.h.

1009 { return indexOf(s.toAscii(), from); }

int indexOf(char c, int from=0) const

Returns the index position of the first occurrence of the character ch in the byte array...

Definition: qbytearray.cpp:2461

◆ insert() [1/5]

QByteArray & QByteArray::insert	(	int	i,
		char	ch
	)

Inserts character ch at index position i in the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

If i is greater than size(), the array is first extended using resize().

Definition at line 1936 of file qbytearray.cpp.

Referenced by charString(), QCoreWlanEngine::connectToId(), QSettingsPrivate::iniEscapedString(), replace(), and write_pbm_image().

 {
     return qbytearray_insert(this, i, &ch, 1);
 }

◆ insert() [2/5]

QByteArray & QByteArray::insert	(	int	i,
		const char *	str
	)

Inserts the string str at position i in the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

If i is greater than size(), the array is first extended using resize().

Definition at line 1901 of file qbytearray.cpp.

 {
     return qbytearray_insert(this, i, str, qstrlen(str));
 }

◆ insert() [3/5]

QByteArray & QByteArray::insert	(	int	i,
		const char *	str,
		int	len
	)

Inserts len bytes of the string str at position i in the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since: 4.6

If i is greater than size(), the array is first extended using resize().

Definition at line 1920 of file qbytearray.cpp.

 {
     return qbytearray_insert(this, i, str, len);
 }

◆ insert() [4/5]

QByteArray & QByteArray::insert	(	int	i,
		const QByteArray &	ba
	)

Inserts the byte array ba at index position i and returns a reference to this byte array.

Example:

QByteArray ba("Meal");
ba.insert(1, QByteArray("ontr"));
// ba == "Montreal"

See also: append(), prepend(), replace(), remove()

Definition at line 1863 of file qbytearray.cpp.

 {
     QByteArray copy(ba);
     return qbytearray_insert(this, i, copy.d->data, copy.d->size);
 }

◆ insert() [5/5]

QByteArray & QByteArray::insert	(	int	i,
		const QString &	str
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Inserts the string str at index position i in the byte array.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If i is greater than size(), the array is first extended using resize().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 998 of file qstring.h.

999 { return insert(i, s.toAscii()); }

QByteArray::insert

QByteArray & insert(int i, char c)

Inserts character ch at index position i in the byte array.

Definition: qbytearray.cpp:1936

◆ isDetached()

bool QByteArray::isDetached ( ) const

inline

Warning: This function is not part of the public interface.

Definition at line 437 of file qbytearray.h.

Referenced by QBitArray::isDetached().

438 { return d->ref == 1; }

Data * d

Definition: qbytearray.h:386

QBasicAtomicInt ref

Definition: qbytearray.h:139

◆ isEmpty()

bool QByteArray::isEmpty ( ) const

inline

Returns true if the byte array has size 0; otherwise returns false.

Example:

QByteArray().isEmpty();         // returns true
QByteArray("").isEmpty();       // returns true
QByteArray("abc").isEmpty();    // returns false

See also: size()

Definition at line 421 of file qbytearray.h.

422 { return d->size == 0; }

Data * d

Definition: qbytearray.h:386

Referenced by digestMd5ResponseHelper(), QUrlPrivate::ensureEncodedParts(), QUrlPrivate::fragmentImpl(), fromPercentEncoding(), fromPercentEncodingHelper(), fromPercentEncodingMutable(), get_device_info(), QBitArray::isNull(), QUrlPrivate::mergePaths(), QJpUnicodeConv::newConverter(), nextField(), operator<<(), QNetworkHeadersPrivate::parseAndSetHeader(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QGLWindowSurface::QGLWindowSurface(), qt_aqua_guess_size(), qt_init(), replace(), QUrl::resolved(), QUrl::setEncodedFragment(), QUrl::setEncodedQuery(), QNetworkHeadersPrivate::setRawHeaderInternal(), toPercentEncoding(), QDBusMetaType::typeToSignature(), and QXmlSerializer::write().

int size

Definition: qbytearray.h:140

◆ isNull()

bool QByteArray::isNull ( ) const

Returns true if this byte array is null; otherwise returns false.

Example:

QByteArray().isNull();          // returns true
QByteArray("").isNull();        // returns false
QByteArray("abc").isNull();     // returns false

Qt makes a distinction between null byte arrays and empty byte arrays for historical reasons. For most applications, what matters is whether or not a byte array contains any data, and this can be determined using isEmpty().

See also: isEmpty()

Definition at line 3485 of file qbytearray.cpp.

3485 { return d == &shared_null; }

Data * d

Definition: qbytearray.h:386

QByteArray::shared_null

static Data shared_null

Definition: qbytearray.h:384

◆ isSharedWith()

bool QByteArray::isSharedWith ( const QByteArray & other ) const

inline

Warning: This function is not part of the public interface.

Definition at line 185 of file qbytearray.h.

185 { return d == other.d; }

Referenced by QZipWriterPrivate::addEntry(), QScript::callQtMethod(), QTextCodec::codecForHtml(), QDeclarativeCompiler::compileAlias(), convertTypes(), QScriptEnginePrivate::convertValue(), QDeclarativeObjectMethodScriptClass::enumType(), QDeclarativeCompiler::evaluateEnum(), QDeclarativeImportsPrivate::find(), QDeclarativePropertyPrivate::findSignalByName(), fontFile(), for(), QScript::functionConnect(), generateInterfaceXml(), QScript::indexOfMetaEnum(), QAxServerBase::Invoke(), QScriptEnginePrivate::jscValueToVariant(), QXIMInputContext::language(), leftJustified(), QAxServerBase::Load(), QTest::memberName(), QUrlPrivate::mergePaths(), QWindowsLocalCodec::mibEnum(), operator<<(), QBBNavigatorEventNotifier::parsePPS(), QNetworkAccessHttpBackend::postRequest(), QMetaObject::property(), QDeclarativeBoundSignalParameters::QDeclarativeBoundSignalParameters(), QHttpMultiPartPrivate::QHttpMultiPartPrivate(), QMetaMethod_name(), qt_init(), read_xpm_body(), rightJustified(), setupDBusInterface(), QScript::variantFromValue(), VARIANTToQVariant(), wrapDSC(), and write_pbm_image().

Data * d

Definition: qbytearray.h:386

◆ lastIndexOf() [1/4]

int QByteArray::lastIndexOf	(	char	ch,
		int	from = `-1`
	)		const

Returns the index position of the last occurrence of character ch in the byte array, searching backward from index position from.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

If from is -1 (the default), the search starts at the last (size() - 1) byte. Returns -1 if ch could not be found.

Example:

QByteArray ba("ABCBA");
ba.lastIndexOf("B");        // returns 3
ba.lastIndexOf("B", 3);     // returns 3
ba.lastIndexOf("B", 2);     // returns 1
ba.lastIndexOf("X");        // returns -1

See also: indexOf(), contains()

Definition at line 2589 of file qbytearray.cpp.

Referenced by addDefaultArguments(), QAxBase::asVariant(), cacheForNamespace(), QTextCodec::codecForHtml(), QDeclarativeObjectMethodScriptClass::enumType(), fontFile(), QUrl::fromPunycode(), QScript::indexOfMetaEnum(), lastIndexOf(), QUrlPrivate::mergePaths(), QMetaObject::newInstance(), QMetaObject::property(), QDeclarativeBoundSignalParameters::QDeclarativeBoundSignalParameters(), MetaObjectGenerator::readFuncsInfo(), QDeclarativeCompiler::rewriteBinding(), and VARIANTToQVariant().

 {
     if (from < 0)
         from += d->size;
     else if (from > d->size)
         from = d->size-1;
     if (from >= 0) {
         const char *b = d->data;
         const char *n = d->data + from + 1;
         while (n-- != b)
             if (*n == ch)
                 return  n - b;
     }
     return -1;
 }

◆ lastIndexOf() [2/4]

int QByteArray::lastIndexOf	(	const char *	str,
		int	from = `-1`
	)		const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns the index position of the last occurrence of the string str in the byte array, searching backward from index position from.

If from is -1 (the default), the search starts at the last (size() - 1) byte. Returns -1 if str could not be found.

Definition at line 2563 of file qbytearray.cpp.

 {
     const int ol = qstrlen(str);
     if (ol == 1)
         return lastIndexOf(*str, from);
 
     return lastIndexOfHelper(d->data, d->size, str, ol, from);
 }

◆ lastIndexOf() [3/4]

int QByteArray::lastIndexOf	(	const QByteArray &	ba,
		int	from = `-1`
	)		const

Returns the index position of the last occurrence of the byte array ba in this byte array, searching backward from index position from.

If from is -1 (the default), the search starts at the last byte. Returns -1 if ba could not be found.

Example:

QByteArray x("crazy azimuths");
QByteArray y("az");
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

See also: indexOf(), contains(), count()

Definition at line 2526 of file qbytearray.cpp.

 {
     const int ol = ba.d->size;
     if (ol == 1)
         return lastIndexOf(*ba.d->data, from);
 
     return lastIndexOfHelper(d->data, d->size, ba.d->data, ol, from);
 }

◆ lastIndexOf() [4/4]

int QByteArray::lastIndexOf	(	const QString &	str,
		int	from = `-1`
	)		const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Returns the index position of the last occurrence of the string str in the byte array, searching backward from index position from.

If from is -1 (the default), the search starts at the last (size() - 1) byte. Returns -1 if str could not be found.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 1010 of file qstring.h.

1011 { return lastIndexOf(s.toAscii(), from); }

QByteArray::lastIndexOf

int lastIndexOf(char c, int from=-1) const

Returns the index position of the last occurrence of character ch in the byte array, searching backward from index position from.

Definition: qbytearray.cpp:2589

◆ left()

QByteArray QByteArray::left ( int len ) const

Returns a byte array that contains the leftmost len bytes of this byte array.

The entire byte array is returned if len is greater than size().

Example:

QByteArray x("Pineapple");
QByteArray y = x.left(4);
// y == "Pine"

See also: right(), mid(), startsWith(), truncate()

Definition at line 2790 of file qbytearray.cpp.

 {
     if (len >= d->size)
         return *this;
     if (len < 0)
         len = 0;
     return QByteArray(d->data, len);
 }

◆ leftJustified()

QByteArray QByteArray::leftJustified	(	int	width,
		char	fill = `' '`,
		bool	truncate = `false`
	)		const

Returns a byte array of size width that contains this byte array padded by the fill character.

If truncate is false and the size() of the byte array is more than width, then the returned byte array is a copy of this byte array.

If truncate is true and the size() of the byte array is more than width, then any bytes in a copy of the byte array after position width are removed, and the copy is returned.

Example:

QByteArray x("apple");

QByteArray y = x.leftJustified(8, '.'); // y == "apple..."

See also: rightJustified()

Definition at line 3429 of file qbytearray.cpp.

Referenced by qEncodeHmacMd5(), and qFillBufferWithString().

 {
     QByteArray result;
     int len = d->size;
     int padlen = width - len;
     if (padlen > 0) {
         result.resize(len+padlen);
         if (len)
             memcpy(result.d->data, d->data, len);
         memset(result.d->data+len, fill, padlen);
     } else {
         if (truncate)
             result = left(width);
         else
             result = *this;
     }
     return result;
 }

◆ length()

int QByteArray::length ( ) const

inline

Same as size().

Definition at line 356 of file qbytearray.h.

Referenced by _q_dupEnvironment(), QFileSystemEngine::absoluteName(), QAxClientSite::activateObject(), QPdfEnginePrivate::addBrushPattern(), QCryptographicHash::addData(), addDefaultArguments(), QZipWriterPrivate::addEntry(), QDBusMarshaller::append(), cacheForNamespace(), QTextCodec::canEncode(), QUrlPrivate::canonicalHost(), charString(), QPatternist::XsdTypeChecker::checkConstrainingFacetsBinary(), checkStaticArray(), QZipWriter::close(), QDeclarativeListModelParser::compileProperty(), QMetaObject::connectSlotsByName(), convertFlags(), QWindowsMimeHtml::convertFromMime(), QAbstractConcatenable::convertToAscii(), convertTypes(), MetaObjectGenerator::createPrototype(), QAuthenticatorPrivate::digestMd5Response(), QAxBase::dynamicCallHelper(), QPdfEnginePrivate::embedFont(), QDB2Result::exec(), QSymSQLResult::exec(), QODBCResult::exec(), QWSSoundServerPrivate::feedDevice(), QNetworkAccessHttpBackend::fetchCacheMetaData(), QDeclarativePropertyPrivate::findSignalByName(), findSlot(), fromPercentEncodingHelper(), fromPercentEncodingMutable(), QUuid::fromRfc4122(), QTextEncoder::fromUnicode(), getNetWmState(), QScript::QObjectDelegate::getOwnPropertyDescriptor(), QScript::QObjectDelegate::getOwnPropertySlot(), QWSPropertyManager::getProperty(), QFontEngineMac::getSfntTable(), QXmlStreamWriterPrivate::indent(), QDeclarativeCompiler::indexOfSignal(), QSettingsPrivate::iniEscapedKey(), QTestFileLogger::init(), QMetaMethod::invoke(), QAxServerBase::Invoke(), QDeclarativeCompiler::isSignalPropertyName(), QLibraryPrivate::load_sys(), MetaObjectGenerator::metaObject(), QJpUnicodeConv::newConverter(), QMetaObject::newInstance(), nextField(), nextNonWhitespace(), QUrlPrivate::normalized(), normalizeTypeInternal(), QIBaseDriver::open(), QTextStream::operator<<(), MetaObjectGenerator::paramList(), paramType(), parseDateString(), QAuthenticatorPrivate::parseDigestAuthenticationChallenge(), parseHttpOptionHeader(), QDBusMetaObjectGenerator::parseMethods(), QAxMetaObject::parsePrototype(), QSocks5SocketEnginePrivate::parseRequestMethodReply(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QDBusMetaObjectGenerator::parseSignals(), QHttpNetworkReplyPrivate::parseStatus(), QPdf::patternForBrush(), QSslSocketPrivate::peek(), QApplicationPrivate::process_cmdline(), QCoreApplicationPrivate::processCommandLineArguments(), q_toPercentEncoding(), QByteArrayMatcher::QByteArrayMatcher(), qDBusParametersForMethod(), qEncodeHmacMd5(), qExtractSecurityPolicyFromString(), qFillBufferWithString(), qstrcmp(), qstring_to_xtp(), qStringFromUcs2Le(), qt_socks5_set_host_name_and_port(), QUuid::QUuid(), QVariantToVARIANT(), qvsnprintf(), QRingBuffer< T >::read(), read_xpm_body(), QHttpNetworkReplyPrivate::readHeader(), QConfFileSettingsPrivate::readIniFile(), QConfFileSettingsPrivate::readIniLine(), QHttpNetworkReplyPrivate::readStatus(), QMYSQLResult::reset(), runlengthEncode(), QZipReaderPrivate::scanFiles(), QTcpServerConnection::send(), QmlOstPlugin::send(), QWSSoundServerClient::sendClientMessage(), QWSServerPrivate::sendFontRemovedEvent(), QUrlPrivate::setEncodedUrl(), QWidgetPrivate::setWindowRole(), QXcbWindow::setWindowTitle(), QXlibWindow::setWindowTitle(), sm_setProperty(), QFontEngineXLFD::stringToCMap(), QString::toStdString(), QTest::toString(), QTextCodec::toUnicode(), QTextDecoder::toUnicode(), QMYSQLResult::virtual_hook(), wrapDSC(), QDBusMetaObjectGenerator::write(), write_pbm_image(), QPdfEnginePrivate::writeCompressed(), QPdfEnginePrivate::writeImage(), and QPdfEnginePrivate::~QPdfEnginePrivate().

356 { return d->size; }

Data * d

Definition: qbytearray.h:386

Referenced by addDefaultArguments(), RequestAnalyzer::analyze(), QAxBase::asVariant(), QAuthDevice::authorizeMessage(), QOpenGLPaintEngine::begin(), cacheForNamespace(), QTextCodec::codecForHtml(), QDeclarativeListModelParser::compileProperty(), QWindowsMimeHtml::convertToMime(), QScriptEnginePrivate::convertToNativeQObject(), QSslKeyPrivate::derFromPem(), QDeclarativeObjectMethodScriptClass::enumType(), QDeclarativeImportsPrivate::find(), QDeclarativePropertyPrivate::findSignalByName(), fontFile(), QHttpNetworkReplyPrivate::getChunkSize(), QScript::indexOfMetaEnum(), QDeclarativeCompiler::indexOfSignal(), QSettingsPrivate::iniUnescapedKey(), QAxServerBase::Invoke(), QTextList::itemText(), QHostInfo::localDomainName(), QJpUnicodeConv::newConverter(), nextField(), QAudioInputPrivate::open(), QAudioOutputPrivate::open(), MetaObjectGenerator::paramList(), parseDateString(), QHttpNetworkReplyPrivate::parseHeader(), QAuthenticatorPrivate::parseHttpResponse(), QBBNavigatorEventNotifier::parsePPS(), QBBButtonEventNotifier::parsePPS(), QAxMetaObject::parsePrototype(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QHttpNetworkReplyPrivate::parseStatus(), QNetworkAccessHttpBackend::postRequest(), QMetaObject::property(), QDeclarativeBoundSignalParameters::QDeclarativeBoundSignalParameters(), qDecodeDataUrl(), qNtlmDecodePhase2(), qt_init(), read_xpm_body(), QAuthDevice::readData(), QConfFileSettingsPrivate::readIniFile(), QAuthDevice::recvReadyRead(), QDeclarativeCompiler::rewriteBinding(), setupLocaleMapper(), split(), QSettingsPrivate::stringToVariant(), toType(), wrapDSC(), and QCoreApplicationData::~QCoreApplicationData().

int size

Definition: qbytearray.h:140

◆ mid()

QByteArray QByteArray::mid	(	int	pos,
		int	len = `-1`
	)		const

Returns a byte array containing len bytes from this byte array, starting at position pos.

If len is -1 (the default), or pos + len >= size(), returns a byte array containing all bytes starting at position pos until the end of the byte array.

Example:

QByteArray x("Five pineapples");
QByteArray y = x.mid(5, 4);     // y == "pine"
QByteArray z = x.mid(5);        // z == "pineapples"

See also: left(), right()

Definition at line 2835 of file qbytearray.cpp.

 {
     if (d == &shared_null || d == &shared_empty || pos >= d->size)
         return QByteArray();
     if (len < 0)
         len = d->size - pos;
     if (pos < 0) {
         len += pos;
         pos = 0;
     }
     if (len + pos > d->size)
         len = d->size - pos;
     if (pos == 0 && len == d->size)
         return *this;
     return QByteArray(d->data + pos, len);
 }

◆ nulTerminated()

QByteArray QByteArray::nulTerminated ( ) const

private

Return a QByteArray that is sure to be NUL-terminated.

Warning: This function is not part of the public interface.

By default, all QByteArray have an extra NUL at the end, guaranteeing that assumption. However, if QByteArray::fromRawData is used, then the NUL is there only if the user put it there. We can't be sure.

Definition at line 1604 of file qbytearray.cpp.

Referenced by toDouble(), toLongLong(), toPercentEncoding(), and toULongLong().

 {
     // is this fromRawData?
     if (d->data == d->array)
         return *this;           // no, then we're sure we're zero terminated
 
     QByteArray copy(*this);
     copy.detach();
     return copy;
 }

◆ number() [1/5]

QByteArray QByteArray::number	(	int	n,
		int	base = `10`
	)

static

Returns a byte array containing the string equivalent of the number n to base base (10 by default).

The base can be any value between 2 and 36.

Example:

int n = 63;
QByteArray::number(n);              // returns "63"
QByteArray::number(n, 16);          // returns "3f"
QByteArray::number(n, 16).toUpper();  // returns "3F"

Note: The format of the number is not localized; the default C locale is used irrespective of the user's locale.

See also: setNum(), toInt()

Definition at line 4004 of file qbytearray.cpp.

Referenced by QXmlTestLogger::addBenchmarkResult(), QTestLogger::addBenchmarkResult(), QDeclarativeCompiler::buildDynamicMeta(), classIDL(), QTextCodec::codecForMib(), convert(), QDeclarativeOpenMetaObjectType::createProperty(), QAuthenticatorPrivate::digestMd5Response(), QDeclarativeCompiledData::dump(), QDeclarativeCompiler::dumpStats(), QPSPrintEnginePrivate::flushPage(), QGLPixmapConvolutionFilter::generateConvolutionShader(), MetaObjectGenerator::guessTypes(), QHttpNetworkRequestPrivate::header(), QSettingsPrivate::iniEscapedString(), QFontDatabase::loadXlfd(), operator<<(), QNetworkAccessHttpBackend::postRequest(), QHttpNetworkConnectionPrivate::prepareRequest(), QFontEngine::properties(), prototype(), QAuthenticatorPrivate::QAuthenticatorPrivate(), qax_generateDocumentation(), qax_readClassInfo(), QHttpMultiPartPrivate::QHttpMultiPartPrivate(), QTest::qSignalDumperCallback(), QTest::qSignalDumperCallbackSlot(), QWSLock::QWSLock(), MetaObjectGenerator::readClassInfo(), MetaObjectGenerator::readEnumInfo(), MetaObjectGenerator::readEventInfo(), MetaObjectGenerator::readInterfaceInfo(), QBBSystemLocaleData::readPpsValue(), renameOverloads(), QSslCertificate::serialNumber(), QHttpNetworkHeaderPrivate::setContentLength(), QTimeLinePrivate::setCurrentTime(), QAxEventSink::signalHasReceivers(), QHttpSocketEngine::slotSocketConnected(), QTest::toString(), QFontSubset::toType1(), QFontSubset::type1AddedGlyphs(), QNetworkDiskCachePrivate::uniqueFileName(), QSslCertificate::version(), write_pbm_image(), and QWSLock::~QWSLock().

 {
     QByteArray s;
     s.setNum(n, base);
     return s;
 }

◆ number() [2/5]

QByteArray QByteArray::number	(	uint	n,
		int	base = `10`
	)

static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toUInt()

Definition at line 4016 of file qbytearray.cpp.

 {
     QByteArray s;
     s.setNum(n, base);
     return s;
 }

◆ number() [3/5]

QByteArray QByteArray::number	(	qlonglong	n,
		int	base = `10`
	)

static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toLongLong()

Definition at line 4028 of file qbytearray.cpp.

 {
     QByteArray s;
     s.setNum(n, base);
     return s;
 }

◆ number() [4/5]

QByteArray QByteArray::number	(	qulonglong	n,
		int	base = `10`
	)

static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toULongLong()

Definition at line 4040 of file qbytearray.cpp.

 {
     QByteArray s;
     s.setNum(n, base);
     return s;
 }

◆ number() [5/5]

QByteArray QByteArray::number	(	double	n,
		char	f = `'g'`,
		int	prec = `6`
	)

static

Returns a byte array that contains the printed value of n, formatted in format f with precision prec.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Argument n is formatted according to the f format specified, which is g by default, and can be any of the following:

Format	Meaning
`e`	format as [-]9.9e[+\|-]999
`E`	format as [-]9.9E[+\|-]999
`f`	format as [-]9.9
`g`	use `e` or `f` format, whichever is the most concise
`G`	use `E` or `f` format, whichever is the most concise

With 'e', 'E', and 'f', prec is the number of digits after the decimal point. With 'g' and 'G', prec is the maximum number of significant digits (trailing zeroes are omitted).

QByteArray ba = QByteArray::number(12.3456, 'E', 3);

// ba == 1.235E+01

Note: The format of the number is not localized; the default C locale is used irrespective of the user's locale.

See also: toDouble()

Definition at line 4079 of file qbytearray.cpp.

 {
     QByteArray s;
     s.setNum(n, f, prec);
     return s;
 }

◆ operator const char *()

QByteArray::operator const char * ( ) const

inline

Definition at line 424 of file qbytearray.h.

425 { return d->data; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

◆ operator QNoImplicitBoolCast()

QByteArray::operator QNoImplicitBoolCast ( ) const

private

◆ operator!=()

bool QByteArray::operator!= ( const QString & str ) const

inline

Returns true if this byte array is not equal to string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 983 of file qstring.h.

984 { return !qStringComparisonHelper(s, constData()); }

qStringComparisonHelper

bool qStringComparisonHelper(const QString &s1, const char *s2)

Definition: qstring.h:916

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

◆ operator+=() [1/4]

QByteArray & QByteArray::operator+= ( char ch )

inline

Appends the character ch onto the end of this byte array and returns a reference to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 505 of file qbytearray.h.

506 { return append(c); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

◆ operator+=() [2/4]

QByteArray & QByteArray::operator+= ( const char * s )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Appends the string str onto the end of this byte array and returns a reference to this byte array.

Definition at line 507 of file qbytearray.h.

508 { return append(s); }

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

◆ operator+=() [3/4]

QByteArray & QByteArray::operator+= ( const QByteArray & ba )

inline

Appends the byte array ba onto the end of this byte array and returns a reference to this byte array.

Example:

QByteArray x("free");
QByteArray y("dom");
x += y;
// x == "freedom"

Note: QByteArray is an implicitly shared class. Consequently, if this is an empty QByteArray, then this will just share the data held in ba. In this case, no copying of data is done, taking constant time. If a shared instance is modified, it will be copied (copy-on-write), taking linear time.

If this is not an empty QByteArray, a deep copy of the data is performed, taking linear time.

This operation typically does not suffer from allocation overhead, because QByteArray preallocates extra space at the end of the data so that it may grow without reallocating for each append operation.

See also: append(), prepend()

Definition at line 509 of file qbytearray.h.

510 { return append(a); }

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

long ASN1_INTEGER_get ASN1_INTEGER * a

Definition: qsslsocket_openssl_symbols.cpp:104

◆ operator+=() [4/4]

QByteArray & QByteArray::operator+= ( const QString & str )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Appends the string str onto the end of this byte array and returns a reference to this byte array.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this operator can lead to loss of information. You can disable this operator by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 1006 of file qstring.h.

1007 { return operator+=(s.toAscii()); }

QByteArray::operator+=

QByteArray & operator+=(char c)

Appends the character ch onto the end of this byte array and returns a reference to this byte array...

Definition: qbytearray.h:505

◆ operator<()

bool QByteArray::operator< ( const QString & str ) const

inline

Returns true if this byte array is lexically less than string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 985 of file qstring.h.

986 { return QString::fromAscii(constData(), size()) < s; }

static QString fromAscii(const char *, int size=-1)

Returns a QString initialized with the first size characters from the string str. ...

Definition: qstring.cpp:4276

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator<=()

bool QByteArray::operator<= ( const QString & str ) const

inline

Returns true if this byte array is lexically less than or equal to string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 989 of file qstring.h.

990 { return QString::fromAscii(constData(), size()) <= s; }

static QString fromAscii(const char *, int size=-1)

Returns a QString initialized with the first size characters from the string str. ...

Definition: qstring.cpp:4276

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator=() [1/2]

QByteArray & QByteArray::operator= ( const QByteArray & other )

Assigns other to this byte array and returns a reference to this byte array.

Definition at line 935 of file qbytearray.cpp.

 {
     other.d->ref.ref();
     if (!d->ref.deref())
         qFree(d);
     d = other.d;
     return *this;
 }

◆ operator=() [2/2]

QByteArray & QByteArray::operator= ( const char * str )

Assigns str to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 954 of file qbytearray.cpp.

 {
     Data *x;
     if (!str) {
         x = &shared_null;
     } else if (!*str) {
         x = &shared_empty;
     } else {
         int len = qstrlen(str);
         if (d->ref != 1 || len > d->alloc || (len < d->size && len < d->alloc >> 1))
             realloc(len);
         x = d;
         memcpy(x->data, str, len + 1); // include null terminator
         x->size = len;
     }
     x->ref.ref();
     if (!d->ref.deref())
          qFree(d);
     d = x;
     return *this;
 }

◆ operator==()

bool QByteArray::operator== ( const QString & str ) const

inline

Returns true if this byte array is equal to string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 981 of file qstring.h.

982 { return qStringComparisonHelper(s, constData()); }

qStringComparisonHelper

bool qStringComparisonHelper(const QString &s1, const char *s2)

Definition: qstring.h:916

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

◆ operator>()

bool QByteArray::operator> ( const QString & str ) const

inline

Returns true if this byte array is lexically greater than string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 987 of file qstring.h.

988 { return QString::fromAscii(constData(), size()) > s; }

static QString fromAscii(const char *, int size=-1)

Returns a QString initialized with the first size characters from the string str. ...

Definition: qstring.cpp:4276

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator>=()

bool QByteArray::operator>= ( const QString & str ) const

inline

Returns true if this byte array is greater than or equal to string str; otherwise returns false.

The Unicode data is converted into 8-bit characters using QString::toAscii().

The comparison is case sensitive.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications. You then need to call QString::fromAscii(), QString::fromLatin1(), QString::fromUtf8(), or QString::fromLocal8Bit() explicitly if you want to convert the byte array to a QString before doing the comparison.

Definition at line 991 of file qstring.h.

992 { return QString::fromAscii(constData(), size()) >= s; }

static QString fromAscii(const char *, int size=-1)

Returns a QString initialized with the first size characters from the string str. ...

Definition: qstring.cpp:4276

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator[]() [1/4]

char QByteArray::operator[] ( int i ) const

inline

Same as at(i).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 415 of file qbytearray.h.

Referenced by size().

416 { Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

#define Q_ASSERT(cond)

Definition: qglobal.h:1823

unsigned int uint

Definition: qglobal.h:996

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator[]() [2/4]

char QByteArray::operator[] ( uint i ) const

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 417 of file qbytearray.h.

418 { Q_ASSERT(i < uint(size())); return d->data[i]; }

char * data

Definition: qbytearray.h:144

Data * d

Definition: qbytearray.h:386

#define Q_ASSERT(cond)

Definition: qglobal.h:1823

unsigned int uint

Definition: qglobal.h:996

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator[]() [3/4]

QByteRef QByteArray::operator[] ( int i )

inline

Returns the byte at index position i as a modifiable reference.

If an assignment is made beyond the end of the byte array, the array is extended with resize() before the assignment takes place.

Example:

QByteArray ba;
for (int i = 0; i < 10; ++i)
    ba[i] = 'A' + i;
// ba == "ABCDEFGHIJ"

The return value is of type QByteRef, a helper class for QByteArray. When you get an object of type QByteRef, you can use it as if it were a char &. If you assign to it, the assignment will apply to the character in the QByteArray from which you got the reference.

See also: at()

Definition at line 489 of file qbytearray.h.

490 { Q_ASSERT(i >= 0); return QByteRef(*this, i); }

QByteArray::QByteRef

friend class QByteRef

Definition: qbytearray.h:392

#define Q_ASSERT(cond)

Definition: qglobal.h:1823

◆ operator[]() [4/4]

QByteRef QByteArray::operator[] ( uint i )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 491 of file qbytearray.h.

492 { return QByteRef(*this, i); }

QByteArray::QByteRef

friend class QByteRef

Definition: qbytearray.h:392

◆ prepend() [1/4]

QByteArray & QByteArray::prepend ( char ch )

Prepends the character ch to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1694 of file qbytearray.cpp.

Referenced by QUrlPrivate::canonicalHost(), QCoreWlanEngine::connectToId(), QAuthenticatorPrivate::digestMd5Response(), QSettingsPrivate::iniEscapedKey(), normalizeTypeInternal(), prepend(), push_front(), qDecodeDataUrl(), qDetectCPUFeatures(), QXIMInputContext::QXIMInputContext(), QDeclarativeBindingCompilerPrivate::registerString(), QDBusAbstractAdaptor::setAutoRelaySignals(), and WinMain().

 {
     if (d->ref != 1 || d->size + 1 > d->alloc)
         realloc(qAllocMore(d->size + 1, sizeof(Data)));
     memmove(d->data+1, d->data, d->size);
     d->data[0] = ch;
     ++d->size;
     d->data[d->size] = '\0';
     return *this;
 }

◆ prepend() [2/4]

QByteArray & QByteArray::prepend ( const char * str )

Prepends the string str to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1657 of file qbytearray.cpp.

 {
     return prepend(str, qstrlen(str));
 }

◆ prepend() [3/4]

QByteArray & QByteArray::prepend	(	const char *	str,
		int	len
	)

Prepends len bytes of the string str to this byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since: 4.6

Definition at line 1672 of file qbytearray.cpp.

 {
     if (str) {
         if (d->ref != 1 || d->size + len > d->alloc)
             realloc(qAllocMore(d->size + len, sizeof(Data)));
         memmove(d->data+len, d->data, d->size);
         memcpy(d->data, str, len);
         d->size += len;
         d->data[d->size] = '\0';
     }
     return *this;
 }

◆ prepend() [4/4]

QByteArray & QByteArray::prepend ( const QByteArray & ba )

Prepends the byte array ba to this byte array and returns a reference to this byte array.

Example:

QByteArray x("ship");
QByteArray y("air");
x.prepend(y);
// x == "airship"

This is the same as insert(0, ba).

Note: QByteArray is an implicitly shared class. Consequently, if this is an empty QByteArray, then this will just share the data held in ba. In this case, no copying of data is done, taking constant time. If a shared instance is modified, it will be copied (copy-on-write), taking linear time.

If this is not an empty QByteArray, a deep copy of the data is performed, taking linear time.

See also: append(), insert()

Definition at line 1636 of file qbytearray.cpp.

 {
     if ((d == &shared_null || d == &shared_empty) && !IS_RAW_DATA(ba.d)) {
         *this = ba;
     } else if (ba.d != &shared_null) {
         QByteArray tmp = *this;
         *this = ba;
         append(tmp);
     }
     return *this;
 }

◆ push_back() [1/3]

void QByteArray::push_back ( char ch )

inline

Same as append(ch).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 511 of file qbytearray.h.

512 { append(c); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

◆ push_back() [2/3]

void QByteArray::push_back ( const char * c )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Same as append(str).

Definition at line 513 of file qbytearray.h.

514 { append(c); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

◆ push_back() [3/3]

void QByteArray::push_back ( const QByteArray & other )

inline

This function is provided for STL compatibility.

It is equivalent to append(other).

Definition at line 515 of file qbytearray.h.

516 { append(a); }

QByteArray & append(char c)

Appends the character ch to this byte array.

Definition: qbytearray.cpp:1817

long ASN1_INTEGER_get ASN1_INTEGER * a

Definition: qsslsocket_openssl_symbols.cpp:104

◆ push_front() [1/3]

void QByteArray::push_front ( char ch )

inline

Same as prepend(ch).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 517 of file qbytearray.h.

518 { prepend(c); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray::prepend

QByteArray & prepend(char c)

Prepends the character ch to this byte array.

Definition: qbytearray.cpp:1694

◆ push_front() [2/3]

void QByteArray::push_front ( const char * c )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Same as prepend(str).

Definition at line 519 of file qbytearray.h.

520 { prepend(c); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray::prepend

QByteArray & prepend(char c)

Prepends the character ch to this byte array.

Definition: qbytearray.cpp:1694

◆ push_front() [3/3]

void QByteArray::push_front ( const QByteArray & other )

inline

This function is provided for STL compatibility.

It is equivalent to prepend(other).

Definition at line 521 of file qbytearray.h.

522 { prepend(a); }

Referenced by QFileSystemEngine::currentPath(), fromHex(), QFreetypeFace::getFace(), QHttpNetworkReplyPrivate::gunzipBodyPartially(), QX11Data::motifdndObtainData(), QMetaObject::newInstance(), normalizeTypeInternal(), QSocks5SocketEnginePrivate::parseRequestMethodReply(), qDecodeDataUrl(), QFtpDTP::read(), read_xpm_string(), QStateMachinePrivate::registerSignalTransition(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), and QWindowsPipeWriter::run().

long ASN1_INTEGER_get ASN1_INTEGER * a

Definition: qsslsocket_openssl_symbols.cpp:104

QByteArray::prepend

QByteArray & prepend(char c)

Prepends the character ch to this byte array.

Definition: qbytearray.cpp:1694

◆ realloc()

void QByteArray::realloc ( int alloc )

private

Definition at line 1564 of file qbytearray.cpp.

Referenced by append(), detach(), operator=(), prepend(), reserve(), and squeeze().

 {
     if (d->ref != 1 || d->data != d->array) {
         Data *x = static_cast<Data *>(qMalloc(sizeof(Data) + alloc));
         Q_CHECK_PTR(x);
         x->size = qMin(alloc, d->size);
         ::memcpy(x->array, d->data, x->size);
         x->array[x->size] = '\0';
         x->ref = 1;
         x->alloc = alloc;
         x->data = x->array;
         if (!d->ref.deref())
             qFree(d);
         d = x;
     } else {
         Data *x = static_cast<Data *>(qRealloc(d, sizeof(Data) + alloc));
         Q_CHECK_PTR(x);
         x->alloc = alloc;
         x->data = x->array;
         d = x;
     }
 }

◆ remove()

QByteArray & QByteArray::remove	(	int	pos,
		int	len
	)

Removes len bytes from the array, starting at index position pos, and returns a reference to the array.

If pos is out of range, nothing happens. If pos is valid, but pos + len is larger than the size of the array, the array is truncated at position pos.

Example:

QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"

See also: insert(), replace()

Definition at line 1955 of file qbytearray.cpp.

 {
     if (len <= 0  || pos >= d->size || pos < 0)
         return *this;
     detach();
     if (pos + len >= d->size) {
         resize(pos);
     } else {
         memmove(d->data + pos, d->data + pos + len, d->size - pos - len);
         resize(d->size - len);
     }
     return *this;
 }

◆ repeated()

QByteArray QByteArray::repeated ( int times ) const

Returns a copy of this byte array repeated the specified number of times.

Since: 4.5

If times is less than 1, an empty byte array is returned.

Example:

QByteArray ba("ab");

ba.repeated(4); // returns "abababab"

Definition at line 2337 of file qbytearray.cpp.

 {
     if (d->size == 0)
         return *this;
 
     if (times <= 1) {
         if (times == 1)
             return *this;
         return QByteArray();
     }
 
     const int resultSize = times * d->size;
 
     QByteArray result;
     result.reserve(resultSize);
     if (result.d->alloc != resultSize)
         return QByteArray(); // not enough memory
 
     memcpy(result.d->data, d->data, d->size);
 
     int sizeSoFar = d->size;
     char *end = result.d->data + sizeSoFar;
 
     const int halfResultSize = resultSize >> 1;
     while (sizeSoFar <= halfResultSize) {
         memcpy(end, result.d->data, sizeSoFar);
         end += sizeSoFar;
         sizeSoFar <<= 1;
     }
     memcpy(end, result.d->data, resultSize - sizeSoFar);
     result.d->data[resultSize] = '\0';
     result.d->size = resultSize;
     return result;
 }

◆ replace() [1/14]

QByteArray & QByteArray::replace	(	int	pos,
		int	len,
		const char *	after
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces len bytes from index position pos with the zero terminated string after.

Notice: this can change the length of the byte array.

Definition at line 2002 of file qbytearray.cpp.

Referenced by addDefaultArguments(), QAxEventSink::addSignal(), QWindowsMimeHtml::convertToMime(), QFontEngine::convertToPostscriptFontFamilyName(), MetaObjectGenerator::guessTypes(), QLibraryPrivate::isPlugin(), MetaObjectGenerator::readFuncsInfo(), replace(), MetaObjectGenerator::replacePrototype(), MetaObjectGenerator::replaceType(), QUrlPrivate::setEncodedUrl(), QNetworkCookie::toRawForm(), and QFontSubset::toType1().

 {
     return replace(pos,len,after,qstrlen(after));
 }

◆ replace() [2/14]

QByteArray & QByteArray::replace	(	int	pos,
		int	len,
		const char *	after,
		int	alen
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces len bytes from index position pos with alen bytes from the string after.

after is allowed to have '\0' characters.

Since: 4.7

Definition at line 2016 of file qbytearray.cpp.

 {
     if (len == alen && (pos + len <= d->size)) {
         detach();
         memcpy(d->data + pos, after, len*sizeof(char));
         return *this;
     } else {
         remove(pos, len);
         return qbytearray_insert(this, pos, after, alen);
     }
 }

◆ replace() [3/14]

QByteArray & QByteArray::replace	(	int	pos,
		int	len,
		const QByteArray &	after
	)

Replaces len bytes from index position pos with the byte array after, and returns a reference to this byte array.

Example:

QByteArray x("Say yes!");
QByteArray y("no");
x.replace(4, 3, y);
// x == "Say no!"

See also: insert(), remove()

Definition at line 1979 of file qbytearray.cpp.

 {
     if (len == after.d->size && (pos + len <= d->size)) {
         detach();
         memmove(d->data + pos, after.d->data, len*sizeof(char));
         return *this;
     } else {
         QByteArray copy(after);
         // ### optimize me
         remove(pos, len);
         return insert(pos, copy);
     }
 }

◆ replace() [4/14]

QByteArray & QByteArray::replace	(	char	before,
		const char *	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the character before with the string after.

Definition at line 577 of file qbytearray.h.

578 { return replace(&before, 1, c, qstrlen(c)); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QByteArray::qstrlen

uint qstrlen(const char *str)

Definition: qbytearray.h:79

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ replace() [5/14]

QByteArray & QByteArray::replace	(	char	before,
		const QByteArray &	after
	)

Replaces every occurrence of the character before with the byte array after.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2247 of file qbytearray.cpp.

 {
     char b[2] = { before, '\0' };
     QByteArray cb = fromRawData(b, 1);
     return replace(cb, after);
 }

◆ replace() [6/14]

QByteArray & QByteArray::replace	(	const char *	before,
		const char *	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the string before with the string after.

Definition at line 581 of file qbytearray.h.

582 { return replace(before, qstrlen(before), after, qstrlen(after)); }

QByteArray::qstrlen

uint qstrlen(const char *str)

Definition: qbytearray.h:79

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ replace() [7/14]

QByteArray & QByteArray::replace	(	const char *	before,
		int	bsize,
		const char *	after,
		int	asize
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the string before with the string after.

Since the sizes of the strings are given by bsize and asize, they may contain zero characters and do not need to be zero-terminated.

Definition at line 2082 of file qbytearray.cpp.

 {
     if (isNull() || (before == after && bsize == asize))
         return *this;
 
     // protect against before or after being part of this
     const char *a = after;
     const char *b = before;
     if (after >= d->data && after < d->data + d->size) {
         char *copy = (char *)malloc(asize);
         Q_CHECK_PTR(copy);
         memcpy(copy, after, asize);
         a = copy;
     }
     if (before >= d->data && before < d->data + d->size) {
         char *copy = (char *)malloc(bsize);
         Q_CHECK_PTR(copy);
         memcpy(copy, before, bsize);
         b = copy;
     }
     
     QByteArrayMatcher matcher(before, bsize);
     int index = 0;
     int len = d->size;
     char *d = data();
 
     if (bsize == asize) {
         if (bsize) {
             while ((index = matcher.indexIn(*this, index)) != -1) {
                 memcpy(d + index, after, asize);
                 index += bsize;
             }
         }
     } else if (asize < bsize) {
         uint to = 0;
         uint movestart = 0;
         uint num = 0;
         while ((index = matcher.indexIn(*this, index)) != -1) {
             if (num) {
                 int msize = index - movestart;
                 if (msize > 0) {
                     memmove(d + to, d + movestart, msize);
                     to += msize;
                 }
             } else {
                 to = index;
             }
             if (asize) {
                 memcpy(d + to, after, asize);
                 to += asize;
             }
             index += bsize;
             movestart = index;
             num++;
         }
         if (num) {
             int msize = len - movestart;
             if (msize > 0)
                 memmove(d + to, d + movestart, msize);
             resize(len - num*(bsize-asize));
         }
     } else {
         // the most complex case. We don't want to lose performance by doing repeated
         // copies and reallocs of the string.
         while (index != -1) {
             uint indices[4096];
             uint pos = 0;
             while(pos < 4095) {
                 index = matcher.indexIn(*this, index);
                 if (index == -1)
                     break;
                 indices[pos++] = index;
                 index += bsize;
                 // avoid infinite loop
                 if (!bsize)
                     index++;
             }
             if (!pos)
                 break;
 
             // we have a table of replacement positions, use them for fast replacing
             int adjust = pos*(asize-bsize);
             // index has to be adjusted in case we get back into the loop above.
             if (index != -1)
                 index += adjust;
             int newlen = len + adjust;
             int moveend = len;
             if (newlen > len) {
                 resize(newlen);
                 len = newlen;
             }
             d = this->d->data;
 
             while(pos) {
                 pos--;
                 int movestart = indices[pos] + bsize;
                 int insertstart = indices[pos] + pos*(asize-bsize);
                 int moveto = insertstart + asize;
                 memmove(d + moveto, d + movestart, (moveend - movestart));
                 if (asize)
                     memcpy(d + insertstart, after, asize);
                 moveend = movestart - bsize;
             }
         }
     }
 
     if (a != after)
         ::free((char *)a);
     if (b != before)
         ::free((char *)b);
     
     
     return *this;
 }

◆ replace() [8/14]

QByteArray & QByteArray::replace	(	const QByteArray &	before,
		const QByteArray &	after
	)

Replaces every occurrence of the byte array before with the byte array after.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Example:

QByteArray ba("colour behaviour flavour neighbour");
ba.replace(QByteArray("ou"), QByteArray("o"));
// ba == "color behavior flavor neighbor"

Definition at line 2044 of file qbytearray.cpp.

 {
     if (isNull() || before.d == after.d)
         return *this;
 
     QByteArray aft = after;
     if (after.d == d)
         aft.detach();
     
     return replace(before.constData(), before.size(), aft.constData(), aft.size());
 }

◆ replace() [9/14]

QByteArray & QByteArray::replace	(	const QByteArray &	before,
		const char *	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the byte array before with the string after.

Definition at line 579 of file qbytearray.h.

580 { return replace(before.constData(), before.size(), c, qstrlen(c)); }

unsigned char c[8]

Definition: qnumeric_p.h:62

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

QByteArray::qstrlen

uint qstrlen(const char *str)

Definition: qbytearray.h:79

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ replace() [10/14]

QByteArray & QByteArray::replace	(	const char *	before,
		const QByteArray &	after
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the string before with the byte array after.

Definition at line 2064 of file qbytearray.cpp.

 {
     QByteArray aft = after;
     if (after.d == d)
         aft.detach();
     
     return replace(c, qstrlen(c), aft.constData(), aft.size());
 }

◆ replace() [11/14]

QByteArray & QByteArray::replace	(	char	before,
		char	after
	)

Replaces every occurrence of the character before with the character after.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2288 of file qbytearray.cpp.

 {
     if (d->size) {
         char *i = data();
         char *e = i + d->size;
         for (; i != e; ++i)
             if (*i == before)
                 * i = after;
     }
     return *this;
 }

◆ replace() [12/14]

QByteArray & QByteArray::replace	(	const QString &	before,
		const char *	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the string before with the string after.

Definition at line 1002 of file qstring.h.

1003 { return replace(before.toAscii(), after); }

QString::toAscii

QByteArray toAscii() const Q_REQUIRED_RESULT

Returns an 8-bit representation of the string as a QByteArray.

Definition: qstring.cpp:4014

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ replace() [13/14]

QByteArray & QByteArray::replace	(	char	before,
		const QString &	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the character before with the string after.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 1000 of file qstring.h.

1001 { return replace(c, after.toAscii()); }

unsigned char c[8]

Definition: qnumeric_p.h:62

QString::toAscii

QByteArray toAscii() const Q_REQUIRED_RESULT

Returns an 8-bit representation of the string as a QByteArray.

Definition: qstring.cpp:4014

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ replace() [14/14]

QByteArray & QByteArray::replace	(	const QString &	before,
		const QByteArray &	after
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Replaces every occurrence of the string before with the byte array after.

The Unicode data is converted into 8-bit characters using QString::toAscii().

If the QString contains non-ASCII Unicode characters, using this function can lead to loss of information. You can disable this function by defining QT_NO_CAST_TO_ASCII when you compile your applications. You then need to call QString::toAscii() (or QString::toLatin1() or QString::toUtf8() or QString::toLocal8Bit()) explicitly if you want to convert the data to const char *.

Definition at line 1004 of file qstring.h.

1005 { return replace(before.toAscii(), after); }

QString::toAscii

QByteArray toAscii() const Q_REQUIRED_RESULT

Returns an 8-bit representation of the string as a QByteArray.

Definition: qstring.cpp:4014

Referenced by _q_dupEnvironment(), QOCIResultPrivate::bindValue(), QUrlPrivate::canonicalHost(), QObject::connect(), QObject::disconnect(), QHttpNetworkRequestPrivate::header(), QSettingsPrivate::iniEscapedKey(), QSettingsPrivate::iniEscapedString(), QMetaMethod::invoke(), MetaObjectGenerator::metaObject(), nextField(), QUrlPrivate::normalized(), QMetaObject::normalizedSignature(), normalizeTypeInternal(), QIBaseDriver::open(), operator+=(), operator<<(), parseHttpOptionHeader(), QSslSocketPrivate::peek(), QNetworkAccessManagerPrivate::prepareMultipart(), QHttpNetworkReplyPrivate::readHeader(), QNetworkAccessFileBackend::readMoreFromFile(), QHttpNetworkReplyPrivate::readStatus(), repeated(), QSocks5SocketEnginePrivate::sendRequestMethod(), QSslCertificate::serialNumber(), QDBusPendingCallPrivate::setMetaTypes(), QLocalePrivate::validateChars(), QDBusMetaObjectGenerator::write(), and QSocks5SocketEngine::writeDatagram().

QByteArray & replace(int index, int len, const char *s)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.cpp:2002

◆ reserve()

void QByteArray::reserve ( int size )

inline

Attempts to allocate memory for at least size bytes.

If you know in advance how large the byte array will be, you can call this function, and if you call resize() often you are likely to get better performance. If size is an underestimate, the worst that will happen is that the QByteArray will be a bit slower.

The sole purpose of this function is to provide a means of fine tuning QByteArray's memory usage. In general, you will rarely ever need to call this function. If you want to change the size of the byte array, call resize().

See also: squeeze(), capacity()

Definition at line 449 of file qbytearray.h.

450 { if (d->ref != 1 || asize > d->alloc) realloc(asize); }

QByteArray::Data::alloc

int alloc

Definition: qbytearray.h:140

Data * d

Definition: qbytearray.h:386

QBasicAtomicInt ref

Definition: qbytearray.h:139

QByteArray::realloc

void realloc(int alloc)

Definition: qbytearray.cpp:1564

◆ resize()

void QByteArray::resize ( int size )

Sets the size of the byte array to size bytes.

If size is greater than the current size, the byte array is extended to make it size bytes with the extra bytes added to the end. The new bytes are uninitialized.

If size is less than the current size, bytes are removed from the end.

See also: size(), truncate()

Definition at line 1508 of file qbytearray.cpp.

 {
     if (size <= 0) {
         Data *x = &shared_empty;
         x->ref.ref();
         if (!d->ref.deref())
             qFree(d);
         d = x;
     } else if (d == &shared_null) {
         //
         // Optimize the idiom:
         //    QByteArray a;
         //    a.resize(sz);
         //    ...
         // which is used in place of the Qt 3 idiom:
         //    QByteArray a(sz);
         //
         Data *x = static_cast<Data *>(qMalloc(sizeof(Data)+size));
         Q_CHECK_PTR(x);
         x->ref = 1;
         x->alloc = x->size = size;
         x->data = x->array;
         x->array[size] = '\0';
         (void) d->ref.deref(); // cannot be 0, x points to shared_null
         d = x;
     } else {
         if (d->ref != 1 || size > d->alloc || (size < d->size && size < d->alloc >> 1))
             realloc(qAllocMore(size, sizeof(Data)));
         if (d->alloc >= size) {
             d->size = size;
             if (d->data == d->array) {
                 d->array[size] = '\0';
             }
         }
     }
 }

◆ right()

QByteArray QByteArray::right ( int len ) const

Returns a byte array that contains the rightmost len bytes of this byte array.

The entire byte array is returned if len is greater than size().

Example:

QByteArray x("Pineapple");
QByteArray y = x.right(5);
// y == "apple"

See also: endsWith(), left(), mid()

Definition at line 2812 of file qbytearray.cpp.

Referenced by clientChallenge(), QApplicationPrivate::process_cmdline(), and QCoreApplicationPrivate::processCommandLineArguments().

 {
     if (len >= d->size)
         return *this;
     if (len < 0)
         len = 0;
     return QByteArray(d->data + d->size - len, len);
 }

◆ rightJustified()

QByteArray QByteArray::rightJustified	(	int	width,
		char	fill = `' '`,
		bool	truncate = `false`
	)		const

Returns a byte array of size width that contains the fill character followed by this byte array.

If truncate is false and the size of the byte array is more than width, then the returned byte array is a copy of this byte array.

If truncate is true and the size of the byte array is more than width, then the resulting byte array is truncated at position width.

Example:

QByteArray x("apple");

QByteArray y = x.rightJustified(8, '.'); // y == "...apple"

See also: leftJustified()

Definition at line 3466 of file qbytearray.cpp.

Referenced by classIDL(), and QSslCertificate::serialNumber().

 {
     QByteArray result;
     int len = d->size;
     int padlen = width - len;
     if (padlen > 0) {
         result.resize(len+padlen);
         if (len)
             memcpy(result.d->data+padlen, data(), len);
         memset(result.d->data, fill, padlen);
     } else {
         if (truncate)
             result = left(width);
         else
             result = *this;
     }
     return result;
 }

◆ setNum() [1/8]

QByteArray & QByteArray::setNum	(	short	n,
		int	base = `10`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toShort()

Definition at line 584 of file qbytearray.h.

Referenced by QPdfEnginePrivate::drawTextItem(), number(), and setNum().

585 { return setNum(qlonglong(n), base); }

static const uint base

Definition: qurl.cpp:268

QByteArray & setNum(short, int base=10)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.h:584

qlonglong

qint64 qlonglong

Definition: qglobal.h:951

◆ setNum() [2/8]

QByteArray & QByteArray::setNum	(	ushort	n,
		int	base = `10`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toUShort()

Definition at line 586 of file qbytearray.h.

587 { return setNum(qulonglong(n), base); }

static const uint base

Definition: qurl.cpp:268

QByteArray & setNum(short, int base=10)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.h:584

qulonglong

quint64 qulonglong

Definition: qglobal.h:952

◆ setNum() [3/8]

QByteArray & QByteArray::setNum	(	int	n,
		int	base = `10`
	)

inline

Sets the byte array to the printed value of n in base base (10 by default) and returns a reference to the byte array.

The base can be any value between 2 and 36.

Example:

QByteArray ba;
int n = 63;
ba.setNum(n);           // ba == "63"
ba.setNum(n, 16);       // ba == "3f"

Note: The format of the number is not localized; the default C locale is used irrespective of the user's locale.

See also: number(), toInt()

Definition at line 588 of file qbytearray.h.

589 { return setNum(qlonglong(n), base); }

static const uint base

Definition: qurl.cpp:268

QByteArray & setNum(short, int base=10)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.h:584

qlonglong

qint64 qlonglong

Definition: qglobal.h:951

◆ setNum() [4/8]

QByteArray & QByteArray::setNum	(	uint	n,
		int	base = `10`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toUInt()

Definition at line 590 of file qbytearray.h.

591 { return setNum(qulonglong(n), base); }

static const uint base

Definition: qurl.cpp:268

QByteArray & setNum(short, int base=10)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.h:584

qulonglong

quint64 qulonglong

Definition: qglobal.h:952

◆ setNum() [5/8]

QByteArray & QByteArray::setNum	(	qlonglong	n,
		int	base = `10`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toLongLong()

Definition at line 3880 of file qbytearray.cpp.

 {
 #if defined(QT_CHECK_RANGE)
     if (base < 2 || base > 36) {
         qWarning("QByteArray::setNum: Invalid base %d", base);
         base = 10;
     }
 #endif
     QLocale locale(QLocale::C);
     *this = locale.d()->longLongToString(n, -1, base).toLatin1();
     return *this;
 }

◆ setNum() [6/8]

QByteArray & QByteArray::setNum	(	qulonglong	n,
		int	base = `10`
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

See also: toULongLong()

Definition at line 3899 of file qbytearray.cpp.

 {
 #if defined(QT_CHECK_RANGE)
     if (base < 2 || base > 36) {
         qWarning("QByteArray::setNum: Invalid base %d", base);
         base = 10;
     }
 #endif
     QLocale locale(QLocale::C);
     *this = locale.d()->unsLongLongToString(n, -1, base).toLatin1();
     return *this;
 }

◆ setNum() [7/8]

QByteArray & QByteArray::setNum	(	float	n,
		char	f = `'g'`,
		int	prec = `6`
	)

inline

Sets the byte array to the printed value of n, formatted in format f with precision prec, and returns a reference to the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Note: The format of the number is not localized; the default C locale is used irrespective of the user's locale.

See also: toFloat()

Definition at line 592 of file qbytearray.h.

593 { return setNum(double(n),f,prec); }

Referenced by QSocks5SocketEnginePrivate::_q_controlSocketReadNotification(), QHttpPrivate::_q_slotConnected(), QHttpPrivate::_q_slotReadyRead(), QFtpPrivate::_q_startNextCommand(), QSocks5SocketEnginePrivate::_q_udpSocketReadNotification(), QZipWriterPrivate::addEntry(), QBasicUnixFontDatabase::addTTFile(), QFontDatabasePrivate::addTTFile(), QByteDataBuffer::append(), QString::append(), QHttpNetworkReplyPrivate::appendCompressedReplyData(), QNetworkReplyImplPrivate::appendDownstreamData(), QConcatenable< QByteArray >::appendTo(), Maemo::appendVariantToDBusMessage(), QApplicationPrivate::applyX11SpecificCommandLineArguments(), QPdf::ascii85Encode(), at(), QAuthDevice::authorizeMessage(), QPatternist::Base64Binary::base64Decode(), QSocks5PasswordAuthenticator::beginAuthenticate(), bindFont(), QOCIResultPrivate::bindValue(), QDeclarativeCompiler::buildDynamicMeta(), QDeclarativeBindingCompilerPrivate::buildExceptionData(), buildParameterNames(), buildString(), QFtpDTP::bytesAvailable(), QHttpNetworkReplyPrivate::bytesAvailable(), QScript::callQtMethod(), QTextCodec::canEncode(), QSslCertificatePrivate::certificatesFromDer(), QSslCertificatePrivate::certificatesFromPem(), QPicturePrivate::checkFormat(), checksum(), childKeysOrGroups(), QRingBuffer< T >::chop(), clientChallenge(), QXlibClipboard::clipboardReadIncrementalProperty(), QX11Data::clipboardReadIncrementalProperty(), QXlibClipboard::clipboardReadProperty(), QX11Data::clipboardReadProperty(), QTextCodec::codecForUtfText(), QUnixSocket::connect(), convertFlags(), QWindowsMimeText::convertFromMime(), QMacPasteboardMimeHTMLText::convertFromMime(), QMacPasteboardMimeTiff::convertFromMime(), QWindowsMimeHtml::convertFromMime(), QSimpleTextCodec::convertFromUnicode(), QIconvCodec::convertFromUnicode(), QWindowsLocalCodec::convertFromUnicode(), QAbstractConcatenable::convertToAscii(), QMacPasteboardMimePlainText::convertToMime(), QMacPasteboardMimeUnicodeText::convertToMime(), QWindowsMimeText::convertToMime(), QMacPasteboardMimeTiff::convertToMime(), QScriptEnginePrivate::convertToNativeQObject(), QIconvCodec::convertToUnicode(), QScriptEnginePrivate::convertValue(), QBitArray::count(), create_wm_client_leader(), QSslKeyPrivate::decodePem(), QSslKeyPrivate::derFromPem(), QIcdEngine::doRequestUpdate(), QPainterPrivate::draw_helper(), QPSPrintEnginePrivate::drawImageHelper(), QPdfEnginePrivate::embedFont(), QClipboardWatcher::empty(), QDB2Result::exec(), QSQLiteResult::exec(), QODBCResult::exec(), QOCICols::execBatch(), QHttpNetworkConnectionChannel::expand(), QFontEngineMac::faceId(), QZipReader::fileData(), QBitArray::fill(), QFileSystemEngine::fillMetaData(), QTextStreamPrivate::flushWriteBuffer(), QXlibClipboardMime::formats_sys(), QDB2Driver::formatValue(), QSqlDriver::formatValue(), QTDSDriver::formatValue(), QMYSQLDriver::formatValue(), QODBCDriver::formatValue(), QRingBuffer< T >::free(), fromBase64(), QImage::fromData(), QDirectFBPixmapData::fromFile(), QGLPixmapData::fromFile(), fromHex(), QUrl::fromPunycode(), QXmlInputSource::fromRawData(), fromRawData(), generateGlyphTables(), QDeclarativeCompiler::genObject(), QXmlStreamReaderPrivate::getChar_helper(), QHttpNetworkReplyPrivate::getChunkSize(), QXlibClipboard::getDataInFormat(), QClipboardWatcher::getDataInFormat(), QFreetypeFace::getFace(), getFullPath(), QFontEngine::glyphCount(), QHttpNetworkReplyPrivate::gunzipBodyPartially(), QHttpNetworkReplyPrivate::gzipCheckHeader(), QXlibKeyboard::handleKeyEvent(), QXlibClipboard::handleSelectionRequest(), QNonContiguousByteDeviceThreadForwardImpl::haveDataSlot(), QHttpNetworkRequestPrivate::header(), ICOReader::iconAt(), QByteArrayMatcher::indexIn(), indexOf(), QRingBuffer< T >::indexOf(), QSettingsPrivate::iniEscapedString(), QTestLiteStaticInfoPrivate::initializeSupportedAtoms(), QDeclarativeJS::integerFromString(), QScript::integerFromString(), QScriptEnginePrivate::jscValueToVariant(), QUnixSocketServer::listen(), QSvgIOHandlerPrivate::load(), QAxScriptManager::load(), QAxServerBase::Load(), QPixmap::loadFromData(), QImage::loadFromData(), QFontEngine::loadKerningPairs(), macQueryInternal(), macValue(), matchLineFeed(), QXlibMime::mimeConvertToFormat(), QXlibMime::mimeDataForAtom(), QRingBuffer< T >::nextDataBlockSize(), normalizeTypeInternal(), QIBaseDriver::open(), operator+(), operator+=(), QString::operator+=(), QString::operator<(), operator<<(), operator<<(), QString::operator<=(), operator=(), QString::operator=(), operator==(), QString::operator>(), QString::operator>=(), operator[](), QBitArray::operator^=(), QBitArray::operator|=(), QBitArray::operator~(), QDeclarativeCompiledData::pack(), QSocks5SocketEnginePrivate::parseRequestMethodReply(), QBufferPrivate::peek(), QIODevicePrivate::peek(), QRingBuffer< T >::peek(), QSslKeyPrivate::pemFromDer(), QByteDataBuffer::prepend(), QString::prepend(), QDeclarativeBindingCompiler::program(), QMacPasteboard::promiseKeeper(), QFtp::put(), QTextStreamPrivate::putString(), QBitArray::QBitArray(), QByteArray(), QSslCertificatePrivate::QByteArray_from_X509(), qbytearray_insert(), QByteArrayMatcher::QByteArrayMatcher(), QClipboardINCRTransaction::QClipboardINCRTransaction(), qCompress(), qCreatev2Hash(), qEncodeHmacMd5(), qEncodeNtlmBuffer(), qEncodeNtlmv2Response(), QFontEngineQPF::QFontEngineQPF(), qGetBinaryData(), qHash(), qMetaTypeCustomType_unlocked(), qNtlmDecodePhase2(), qStreamNtlmBuffer(), qStringFromUcs2Le(), qt_create_commandline(), qt_error_string(), qt_fill_input_buffer(), qt_get_net_supported(), qt_get_net_virtual_roots(), qt_inflateGZipDataFrom(), qt_mac_execute_apple_script(), qt_parse_pattern(), qt_read_xpm_image_or_array(), qt_socks5_get_host_address_and_port(), qt_x11_apply_settings_in_all_apps(), queryFont(), QUrlPrivate::queryItem(), qUncompress(), QFtpDTP::read(), QByteDataBuffer::read(), QIODevice::read(), QRingBuffer< T >::read(), read_xpm_body(), read_xpm_string(), QFtpDTP::readAll(), QIODevice::readAll(), QAuthDevice::readData(), QSocks5SocketEngine::readDatagram(), QConfFileSettingsPrivate::readIniFile(), QWinSettingsPrivate::readKey(), QIODevice::readLine(), QOCICols::readPiecewise(), QHttpNetworkReplyPrivate::readReplyBodyRaw(), QHttpNetworkReplyPrivate::readStatus(), QPacketProtocolPrivate::readyToRead(), QAuthDevice::recvReadyRead(), registerFont(), QPlatformFontDatabase::registerQPF2Font(), releaseFontData(), removeDotsFromPath(), replace(), QBBNavigatorEventNotifier::replyPPS(), QRingBuffer< T >::reserve(), QBitArray::resize(), resize(), resolveGdi32(), QWidget::restoreGeometry(), QMainWindowLayoutState::restoreState(), QInternalMimeData::retrieveData(), QKqueueFileSystemWatcherEngine::run(), QDeclarativeVME::run(), QWindowsPipeWriter::run(), runlengthEncode(), QAxServerBase::Save(), QPacketProtocol::send(), send_selection(), QWSServerPrivate::sendQCopEvent(), QXlibClipboard::sendSelection(), QWinSettingsPrivate::set(), set_text(), QDeclarativeParser::Object::setBindingBit(), setData(), QWSRegionCommand::setData(), QUrlPrivate::setEncodedUrl(), QWSFontCommand::setFontName(), QWSQCopSendCommand::setMessage(), QBBClipboard::setMimeData(), QByteArrayMatcher::setPattern(), QWSDirectPainterSurface::setPermanentState(), QWSDisplay::setProperty(), setRawData(), QProcess::setReadChannel(), QWSIMResponseCommand::setResult(), QBitArray::size(), QNonContiguousByteDeviceByteArrayImpl::size(), QConcatenable< QByteArray >::size(), QByteDataBuffer::sizeNextBlock(), QFtpDTP::socketReadyRead(), standardLibraryErrorString(), QFontEngineMac::stringToCMap(), QRawFont::supportedWritingSystems(), toBase64(), toInt(), QSslKey::toPem(), QXlibKeyboard::translateKeySym(), QXcbKeyboard::translateKeySym(), translateKeySym(), truncate(), QIntValidator::validate(), QScript::variantFromValue(), VARIANTToQVariant(), QSettingsPrivate::variantToString(), Maemo::IAPConfPrivate::variantToValue(), QMYSQLResult::virtual_hook(), QIODevice::write(), QPdfEnginePrivate::write(), QRfbRawEncoder::write(), QXmlStreamWriterPrivate::write(), QUnixSocketPrivate::writeActivated(), QIBaseResultPrivate::writeBlob(), QPAGenerator::writeBlock(), QPFGenerator::writeBlock(), QPdfEnginePrivate::writeCompressed(), QUdpSocket::writeDatagram(), QSocks5SocketEngine::writeDatagram(), QPAGenerator::writeGMap(), QPFGenerator::writeGMap(), QClipboardINCRTransaction::x11Event(), QX11Data::xdndHandleSelectionRequest(), QX11Data::xdndMimeConvertToFormat(), QX11Data::xdndMimeDataForAtom(), and xdndObtainData().

QByteArray & setNum(short, int base=10)

This is an overloaded member function, provided for convenience. It differs from the above function o...

Definition: qbytearray.h:584

◆ setNum() [8/8]

QByteArray & QByteArray::setNum	(	double	n,
		char	f = `'g'`,
		int	prec = `6`
	)

Sets the byte array to the printed value of n, formatted in format f with precision prec, and returns a reference to the byte array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The format f can be any of the following:

Format	Meaning
`e`	format as [-]9.9e[+\|-]999
`E`	format as [-]9.9E[+\|-]999
`f`	format as [-]9.9
`g`	use `e` or `f` format, whichever is the most concise
`G`	use `E` or `f` format, whichever is the most concise

With 'e', 'E', and 'f', prec is the number of digits after the decimal point. With 'g' and 'G', prec is the maximum number of significant digits (trailing zeroes are omitted).

Note: The format of the number is not localized; the default C locale is used irrespective of the user's locale.

See also: toDouble()

Definition at line 3943 of file qbytearray.cpp.

 {
     QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
     uint flags = 0;
 
     if (qIsUpper(f))
         flags = QLocalePrivate::CapitalEorX;
     f = qToLower(f);
 
     switch (f) {
         case 'f':
             form = QLocalePrivate::DFDecimal;
             break;
         case 'e':
             form = QLocalePrivate::DFExponent;
             break;
         case 'g':
             form = QLocalePrivate::DFSignificantDigits;
             break;
         default:
 #if defined(QT_CHECK_RANGE)
             qWarning("QByteArray::setNum: Invalid format char '%c'", f);
 #endif
             break;
     }
 
     QLocale locale(QLocale::C);
     *this = locale.d()->doubleToString(n, prec, form, -1, flags).toLatin1();
     return *this;
 }

◆ setRawData()

QByteArray & QByteArray::setRawData	(	const char *	data,
		uint	size
	)

Resets the QByteArray to use the first size bytes of the data array.

Since: 4.7

The bytes are not copied. The QByteArray will contain the data pointer. The caller guarantees that data will not be deleted or modified as long as this QByteArray and any copies of it exist that have not been modified.

This function can be used instead of fromRawData() to re-use existings QByteArray objects to save memory re-allocations.

See also: fromRawData(), data(), constData()

Definition at line 4154 of file qbytearray.cpp.

 {
     if (d->ref != 1 || d->alloc) {
         *this = fromRawData(data, size);
     } else {
         if (data) {
             d->data = const_cast<char *>(data);
         } else {
             d->data = d->array;
             size = 0;
         }
         d->alloc = d->size = size;
         *d->array = '\0';
     }
     return *this;
 }

◆ simplified()

QByteArray QByteArray::simplified ( ) const

Returns a byte array that has whitespace removed from the start and the end, and which has each sequence of internal whitespace replaced with a single space.

Whitespace means any character for which the standard C++ isspace() function returns true. This includes the ASCII characters '\t', '\n', '\v', '\f', '\r', and ' '.

Example:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.simplified();
// ba == "lots of whitespace";

See also: trimmed()

Definition at line 3348 of file qbytearray.cpp.

Referenced by read_xpm_body(), and wrapDSC().

 {
     if (d->size == 0)
         return *this;
     QByteArray result(d->size, Qt::Uninitialized);
     const char *from = d->data;
     const char *fromend = from + d->size;
     int outc=0;
     char *to = result.d->data;
     for (;;) {
         while (from!=fromend && isspace(uchar(*from)))
             from++;
         while (from!=fromend && !isspace(uchar(*from)))
             to[outc++] = *from++;
         if (from!=fromend)
             to[outc++] = ' ';
         else
             break;
     }
     if (outc > 0 && to[outc-1] == ' ')
         outc--;
     result.resize(outc);
     return result;
 }

◆ size()

int QByteArray::size ( ) const

inline

Returns the number of bytes in this byte array.

The last byte in the byte array is at position size() - 1. In addition, QByteArray ensures that the byte at position size() is always '\0', so that you can use the return value of data() and constData() as arguments to functions that expect '\0'-terminated strings. If the QByteArray object was created from a raw data that didn't include the trailing null-termination character then QByteArray doesn't add it automaticall unless the deep copy is created.

Example:

QByteArray ba("Hello");
int n = ba.size();          // n == 5
ba.data()[0];               // returns 'H'
ba.data()[4];               // returns 'o'
ba.data()[5];               // returns '\0'

See also: isEmpty(), resize()

Definition at line 402 of file qbytearray.h.

403 { return d->size; }

Data * d

Definition: qbytearray.h:386

Referenced by QGLXContext::getProcAddress(), QEgl::hasExtension(), QAxServerBase::Invoke(), QXlibMime::mimeDataForAtom(), MetaObjectGenerator::paramList(), parseCookieHeader(), QNetworkCookie::parseCookies(), QAuthenticatorPrivate::parseDigestAuthenticationChallenge(), QBBNavigatorEventNotifier::parsePPS(), QBBButtonEventNotifier::parsePPS(), QAxMetaObject::parsePrototype(), QDeclarativeDomProperty::propertyNameParts(), q_hasEglExtension(), QGLXContext::QGLXContext(), qt_init(), QXIMInputContext::QXIMInputContext(), read_xpm_body(), QMimeDataPrivate::retrieveTypedData(), WinMain(), and QX11Data::xdndMimeDataForAtom().

int size

Definition: qbytearray.h:140

◆ split()

QList< QByteArray > QByteArray::split ( char sep ) const

Splits the byte array into subarrays wherever sep occurs, and returns the list of those arrays.

If sep does not match anywhere in the byte array, split() returns a single-element list containing this byte array.

Definition at line 2307 of file qbytearray.cpp.

 {
     QList<QByteArray> list;
     int start = 0;
     int end;
     while ((end = indexOf(sep, start)) != -1) {
         list.append(mid(start, end - start));
         start = end + 1;
     }
     list.append(mid(start));
     return list;
 }

◆ squeeze()

void QByteArray::squeeze ( )

inline

Releases any memory not required to store the array's data.

The sole purpose of this function is to provide a means of fine tuning QByteArray's memory usage. In general, you will rarely ever need to call this function.

See also: reserve(), capacity()

Definition at line 452 of file qbytearray.h.

453 { if (d->size < d->alloc) realloc(d->size); }

QByteArray::Data::alloc

int alloc

Definition: qbytearray.h:140

Data * d

Definition: qbytearray.h:386

QByteArray::realloc

void realloc(int alloc)

Definition: qbytearray.cpp:1564

Referenced by QFileSystemEngine::absoluteName(), QCoreApplication::arguments(), QHttpNetworkReplyPrivate::authenticationMethod(), cacheForNamespace(), QCacheItem::canCompress(), QUrlPrivate::canonicalHost(), QSvgIOHandler::canRead(), QNetworkAccessHttpBackend::canResume(), QDeclarativeListModelParser::compileProperty(), QScriptEnginePrivate::convertToNativeQObject(), QHttpNetworkConnectionChannel::detectPipeliningSupport(), QHttpNetworkReplyPrivate::findChallenge(), findSlot(), QUrl::fromPunycode(), QRegExpEngine::getEscape(), QFreetypeFace::getFace(), QDeclarativeCompiler::isSignalPropertyName(), QXIMInputContext::language(), QSvgTinyDocument::load(), QHostInfo::localDomainName(), QX11Data::motifdndObtainData(), QUrlPrivate::normalized(), QAuthenticatorPrivate::parseHttpResponse(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QHttpNetworkReplyPrivate::parseStatus(), QCoreApplicationPrivate::processCommandLineArguments(), qax_noSuchFunction(), qDecodeDataUrl(), QHttpNetworkReplyPrivate::readStatus(), QStateMachinePrivate::registerSignalTransition(), QUrlPrivate::toEncoded(), QNetworkCookie::toRawForm(), QIntValidator::validate(), QDoubleValidatorPrivate::validateWithLocale(), and QCoreApplicationData::~QCoreApplicationData().

int size

Definition: qbytearray.h:140

◆ startsWith() [1/3]

bool QByteArray::startsWith ( const QByteArray & ba ) const

Returns true if this byte array starts with byte array ba; otherwise returns false.

Example:

QByteArray url("ftp://ftp.qt.nokia.com/");
if (url.startsWith("ftp:"))
    ...

See also: endsWith(), left()

Definition at line 2684 of file qbytearray.cpp.

 {
     if (d == ba.d || ba.d->size == 0)
         return true;
     if (d->size < ba.d->size)
         return false;
     return memcmp(d->data, ba.d->data, ba.d->size) == 0;
 }

◆ startsWith() [2/3]

bool QByteArray::startsWith ( char ch ) const

Returns true if this byte array starts with character ch; otherwise returns false.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2719 of file qbytearray.cpp.

 {
     if (d->size == 0)
         return false;
     return d->data[0] == ch;
 }

◆ startsWith() [3/3]

bool QByteArray::startsWith ( const char * str ) const

Returns true if this byte array starts with string str; otherwise returns false.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2701 of file qbytearray.cpp.

 {
     if (!str || !*str)
         return true;
     int len = qstrlen(str);
     if (d->size < len)
         return false;
     return qstrncmp(d->data, str, len) == 0;
 }

◆ swap()

void QByteArray::swap ( QByteArray & other )

inline

Swaps byte array other with this byte array.

Since: 4.8

This operation is very fast and never fails.

Definition at line 164 of file qbytearray.h.

164 { qSwap(d, other.d); }

Referenced by QBBScreen::adjustOrientation(), buttonChange(), QVNCScreen::connect(), QWSDisplay::Data::connectToPipe(), QWindowsMimeHtml::convertToMime(), QWidget::create(), QEglFSScreen::createAndSetPlatformContext(), createContext(), QEgl::defaultConfig(), defaultDepth(), do_size_hints(), QGraphicsScenePrivate::draw(), QNetworkAccessHttpBackend::fetchCacheMetaData(), QWidgetBackingStore::flushPaint(), flushUpdate(), QFreetypeFace::getFace(), QBBNavigatorEventNotifier::handleMessage(), QSettingsPrivate::iniUnescapedKey(), QGtkStylePrivate::isKDE4Session(), QScreen::isWidgetPaintOnScreen(), layoutDebug(), QWidgetPrivate::moveRect(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QHttpNetworkReplyPrivate::parseStatus(), QDBusConnectionPrivate::QDBusConnectionPrivate(), QEglFSScreen::QEglFSScreen(), qt_flush(), qt_grab_cursor(), qt_graphicsLayoutDebug(), QVNCDirtyMap::QVNCDirtyMap(), QVNCScreenPrivate::QVNCScreenPrivate(), QRfbSingleColorHextile< SRC >::read(), read_int_env_var(), QWidgetPrivate::scroll_sys(), QWidgetPrivate::scrollRect(), QDirectFBPaintEnginePrivate::setCompositionMode(), QVNCDirtyMapOptimized< T >::setDirty(), QPainter::setRenderHint(), QWidgetPrivate::subtractOpaqueSiblings(), and QETWidget::translateConfigEvent().

Data * d

Definition: qbytearray.h:386

qSwap

void qSwap(T &value1, T &value2)

Definition: qglobal.h:2181

◆ toBase64()

QByteArray QByteArray::toBase64 ( ) const

Returns a copy of the byte array, encoded as Base64.

QByteArray text("Qt is great!");

text.toBase64(); // returns "UXQgaXMgZ3JlYXQh"

The algorithm used to encode Base64-encoded data is defined in RFC 2045.

See also: fromBase64()

Definition at line 3796 of file qbytearray.cpp.

Referenced by QDeclarativeEnginePrivate::btoa(), QAuthenticatorPrivate::calculateResponse(), QSvgPaintEngine::drawImage(), operator<<(), QSslKeyPrivate::pemFromDer(), QSslCertificatePrivate::QByteArray_from_X509(), QHttpMultiPartPrivate::QHttpMultiPartPrivate(), and QPatternist::Base64Binary::stringValue().

 {
     const char alphabet[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
                     "ghijklmn" "opqrstuv" "wxyz0123" "456789+/";
     const char padchar = '=';
     int padlen = 0;
 
     QByteArray tmp((d->size * 4) / 3 + 3, Qt::Uninitialized);
 
     int i = 0;
     char *out = tmp.data();
     while (i < d->size) {
     int chunk = 0;
     chunk |= int(uchar(d->data[i++])) << 16;
     if (i == d->size) {
         padlen = 2;
     } else {
         chunk |= int(uchar(d->data[i++])) << 8;
         if (i == d->size) padlen = 1;
         else chunk |= int(uchar(d->data[i++]));
     }
 
     int j = (chunk & 0x00fc0000) >> 18;
     int k = (chunk & 0x0003f000) >> 12;
     int l = (chunk & 0x00000fc0) >> 6;
     int m = (chunk & 0x0000003f);
     *out++ = alphabet[j];
     *out++ = alphabet[k];
     if (padlen > 1) *out++ = padchar;
     else *out++ = alphabet[l];
     if (padlen > 0) *out++ = padchar;
     else *out++ = alphabet[m];
     }
 
     tmp.truncate(out - tmp.data());
     return tmp;
 }

◆ toDouble()

double QByteArray::toDouble ( bool * ok = 0 ) const

Returns the byte array converted to a double value.

Returns 0.0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

QByteArray string("1234.56");

double a = string.toDouble(); // a == 1234.56

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3763 of file qbytearray.cpp.

Referenced by getXDefault(), and toFloat().

 {
     return QLocalePrivate::bytearrayToDouble(nulTerminated().constData(), ok);
 }

◆ toFloat()

float QByteArray::toFloat ( bool * ok = 0 ) const

Returns the byte array converted to a float value.

Returns 0.0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3782 of file qbytearray.cpp.

Referenced by QOpenGLPaintEngine::begin().

 {
     return float(toDouble(ok));
 }

◆ toHex()

QByteArray QByteArray::toHex ( ) const

Returns a hex encoded copy of the byte array.

The hex encoding uses the numbers 0-9 and the letters a-f.

See also: fromHex()

Definition at line 4271 of file qbytearray.cpp.

Referenced by digestMd5ResponseHelper(), QDBusMetaObjectGenerator::findType(), QDeclarativeEnginePrivate::md5(), QAuthenticatorPrivate::QAuthenticatorPrivate(), qmlsqldatabase_open_sync(), and QSslSocketBackendPrivate::startHandshake().

 {
     QByteArray hex(d->size * 2, Qt::Uninitialized);
     char *hexData = hex.data();
     const uchar *data = (const uchar *)d->data;
     for (int i = 0; i < d->size; ++i) {
         int j = (data[i] >> 4) & 0xf;
         if (j <= 9)
             hexData[i*2] = (j + '0');
          else
             hexData[i*2] = (j + 'a' - 10);
         j = data[i] & 0xf;
         if (j <= 9)
             hexData[i*2+1] = (j + '0');
          else
             hexData[i*2+1] = (j + 'a' - 10);
     }
     return hex;
 }

◆ toInt()

int QByteArray::toInt	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to an int using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

QByteArray str("FF");
bool ok;
int hex = str.toInt(&ok, 16);     // hex == 255, ok == true
int dec = str.toInt(&ok, 10);     // dec == 0, ok == false

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3576 of file qbytearray.cpp.

 {
     qlonglong v = toLongLong(ok, base);
     if (v < INT_MIN || v > INT_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return int(v);
 }

◆ toLong()

long QByteArray::toLong	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Since: 4.1

Returns the byte array converted to a long int using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

QByteArray str("FF");
bool ok;
long hex = str.toLong(&ok, 16);   // hex == 255, ok == true
long dec = str.toLong(&ok, 10);   // dec == 0, ok == false

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3641 of file qbytearray.cpp.

Referenced by QHttpNetworkReplyPrivate::getChunkSize().

 {
     qlonglong v = toLongLong(ok, base);
     if (v < LONG_MIN || v > LONG_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return long(v);
 }

◆ toLongLong()

qlonglong QByteArray::toLongLong	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to a {long long} using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3508 of file qbytearray.cpp.

Referenced by parseHeaderValue(), toInt(), toLong(), and toShort().

 {
 #if defined(QT_CHECK_RANGE)
     if (base != 0 && (base < 2 || base > 36)) {
         qWarning("QByteArray::toLongLong: Invalid base %d", base);
         base = 10;
     }
 #endif
 
     return QLocalePrivate::bytearrayToLongLong(nulTerminated().constData(), base, ok);
 }

◆ toLower()

QByteArray QByteArray::toLower ( ) const

Returns a lowercase copy of the byte array.

The bytearray is interpreted as a Latin-1 encoded string.

Example:

QByteArray x("Qt by NOKIA");
QByteArray y = x.toLower();
// y == "qt by nokia"

See also: toUpper(), {8-bit Character Comparisons}

Definition at line 2861 of file qbytearray.cpp.

Referenced by QHttpNetworkReplyPrivate::authenticationMethod(), QUrlPrivate::canonicalHost(), QTextCodec::codecForHtml(), createReadHandlerHelper(), digestMd5ResponseHelper(), QNetworkAccessHttpBackend::fetchCacheMetaData(), QDeclarativeXMLHttpRequest::fillHeadersList(), QHttpNetworkReplyPrivate::findChallenge(), fontFile(), get_named_rgb(), if(), imageReadMimeFormats(), imageWriteMimeFormats(), QWaylandNativeInterface::nativeResourceForWidget(), QAuthenticatorPrivate::parseHttpResponse(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), qax_noSuchFunction(), qDecodeDataUrl(), qt_fillFontDef(), read_xpm_body(), QHttpNetworkReplyPrivate::readHeader(), QPpmHandler::setOption(), WinMain(), and QTextDocumentWriter::write().

 {
     QByteArray s(*this);
     register uchar *p = reinterpret_cast<uchar *>(s.data());
     if (p) {
         while (*p) {
             *p = QChar::toLower((ushort)*p);
             p++;
         }
     }
     return s;
 }

◆ toPercentEncoding()

QByteArray QByteArray::toPercentEncoding	(	const QByteArray &	exclude = `QByteArray()`,
		const QByteArray &	include = `QByteArray()`,
		char	percent = `'%'`
	)		const

Returns a URI/URL-style percent-encoded copy of this byte array.

Since: 4.4

The percent parameter allows you to override the default '' character for another.

By default, this function will encode all characters that are not one of the following:

ALPHA ("a" to "z" and "A" to "Z") / DIGIT (0 to 9) / "-" / "." / "_" / "~"

To prevent characters from being encoded pass them to exclude. To force characters to be encoded pass them to include. The percent character is always encoded.

Example:

QByteArray text = "{a fishy string?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug(ba.constData());
// prints "{a fi%73hy %73tring%3F}"

The hex encoding uses the numbers 0-9 and the uppercase letters A-F.

See also: fromPercentEncoding(), QUrl::toPercentEncoding()

Definition at line 4467 of file qbytearray.cpp.

 {
     if (isNull())
         return QByteArray();    // preserve null
     if (isEmpty())
         return QByteArray(data(), 0);
 
     QByteArray include2 = include;
     if (percent != '%')                        // the default
         if ((percent >= 0x61 && percent <= 0x7A) // ALPHA
             || (percent >= 0x41 && percent <= 0x5A) // ALPHA
             || (percent >= 0x30 && percent <= 0x39) // DIGIT
             || percent == 0x2D // -
             || percent == 0x2E // .
             || percent == 0x5F // _
             || percent == 0x7E) // ~
         include2 += percent;
 
     QByteArray result = *this;
     q_toPercentEncoding(&result, exclude.nulTerminated().constData(), include2.nulTerminated().constData(), percent);
 
     return result;
 }

◆ toShort()

short QByteArray::toShort	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to a short using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3704 of file qbytearray.cpp.

 {
     qlonglong v = toLongLong(ok, base);
     if (v < SHRT_MIN || v > SHRT_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return short(v);
 }

◆ toUInt()

uint QByteArray::toUInt	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to an {unsigned int} using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3607 of file qbytearray.cpp.

Referenced by qt_parse_pattern().

 {
     qulonglong v = toULongLong(ok, base);
     if (v > UINT_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return uint(v);
 }

◆ toULong()

ulong QByteArray::toULong	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Since: 4.1

Returns the byte array converted to an {unsigned long int} using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3673 of file qbytearray.cpp.

 {
     qulonglong v = toULongLong(ok, base);
     if (v > ULONG_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return ulong(v);
 }

◆ toULongLong()

qulonglong QByteArray::toULongLong	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to an {unsigned long long} using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3541 of file qbytearray.cpp.

Referenced by QHttpNetworkHeaderPrivate::contentLength(), QNetworkAccessHttpBackend::postRequest(), toUInt(), toULong(), and toUShort().

 {
 #if defined(QT_CHECK_RANGE)
     if (base != 0 && (base < 2 || base > 36)) {
         qWarning("QByteArray::toULongLong: Invalid base %d", base);
         base = 10;
     }
 #endif
 
     return QLocalePrivate::bytearrayToUnsLongLong(nulTerminated().constData(), base, ok);
 }

◆ toUpper()

QByteArray QByteArray::toUpper ( ) const

Returns an uppercase copy of the byte array.

The bytearray is interpreted as a Latin-1 encoded string.

Example:

QByteArray x("Qt by NOKIA");
QByteArray y = x.toUpper();
// y == "QT BY NOKIA"

See also: toLower(), {8-bit Character Comparisons}

Definition at line 2884 of file qbytearray.cpp.

Referenced by QSslSocketBackendPrivate::startHandshake().

 {
     QByteArray s(*this);
     register uchar *p = reinterpret_cast<uchar *>(s.data());
     if (p) {
         while (*p) {
             *p = QChar::toUpper((ushort)*p);
             p++;
         }
     }
     return s;
 }

◆ toUShort()

ushort QByteArray::toUShort	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the byte array converted to an {unsigned short} using base base, which is 10 by default and must be between 2 and 36, or 0.

If base is 0, the base is determined automatically using the following rules: If the byte array begins with "0x", it is assumed to be hexadecimal; if it begins with "0", it is assumed to be octal; otherwise it is assumed to be decimal.

Returns 0 if the conversion fails.

If ok is not 0: if a conversion error occurs, *{ok} is set to false; otherwise *{ok} is set to true.

Note: The conversion of the number is performed in the default C locale, irrespective of the user's locale.

See also: number()

Definition at line 3735 of file qbytearray.cpp.

 {
     qulonglong v = toULongLong(ok, base);
     if (v > USHRT_MAX) {
         if (ok)
             *ok = false;
         v = 0;
     }
     return ushort(v);
 }

◆ trimmed()

QByteArray QByteArray::trimmed ( ) const

Returns a byte array that has whitespace removed from the start and the end.

Whitespace means any character for which the standard C++ isspace() function returns true. This includes the ASCII characters '\t', '\n', '\v', '\f', '\r', and ' '.

Example:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.trimmed();
// ba == "lots\t of\nwhitespace";

Unlike simplified(), trimmed() leaves internal whitespace alone.

See also: simplified()

Definition at line 3388 of file qbytearray.cpp.

Referenced by QHttpNetworkReplyPrivate::authenticationMethod(), QHostInfo::localDomainName(), QJpUnicodeConv::newConverter(), nextField(), parseCookieHeader(), QHttpNetworkReplyPrivate::parseHeader(), parseHeaderValue(), QAuthenticatorPrivate::parseHttpResponse(), QNetworkCookiePrivate::parseSetCookieHeaderLine(), QDeclarativeGridScaledImage::QDeclarativeGridScaledImage(), qDecodeDataUrl(), read_xpm_body(), QConfFileSettingsPrivate::readIniFile(), QMimeDataPrivate::retrieveTypedData(), and QCoreApplicationData::~QCoreApplicationData().

 {
     if (d->size == 0)
         return *this;
     const char *s = d->data;
     if (!isspace(uchar(*s)) && !isspace(uchar(s[d->size-1])))
         return *this;
     int start = 0;
     int end = d->size - 1;
     while (start<=end && isspace(uchar(s[start])))  // skip white space from start
         start++;
     if (start <= end) {                          // only white space
         while (end && isspace(uchar(s[end])))           // skip white space from end
             end--;
     }
     int l = end - start + 1;
     if (l <= 0) {
         shared_empty.ref.ref();
         return QByteArray(&shared_empty, 0, 0);
     }
     return QByteArray(s+start, l);
 }

◆ truncate()

void QByteArray::truncate ( int pos )

Truncates the byte array at index position pos.

If pos is beyond the end of the array, nothing happens.

Example:

QByteArray ba("Stockholm");

ba.truncate(5); // ba == "Stock"

See also: chop(), resize(), left()

Definition at line 1270 of file qbytearray.cpp.

Referenced by QIsciiCodec::convertFromUnicode(), MetaObjectGenerator::createPrototype(), QZipReader::fileData(), fromBase64(), QMetaMethod::invoke(), QAxServerBase::Invoke(), QHostInfo::localDomainName(), QIBaseDriver::open(), MetaObjectGenerator::paramList(), paramType(), QDBusMetaObjectGenerator::parseMethods(), QAxMetaObject::parsePrototype(), QDBusMetaObjectGenerator::parseSignals(), QDBusConnectionPrivate::prepareHook(), q_fromPercentEncoding(), q_toPercentEncoding(), qDBusParametersForMethod(), qDecodeDataUrl(), QVariantToVARIANT(), QXIMInputContext::QXIMInputContext(), read_xpm_body(), MetaObjectGenerator::readFuncsInfo(), QHttpNetworkReplyPrivate::readStatus(), QDBusConnectionPrivate::relaySignal(), removeDotsFromPath(), and toBase64().

 {
     if (pos < d->size)
         resize(pos);
 }

Friends and Related Functions

◆ operator!=() [1/3]

bool operator!=	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 533 of file qbytearray.h.

534 { return !(a1==a2); }

◆ operator!=() [2/3]

bool operator!=	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is not equal to string a2; otherwise returns false.

Definition at line 535 of file qbytearray.h.

536 { return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

bool isEmpty() const

Returns true if the byte array has size 0; otherwise returns false.

Definition: qbytearray.h:421

◆ operator!=() [3/3]

bool operator!=	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is not equal to byte array a2; otherwise returns false.

Definition at line 537 of file qbytearray.h.

538 { return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

bool isEmpty() const

Returns true if the byte array has size 0; otherwise returns false.

Definition: qbytearray.h:421

◆ operator+() [1/5]

const QByteArray operator+	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

See also: QByteArray::operator+=()

Definition at line 564 of file qbytearray.h.

565 { return QByteArray(a1) += a2; }

QByteArray()

Constructs an empty byte array.

Definition: qbytearray.h:400

◆ operator+() [2/5]

const QByteArray operator+	(	const QByteArray &	a1,
		const char *	a2
	)

Returns a byte array that is the result of concatenating byte array a1 and string a2.

Definition at line 566 of file qbytearray.h.

567 { return QByteArray(a1) += a2; }

QByteArray()

Constructs an empty byte array.

Definition: qbytearray.h:400

◆ operator+() [3/5]

const QByteArray operator+	(	const QByteArray &	a1,
		char	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 568 of file qbytearray.h.

569 { return QByteArray(a1) += a2; }

QByteArray()

Constructs an empty byte array.

Definition: qbytearray.h:400

◆ operator+() [4/5]

const QByteArray operator+	(	const char *	a1,
		const QByteArray &	a2
	)

Returns a byte array that is the result of concatenating string a1 and byte array a2.

Definition at line 570 of file qbytearray.h.

571 { return QByteArray(a1) += a2; }

QByteArray()

Constructs an empty byte array.

Definition: qbytearray.h:400

◆ operator+() [5/5]

const QByteArray operator+	(	char	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 572 of file qbytearray.h.

573 { return QByteArray(&a1, 1) += a2; }

QByteArray()

Constructs an empty byte array.

Definition: qbytearray.h:400

◆ operator<() [1/3]

bool operator<	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 539 of file qbytearray.h.

Referenced by QElapsedTimer::operator!=().

540 { return qstrcmp(a1, a2) < 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator<() [2/3]

bool operator<	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is lexically less than string a2; otherwise returns false.

Definition at line 541 of file qbytearray.h.

542 { return qstrcmp(a1, a2) < 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator<() [3/3]

bool operator<	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is lexically less than byte array a2; otherwise returns false.

Definition at line 543 of file qbytearray.h.

544 { return qstrcmp(a1, a2) < 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator<<()

QDataStream & operator<<	(	QDataStream &	out,
		const QByteArray &	ba
	)

See also: {Serializing Qt Data Types}

Definition at line 2928 of file qbytearray.cpp.

Referenced by setNum().

 {
     if (ba.isNull() && out.version() >= 6) {
         out << (quint32)0xffffffff;
         return out;
     }
     return out.writeBytes(ba, ba.size());
 }

◆ operator<=() [1/3]

bool operator<=	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 545 of file qbytearray.h.

546 { return qstrcmp(a1, a2) <= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator<=() [2/3]

bool operator<=	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is lexically less than or equal to string a2; otherwise returns false.

Definition at line 547 of file qbytearray.h.

548 { return qstrcmp(a1, a2) <= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator<=() [3/3]

bool operator<=	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is lexically less than or equal to byte array a2; otherwise returns false.

Definition at line 549 of file qbytearray.h.

550 { return qstrcmp(a1, a2) <= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator==() [1/3]

bool operator==	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 527 of file qbytearray.h.

528 { return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); }

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ operator==() [2/3]

bool operator==	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is equal to string a2; otherwise returns false.

Definition at line 529 of file qbytearray.h.

530 { return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

bool isEmpty() const

Returns true if the byte array has size 0; otherwise returns false.

Definition: qbytearray.h:421

◆ operator==() [3/3]

bool operator==	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is equal to byte array a2; otherwise returns false.

Definition at line 531 of file qbytearray.h.

532 { return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

bool isEmpty() const

Returns true if the byte array has size 0; otherwise returns false.

Definition: qbytearray.h:421

◆ operator>() [1/3]

bool operator>	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 551 of file qbytearray.h.

552 { return qstrcmp(a1, a2) > 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>() [2/3]

bool operator>	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is lexically greater than string a2; otherwise returns false.

Definition at line 553 of file qbytearray.h.

554 { return qstrcmp(a1, a2) > 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>() [3/3]

bool operator>	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is lexically greater than byte array a2; otherwise returns false.

Definition at line 555 of file qbytearray.h.

556 { return qstrcmp(a1, a2) > 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>=() [1/3]

bool operator>=	(	const QByteArray &	a1,
		const QByteArray &	a2
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 557 of file qbytearray.h.

558 { return qstrcmp(a1, a2) >= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>=() [2/3]

bool operator>=	(	const QByteArray &	a1,
		const char *	a2
	)

Returns true if byte array a1 is lexically greater than or equal to string a2; otherwise returns false.

Definition at line 559 of file qbytearray.h.

560 { return qstrcmp(a1, a2) >= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>=() [3/3]

bool operator>=	(	const char *	a1,
		const QByteArray &	a2
	)

Returns true if string a1 is lexically greater than or equal to byte array a2; otherwise returns false.

Definition at line 561 of file qbytearray.h.

562 { return qstrcmp(a1, a2) >= 0; }

int qstrcmp(const char *str1, const char *str2)

A safe strcmp() function.

Definition: qbytearray.cpp:231

◆ operator>>()

QDataStream & operator>>	(	QDataStream &	in,
		QByteArray &	ba
	)

See also: {Serializing Qt Data Types}

Definition at line 2948 of file qbytearray.cpp.

Referenced by setNum().

 {
     ba.clear();
     quint32 len;
     in >> len;
     if (len == 0xffffffff)
         return in;
 
     const quint32 Step = 1024 * 1024;
     quint32 allocated = 0;
 
     do {
         int blockSize = qMin(Step, len - allocated);
         ba.resize(allocated + blockSize);
         if (in.readRawData(ba.data() + allocated, blockSize) != blockSize) {
             ba.clear();
             in.setStatus(QDataStream::ReadPastEnd);
             return in;
         }
         allocated += blockSize;
     } while (allocated < len);
 
     return in;
 }

◆ QByteRef

friend class QByteRef

friend

Definition at line 392 of file qbytearray.h.

Referenced by operator[]().

◆ qChecksum()

quint16 qChecksum	(	const char *	data,
		uint	len
	)

The checksum is independent of the byte order (endianness).

Note: This function is a 16-bit cache conserving (16 entry table) implementation of the CRC-16-CCITT algorithm.

Definition at line 434 of file qbytearray.cpp.

Referenced by qstrncmp().

 {
     register quint16 crc = 0xffff;
     uchar c;
     const uchar *p = reinterpret_cast<const uchar *>(data);
     while (len--) {
         c = *p++;
         crc = ((crc >> 4) & 0x0fff) ^ crc_tbl[((crc ^ c) & 15)];
         c >>= 4;
         crc = ((crc >> 4) & 0x0fff) ^ crc_tbl[((crc ^ c) & 15)];
     }
     return ~crc & 0xffff;
 }

◆ qCompress() [1/2]

QByteArray qCompress	(	const QByteArray &	data,
		int	compressionLevel
	)

The compressionLevel parameter specifies how much compression should be used. Valid values are between 0 and 9, with 9 corresponding to the greatest compression (i.e. smaller compressed data) at the cost of using a slower algorithm. Smaller values (8, 7, ..., 1) provide successively less compression at slightly faster speeds. The value 0 corresponds to no compression at all. The default value is -1, which specifies zlib's default compression.

See also: qUncompress()

Definition at line 604 of file qbytearray.h.

Referenced by qCompress(), and setNum().

605 { return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }

QByteArray::qCompress

QByteArray qCompress(const QByteArray &data, int compressionLevel)

Compresses the data byte array and returns the compressed data in a new byte array.

Definition: qbytearray.h:604

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433

int size() const

Returns the number of bytes in this byte array.

Definition: qbytearray.h:402

◆ qCompress() [2/2]

QByteArray qCompress	(	const uchar *	data,
		int	nbytes,
		int	compressionLevel
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 483 of file qbytearray.cpp.

 {
     if (nbytes == 0) {
         return QByteArray(4, '\0');
     }
     if (!data) {
         qWarning("qCompress: Data is null");
         return QByteArray();
     }
     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, (uchar*)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;
         }
     } while (res == Z_BUF_ERROR);
 
     return bazip;
 }

◆ qsnprintf()

int qsnprintf	(	char *	str,
		size_t	n,
		const char *	fmt,
			...
	)

fmt is the printf() format string. The result is put into str, which is a buffer of at least n bytes.

Warning: Call this function only when you know what you are doing since it shows different behavior on certain platforms. Use QString::sprintf() to format a string instead.

See also: qvsnprintf(), QString::sprintf()

Definition at line 128 of file qvsnprintf.cpp.

Referenced by fromPercentEncodingMutable(), qstrncmp(), qt_x_errhandler(), and write_xbm_image().

 {
     va_list ap;
     va_start(ap, fmt);
 
     int ret = qvsnprintf(str, n, fmt, ap);
     va_end(ap);
 
     return ret;
 }

◆ qstrcmp()

int qstrcmp	(	const char *	str1,
		const char *	str2
	)

Compares str1 and str2. Returns a negative value if str1 is less than str2, 0 if str1 is equal to str2 or a positive value if str1 is greater than str2.

Special case 1: Returns 0 if str1 and str2 are both 0.

Special case 2: Returns an arbitrary non-zero value if str1 is 0 or str2 is 0 (but not both).

See also: qstrncmp(), qstricmp(), qstrnicmp(), {8-bit Character Comparisons}

Definition at line 231 of file qbytearray.cpp.

Referenced by convert(), operator!=(), operator<(), operator<=(), operator==(), operator>(), operator>=(), qstrcmp(), qstrnlen(), and QVariantToVARIANT().

 {
     return (str1 && str2) ? strcmp(str1, str2)
         : (str1 ? 1 : (str2 ? -1 : 0));
 }

◆ qstrcpy()

char * qstrcpy	(	char *	dst,
		const char *	src
	)

If src is 0, it immediately returns 0.

This function assumes that dst is large enough to hold the contents of src.

See also: qstrncpy()

Definition at line 137 of file qbytearray.cpp.

Referenced by qstrdup(), qstrncmp(), and qstrnlen().

 {
     if (!src)
         return 0;
 #if defined(_MSC_VER) && _MSC_VER >= 1400
     int len = qstrlen(src);
     // This is actually not secure!!! It will be fixed
     // properly in a later release!
     if (len >= 0 && strcpy_s(dst, len+1, src) == 0)
         return dst;
     return 0;
 #else
     return strcpy(dst, src);
 #endif
 }

◆ qstrdup()

char * qstrdup ( const char * src )

Allocates space for a copy of src, copies it, and returns a pointer to the copy. If src is 0, it immediately returns 0.

Ownership is passed to the caller, so the returned string must be deleted using delete[].

Definition at line 114 of file qbytearray.cpp.

 {
     if (!src)
         return 0;
     char *dst = new char[strlen(src) + 1];
     return qstrcpy(dst, src);
 }

◆ qstricmp()

int qstricmp	(	const char *	str1,
		const char *	str2
	)

Compares str1 and str2 ignoring the case of the characters. The encoding of the strings is assumed to be Latin-1.

Returns a negative value if str1 is less than str2, 0 if str1 is equal to str2 or a positive value if str1 is greater than str2.

Special case 1: Returns 0 if str1 and str2 are both 0.

Special case 2: Returns a random non-zero value if str1 is 0 or str2 is 0 (but not both).

See also: qstrcmp(), qstrncmp(), qstrnicmp(), {8-bit Character Comparisons}

Definition at line 279 of file qbytearray.cpp.

Referenced by classIDL(), nameMatch(), and qstrncmp().

 {
     register const uchar *s1 = reinterpret_cast<const uchar *>(str1);
     register const uchar *s2 = reinterpret_cast<const uchar *>(str2);
     int res;
     uchar c;
     if (!s1 || !s2)
         return s1 ? 1 : (s2 ? -1 : 0);
     for (; !(res = (c = QChar::toLower((ushort)*s1)) - QChar::toLower((ushort)*s2)); s1++, s2++)
         if (!c)                                // strings are equal
             break;
     return res;
 }

◆ QString

friend class QString

friend

Definition at line 393 of file qbytearray.h.

◆ qstrlen()

uint qstrlen ( const char * str )

Returns the number of characters that precede the terminating '\0', or 0 if str is 0.

See also: qstrnlen()

Definition at line 79 of file qbytearray.h.

Referenced by append(), compare(), containsTLDEntry(), count(), endsWith(), indexOf(), insert(), lastIndexOf(), operator=(), prepend(), QByteArray(), qstrcpy(), qsvg_get_hex_rgb(), qt_get_hex_rgb(), removeGroupSeparators(), replace(), startsWith(), and write_xbm_image().

80 { return str ? uint(strlen(str)) : 0; }

unsigned int uint

Definition: qglobal.h:996

◆ qstrncmp()

int qstrncmp	(	const char *	str1,
		const char *	str2,
		uint	len
	)

Compares at most len bytes of str1 and str2.

Returns a negative value if str1 is less than str2, 0 if str1 is equal to str2 or a positive value if str1 is greater than str2.

Special case 1: Returns 0 if str1 and str2 are both 0.

Special case 2: Returns a random non-zero value if str1 is 0 or str2 is 0 (but not both).

See also: qstrcmp(), qstricmp(), qstrnicmp(), {8-bit Character Comparisons}

Definition at line 101 of file qbytearray.h.

Referenced by endsWith(), read_dib_fileheader(), and startsWith().

 {
     return (str1 && str2) ? strncmp(str1, str2, len)
         : (str1 ? 1 : (str2 ? -1 : 0));
 }

◆ qstrncpy()

char * qstrncpy	(	char *	dst,
		const char *	src,
		uint	len
	)

Copies at most len bytes from src (stopping at len or the terminating '\0' whichever comes first) into dst and returns a pointer to dst. Guarantees that dst is '\0'-terminated. If src or dst is 0, returns 0 immediately.

This function assumes that dst is at least len characters long.

Note: When compiling with Visual C++ compiler version 14.00 (Visual C++ 2005) or later, internally the function strncpy_s will be used.

See also: qstrcpy()

Definition at line 175 of file qbytearray.cpp.

Referenced by qstrnlen().

 {
     if (!src || !dst)
         return 0;
 #if defined(_MSC_VER) && _MSC_VER >= 1400
     strncpy_s(dst, len, src, len-1);
 #else
     strncpy(dst, src, len);
 #endif
     if (len > 0)
         dst[len-1] = '\0';
     return dst;
 }

◆ qstrnicmp()

int qstrnicmp	(	const char *	str1,
		const char *	str2,
		uint	len
	)

Compares at most len bytes of str1 and str2 ignoring the case of the characters. The encoding of the strings is assumed to be Latin-1.

Returns a negative value if str1 is less than str2, 0 if str1 is equal to str2 or a positive value if str1 is greater than str2.

Special case 1: Returns 0 if str1 and str2 are both 0.

Special case 2: Returns a random non-zero value if str1 is 0 or str2 is 0 (but not both).

See also: qstrcmp(), qstrncmp(), qstricmp(), {8-bit Character Comparisons}

Definition at line 316 of file qbytearray.cpp.

Referenced by qstrncmp().

 {
     register const uchar *s1 = reinterpret_cast<const uchar *>(str1);
     register const uchar *s2 = reinterpret_cast<const uchar *>(str2);
     int res;
     uchar c;
     if (!s1 || !s2)
         return s1 ? 1 : (s2 ? -1 : 0);
     for (; len--; s1++, s2++) {
         if ((res = (c = QChar::toLower((ushort)*s1)) - QChar::toLower((ushort)*s2)))
             return res;
         if (!c)                                // strings are equal
             break;
     }
     return 0;
 }

◆ qstrnlen()

uint qstrnlen	(	const char *	str,
		uint	maxlen
	)

Since: 4.2

A safe strnlen() function.

Returns the number of characters that precede the terminating '\0', but at most maxlen. If str is 0, returns 0.

See also: qstrlen()

Definition at line 82 of file qbytearray.h.

 {
     uint length = 0;
     if (str) {
         while (length < maxlen && *str++)
             length++;
     }
     return length;
 }

◆ qUncompress [1/2]

QByteArray qUncompress	(	const uchar *	data,
		int	nbytes
	)

friend

Uncompresses the first nbytes of data and returns a new byte array with the uncompressed data.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 562 of file qbytearray.cpp.

Referenced by qUncompress(), and setNum().

 {
     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();
     }
     ulong expectedSize = (data[0] << 24) | (data[1] << 16) |
                        (data[2] <<  8) | (data[3]      );
     ulong len = qMax(expectedSize, 1ul);
     QScopedPointer<QByteArray::Data, QScopedPointerPodDeleter> d;
 
     forever {
         ulong alloc = len;
         if (len  >= ulong(1 << 31) - sizeof(QByteArray::Data)) {
             //QByteArray does not support that huge size anyway.
             qWarning("qUncompress: Input data is corrupted");
             return QByteArray();
         }
         QByteArray::Data *p = static_cast<QByteArray::Data *>(qRealloc(d.data(), sizeof(QByteArray::Data) + alloc));
         if (!p) {
             // we are not allowed to crash here when compiling with QT_NO_EXCEPTIONS
             qWarning("qUncompress: could not allocate enough memory to uncompress data");
             return QByteArray();
         }
         d.take(); // realloc was successful
         d.reset(p);
 
         int res = ::uncompress((uchar*)d->array, &len,
                                (uchar*)data+4, nbytes-4);
 
         switch (res) {
         case Z_OK:
             if (len != alloc) {
                 if (len  >= ulong(1 << 31) - sizeof(QByteArray::Data)) {
                     //QByteArray does not support that huge size anyway.
                     qWarning("qUncompress: Input data is corrupted");
                     return QByteArray();
                 }
                 QByteArray::Data *p = static_cast<QByteArray::Data *>(qRealloc(d.data(), sizeof(QByteArray::Data) + len));
                 if (!p) {
                     // we are not allowed to crash here when compiling with QT_NO_EXCEPTIONS
                     qWarning("qUncompress: could not allocate enough memory to uncompress data");
                     return QByteArray();
                 }
                 d.take(); // realloc was successful
                 d.reset(p);
             }
             d->ref = 1;
             d->alloc = d->size = len;
             d->data = d->array;
             d->array[len] = 0;
 
             return QByteArray(d.take(), 0, 0);
 
         case Z_MEM_ERROR:
             qWarning("qUncompress: Z_MEM_ERROR: Not enough memory");
             return QByteArray();
 
         case Z_BUF_ERROR:
             len *= 2;
             continue;
 
         case Z_DATA_ERROR:
             qWarning("qUncompress: Z_DATA_ERROR: Input data is corrupted");
             return QByteArray();
         }
     }
 }

◆ qUncompress() [2/2]

QByteArray qUncompress ( const QByteArray & data )

Returns an empty QByteArray if the input data was corrupt.

This function will uncompress data compressed with qCompress() from this and any earlier Qt version, back to Qt 3.1 when this feature was added.

Note: If you want to use this function to uncompress external 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.

See also: qCompress()

Definition at line 606 of file qbytearray.h.

607 { return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }

const char * constData() const

Returns a pointer to the data stored in the byte array.

Definition: qbytearray.h:433