QString Class Reference

QStringData * d

Definition: qstring.h:560

QString::shared_null

static QStringData * shared_null

Definition: qstring.h:561

QString::QString	(	int	size,
		bool	dummy
	)

private

Private function.

Constructs a string with preallocated space for size characters.

The string is empty.

See also: isNull()

Definition at line 12260 of file qstring.cpp.

 {
     if ( size ) {
         Q2HELPER(stat_construct_int++)
         int l = size;
         Q2HELPER(stat_construct_int_size+=l)
         QChar* uc = QT_ALLOC_QCHAR_VEC( l );
         d = new QStringData( uc, 0, l );
     } else {
         Q2HELPER(stat_construct_null++)
         d = shared_null ? shared_null : (shared_null=new QStringData);
         d->ref();
     }
 }

QString::QString	(	QStringData *	dd,
		bool
	)

inlineprivate

Definition at line 565 of file qstring.h.

565 : d(dd) { }

QStringData * d

Definition: qstring.h:560

Member Function Documentation

QString & QString::append ( char ch )

inline

Appends ch to the string and returns a reference to the result. Equivalent to operator+=().

Definition at line 703 of file qstring.h.

704 { return operator+=(c); }

QString::operator+=

QString & operator+=(const QString &str)

Definition: qstring.cpp:14399

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString & QString::append ( QChar ch )

inline

Appends ch to the string and returns a reference to the result. Equivalent to operator+=().

Definition at line 700 of file qstring.h.

701 { return operator+=(c); }

QString::operator+=

QString & operator+=(const QString &str)

Definition: qstring.cpp:14399

dictionary c

Definition: ValidateOpDetSimulation.py:57

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

inline

Appends str to the string and returns a reference to the result. Equivalent to operator+=().

Definition at line 697 of file qstring.h.

698 { return operator+=(s); }

QString::operator+=

QString & operator+=(const QString &str)

Definition: qstring.cpp:14399

s

static QCString * s

Definition: config.cpp:1042

QString QString::arg	(	long	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 12593 of file qstring.cpp.

 {
     return arg( QString::number( a, base ), fieldwidth );
 }

QString QString::arg	(	ulong	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 12603 of file qstring.cpp.

 {
     return arg( QString::number( a, base ), fieldwidth );
 }

QString QString::arg	(	int	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

inline

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 721 of file qstring.h.

722 { return arg((long)a, fieldwidth, base); }

Definition: value_ptr_test_4.cc:5

QString arg(long a, int fieldwidth=0, int base=10) const

Definition: qstring.cpp:12593

const double a

Definition: gUpMuFluxGen.cxx:164

QString QString::arg	(	uint	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

inline

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 724 of file qstring.h.

725 { return arg((ulong)a, fieldwidth, base); }

Definition: value_ptr_test_4.cc:5

QString arg(long a, int fieldwidth=0, int base=10) const

Definition: qstring.cpp:12593

const double a

Definition: gUpMuFluxGen.cxx:164

unsigned long ulong

Definition: qglobal.h:352

QString QString::arg	(	short	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

inline

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 727 of file qstring.h.

728 { return arg((long)a, fieldwidth, base); }

Definition: value_ptr_test_4.cc:5

QString arg(long a, int fieldwidth=0, int base=10) const

Definition: qstring.cpp:12593

const double a

Definition: gUpMuFluxGen.cxx:164

QString QString::arg	(	ushort	a,
		int	fieldwidth = `0`,
		int	base = `10`
	)		const

inline

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

a is expressed in to base notation, which is decimal by default and must be in the range 2-36 inclusive.

Definition at line 730 of file qstring.h.

731 { return arg((ulong)a, fieldwidth, base); }

Definition: value_ptr_test_4.cc:5

QString arg(long a, int fieldwidth=0, int base=10) const

Definition: qstring.cpp:12593

const double a

Definition: gUpMuFluxGen.cxx:164

unsigned long ulong

Definition: qglobal.h:352

QString QString::arg	(	char	a,
		int	fieldwidth = `0`
	)		const

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

a is assumed to be in the Latin1 character set.

Definition at line 12642 of file qstring.cpp.

 {
     QString c;
     c += a;
     return arg( c, fieldwidth );
 }

QString QString::arg	(	QChar	a,
		int	fieldwidth = `0`
	)		const

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 12651 of file qstring.cpp.

 {
     QString c;
     c += a;
     return arg( c, fieldwidth );
 }

QString QString::arg	(	const QString &	a,
		int	fieldwidth = `0`
	)		const

Returns a string equal to this one, but with the lowest-numbered occurrence of i (for a positive integer i) replaced by a.

label.setText( tr("Rename %1 to %2?").arg(oldName).arg(newName) );

fieldwidth is the minimum amount of space a is padded to. A positive value produces right-aligned text, while a negative value produces left aligned text.

Warning: Using arg() for constructing "real" sentences programmatically is likely to lead to translation problems. Inserting objects like numbers or file names is fairly safe.; Relying on spaces to create alignment is prone to lead to translation problems.

If there is no i pattern, a warning message (qWarning()) is printed and the text as appended at the end of the string. This is error recovery and should not occur in correct code.

See also: QObject::tr()

Definition at line 12553 of file qstring.cpp.

 {
     int pos, len;
     QString r = *this;
 
     if ( !findArg( pos, len ) ) {
         qWarning( "QString::arg(): Argument missing: %s, %s",
                   (const char *)ascii(), (const char *)ascii() );
         // Make sure the text at least appears SOMEWHERE
         r += ' ';
         pos = r.length();
         len = 0;
     }
 
     r.replace( pos, len, a );
     if ( fieldwidth < 0 ) {
         QString s;
         while ( (uint)-fieldwidth > a.length() ) {
             s += ' ';
             fieldwidth++;
         }
         r.insert( pos + a.length(), s );
     } else if ( fieldwidth ) {
         QString s;
         while ( (uint)fieldwidth > a.length() ) {
             s += ' ';
             fieldwidth--;
         }
         r.insert( pos, s );
     }
 
     return r;
 }

QString QString::arg	(	double	a,
		int	fieldwidth = `0`,
		char	fmt = `'g'`,
		int	prec = `-1`
	)		const

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

is formatted according to the fmt format specified, which is 'g' by default and can be any of 'f', 'F', 'e', 'E', 'g' or 'G', all of which have the same meaning as for sprintf(). prec determines the precision, just as for number() and sprintf().

Definition at line 12665 of file qstring.cpp.

 {
     return arg( QString::number( a, fmt, prec ), fieldwidth );
 }

const char * QString::ascii ( ) const

This functions simply calls latin1() and returns the result.

Definition at line 14494 of file qstring.cpp.

 {
     return latin1();
 }

QChar * QString::asciiToUnicode	(	const char *	str,
		uint *	len,
		uint	maxlen = `(uint)-1`
	)

staticprivate

This utility function converts the NUL-terminated 8-bit string str to Unicode, returning the result and setting len to the length of the Unicode string.

The caller is responsible for deleting the return value with delete[].

Definition at line 12005 of file qstring.cpp.

 {
     QChar* result = 0;
     uint l = 0;
     if ( str ) {
         if ( maxlen != (uint)-1 ) {
             while ( l < maxlen && str[l] )
                 l++;
         } else {
             // Faster?
             l = qstrlen(str);
         }
         QChar *uc = new QChar[ l ]; // Can't use macro since function is public
         result = uc;
         uint i = l;
         while ( i-- )
             *uc++ = *str++;
     }
     if ( len )
         *len = l;
     return result;
 }

QChar * QString::asciiToUnicode	(	const QByteArray &	ba,
		uint *	len
	)

staticprivate

This utility function converts the 8-bit string ba to Unicode, returning the result.

The caller is responsible for deleting the return value with delete[].

Definition at line 11957 of file qstring.cpp.

 {
     if ( ba.isNull() ) {
         if ( len )
           *len = 0;
         return 0;
     }
     int l = 0;
     while ( l < (int)ba.size() && ba[l] )
         l++;
     const char* str = ba.data();
     QChar *uc = new QChar[ l ];   // Can't use macro, since function is public
     QChar *result = uc;
     if ( len )
         *len = l;
     while (l--)
         *uc++ = *str++;
     return result;
 }

QChar QString::at ( uint i ) const

inline

Returns the character at i, or 0 if i is beyond the length of the string.

Note: If this QString is not const or const&, the non-const at() will be used instead, which will expand the string if i is beyond the length of the string.

Definition at line 492 of file qstring.h.

493 { return i<d->len ? d->unicode[i] : QChar::null; }

QStringData::len

uint len

Definition: qstring.h:344

QStringData * d

Definition: qstring.h:560

QStringData::unicode

QChar * unicode

Definition: qstring.h:342

QChar::null

QT_STATIC_CONST QChar null

Definition: qstring.h:68

QCharRef QString::at ( uint i )

inline

Returns a reference to the character at i, expanding the string with QChar::null if necessary. The resulting reference can then be assigned to, or otherwise used immediately, but becomes invalid once further modifications are made to the string.

Definition at line 623 of file qstring.h.

623 { return QCharRef(this,i); }

QCharRef

The QCharRef class is a helper class for QString.

Definition: qstring.h:568

QChar::Direction QString::basicDirection ( )

This function returns the basic directionality of the string (QChar::DirR for right to left and QChar::DirL for left to right). Useful to find the right alignment.

Definition at line 11621 of file qstring.cpp.

 {
 #ifndef QT_NO_UNICODETABLES
     // find base direction
     unsigned int pos = 0;
     while ((pos < length()) &&
            (at(pos) != RLE) &&
            (at(pos) != LRE) &&
            (at(pos) != RLO) &&
            (at(pos) != LRO) &&
            (at(pos).direction() > 1) &&
            (at(pos).direction() != QChar::DirAL)) // not R and not L
         pos++;
 
     if ((at(pos).direction() == QChar::DirR) ||
         (at(pos).direction() == QChar::DirAL) ||
         (at(pos) == RLE) ||
         (at(pos) == RLO))
         return QChar::DirR;
 #endif
 
     return QChar::DirL;
 }

int QString::compare ( const QString & s ) const

Compares this string to s, returning an integer less than, equal to, or greater than zero if it is, respectively, lexically less than, equal to, or greater than s.

Definition at line 14838 of file qstring.cpp.

 {
     return ucstrcmp(*this,s);
 }

int QString::compare	(	const QString &	s1,
		const QString &	s2
	)

inlinestatic

Compare s1 to s2 returning an integer less than, equal to, or greater than zero if s1 is, respectively, lexically less than, equal to, or greater than s2.

Definition at line 530 of file qstring.h.

531 { return s1.compare(s2); }

QString::compare

int compare(const QString &s) const

Definition: qstring.cpp:14838

void QString::compose ( )

Note that this function is not supported in Qt 2.0, and is merely for experimental and illustrative purposes. It is mainly of interest to those experimenting with Arabic and other composition-rich texts.

Applies possible ligatures to a QString, useful when composition-rich text requires rendering with glyph-poor fonts, but also makes compositions such as QChar(0x0041) ('A') and QChar(0x0308) (Unicode accent diaresis) giving QChar(0x00c4) (German A Umlaut).

Definition at line 11543 of file qstring.cpp.

 {
 #ifndef QT_NO_UNICODETABLES
     unsigned int index=0, len;
     unsigned int cindex = 0;
 
     QChar code, head;
 
     QArray<QChar> dia;
 
     QString composed = *this;
 
     while (index < length()) {
         code = at(index);
         //printf("\n\nligature for 0x%x:\n", code.unicode());
         QLigature ligature(code);
         ligature.first();
         while(ligature.current()) {
             if ((len = ligature.match(*this, index)) != 0) {
                 head = ligature.head();
                 unsigned short code = head.unicode();
                 // we exclude Arabic presentation forms A and a few
                 // other ligatures, which are undefined in most fonts
                 if(!(code > 0xfb50 && code < 0xfe80) &&
                    !(code > 0xfb00 && code < 0xfb2a)) {
                                 // joining info is only needed for arabic
                     if (format(ligature.tag(), *this, index, len)) {
                         //printf("using ligature 0x%x, len=%d\n",code,len);
                         // replace letter
                         composed.replace(cindex, len, QChar(head));
                         index += len-1;
                         // we continue searching in case we have a final
                         // form because medial ones are preferred.
                         if ( len != 1 || ligature.tag() !=QChar::Final )
                             break;
                     }
                 }
             }
             ligature.next();
         }
         cindex++;
         index++;
     }
     *this = composed;
 #endif
 }

QChar QString::constref ( uint i ) const

inline

Equivalent to at(i), this returns the QChar at i by value.

See also: ref()

Definition at line 498 of file qstring.h.

499 { return at(i); }

QString::at

QChar at(uint i) const

Definition: qstring.h:492

int QString::contains	(	QChar	c,
		bool	cs = `TRUE`
	)		const

Returns the number of times the character c occurs in the string.

The match is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

Definition at line 13104 of file qstring.cpp.

 {
     int count = 0;
     const QChar *uc = unicode();
     if ( !uc )
         return 0;
     int n = length();
     if ( cs ) {                                 // case sensitive
         while ( n-- )
             if ( *uc++ == c )
                 count++;
     } else {                                    // case insensitive
         c = c.lower();
         while ( n-- ) {
             if ( uc->lower() == c )
                 count++;
             uc++;
         }
     }
     return count;
 }

int QString::contains	(	char	c,
		bool	cs = `TRUE`
	)		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 424 of file qstring.h.

425 { return contains(QChar(c), cs); }

The QChar class provides a light-weight Unicode character.

Definition: qstring.h:56

QString::contains

int contains(QChar c, bool cs=TRUE) const

Definition: qstring.cpp:13104

dictionary c

Definition: ValidateOpDetSimulation.py:57

cs

const char * cs

Definition: qtextcodec.cpp:1350

int QString::contains	(	const char *	str,
		bool	cs = `TRUE`
	)		const

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 13129 of file qstring.cpp.

 {
     return contains(QString(str),cs);
 }

int QString::contains	(	const QString &	str,
		bool	cs = `TRUE`
	)		const

Returns the number of times str occurs in the string.

The match is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

This function counts overlapping substrings, for example, "banana" contains two occurrences of "ana".

See also: findRev()

Definition at line 13160 of file qstring.cpp.

 {
     int count = 0;
     const QChar *uc = unicode();
     if ( !uc )
         return 0;
     int len = str.length();
     int n = length();
     while ( n-- ) {                             // counts overlapping strings
         // ### Doesn't account for length of this - searches over "end"
         if ( cs ) {
             if ( ucstrncmp( uc, str.unicode(), len ) == 0 )
                 count++;
         } else {
             if ( ucstrnicmp(uc, str.unicode(), len) == 0 )
                 count++;
         }
         uc++;
     }
     return count;
 }

int QString::contains ( const QRegExp & rx ) const

Counts the number of overlapping occurrences of rx in the string.

QString s = "banana and panama";
QRegExp r = QRegExp("a[nm]a", TRUE, FALSE);
s.contains( r );                              // 4 matches

See also: find() findRev()

Definition at line 13759 of file qstring.cpp.

 {
     if ( isEmpty() )
         return rx.match( data() ) < 0 ? 0 : 1;
     int count = 0;
     int index = -1;
     int len = length();
     while ( index < len-1 ) {                   // count overlapping matches
         index = rx.match( data(), index+1 );
         if ( index < 0 )
             break;
         count++;
     }
     return count;
 }

QString QString::copy ( ) const

inline

Returns a deep copy of this string.

Doing this is redundant in Qt 2.x, since QString is implicitly shared, and so will automatically be deeply copied as necessary.

Definition at line 685 of file qstring.h.

686 { return QString( *this ); }

QString()

Definition: qstring.h:652

const char * QString::data ( ) const

inline

Returns a pointer to a 0-terminated classic C string.

In Qt 1.x, this returned a char* allowing direct manipulation of the string as a sequence of bytes. In Qt 2.x where QString is a Unicode string, char* conversion constructs a temporary string, and hence direct character operations are meaningless.

Definition at line 542 of file qstring.h.

542 { return latin1(); }

QString::latin1

const char * latin1() const

Definition: qstring.cpp:14457

void QString::deref ( )

private

Definition at line 12373 of file qstring.cpp.

 {
     if ( d->deref() ) {
         if ( d == shared_null )
             shared_null = 0;
         delete d;
         d = 0; // helps debugging
     }
 }

void QString::fill	(	QChar	c,
		int	len = `-1`
	)

Fills the string with len characters of value c.

If len is negative, the current string length is used.

Definition at line 12865 of file qstring.cpp.

 {
     if ( len < 0 )
         len = length();
     if ( len == 0 ) {
         *this = "";
     } else {
         deref();
         QChar * nd = QT_ALLOC_QCHAR_VEC( len );
         d = new QStringData(nd,len,len);
         while (len--) *nd++ = c;
     }
 }

int QString::find	(	QChar	c,
		int	index = `0`,
		bool	cs = `TRUE`
	)		const

Finds the first occurrence of the character c, starting at position index. If index is -1, the search starts at the last character; if -2, at the next to last character; etc.

The search is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

Returns the position of c, or -1 if c could not be found.

Definition at line 12902 of file qstring.cpp.

 {
     if ( index < 0 )
         index += length();
     if ( (uint)index >= length() )              // index outside string
         return -1;
     register const QChar *uc;
     uc = unicode()+index;
     int n = length()-index;
     if ( cs ) {
         while ( n-- && *uc != c )
             uc++;
     } else {
         c = c.lower();
         while ( n-- && uc->lower() != c )
             uc++;
     }
     if ( uint(uc - unicode()) >= length() )
         return -1;
     return (int)(uc - unicode());
 }

int QString::find	(	char	c,
		int	index = `0`,
		bool	cs = `TRUE`
	)		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 733 of file qstring.h.

734 { return find(QChar(c), index, cs); }

The QChar class provides a light-weight Unicode character.

Definition: qstring.h:56

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString::find

int find(QChar c, int index=0, bool cs=TRUE) const

Definition: qstring.cpp:12902

index

Definition: ValidateOpDetReco.py:379

cs

const char * cs

Definition: qtextcodec.cpp:1350

int QString::find	(	const QString &	str,
		int	index = `0`,
		bool	cs = `TRUE`
	)		const

Finds the first occurrence of the string str, starting at position index. If index is -1, the search starts at the last character; if -2, at the next to last character; etc.

The search is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

Returns the position of str, or -1 if str could not be found.

Definition at line 12935 of file qstring.cpp.

 {
     /*
       We use some weird hashing for efficiency's sake.  Instead of
       comparing strings, we compare the hash value of str with that of
       a part of this QString.  Only if that matches, we call ucstrncmp
       or ucstrnicmp.
 
       The hash value of a string is the sum of the cells of its
       QChars.
     */
     if ( index < 0 )
         index += length();
     int lstr = str.length();
     int lthis = length() - index;
     if ( (uint)lthis > length() )
         return -1;
     int delta = lthis - lstr;
     if ( delta < 0 )
         return -1;
 
     const QChar *uthis = unicode() + index;
     const QChar *ustr = str.unicode();
     uint hthis = 0;
     uint hstr = 0;
     int i;
     if ( cs ) {
         for ( i = 0; i < lstr; i++ ) {
             hthis += uthis[i].cell();
             hstr += ustr[i].cell();
         }
         i = 0;
         while ( TRUE ) {
             if ( hthis == hstr && ucstrncmp(uthis + i, ustr, lstr) == 0 )
                 return index + i;
             if ( i == delta )
                 return -1;
             hthis += uthis[i + lstr].cell();
             hthis -= uthis[i].cell();
             i++;
         }
     } else {
         for ( i = 0; i < lstr; i++ ) {
             hthis += uthis[i].lower().cell();
             hstr += ustr[i].lower().cell();
         }
         i = 0;
         while ( TRUE ) {
             if ( hthis == hstr && ucstrnicmp(uthis + i, ustr, lstr) == 0 )
                 return index + i;
             if ( i == delta )
                 return -1;
             hthis += uthis[i + lstr].lower().cell();
             hthis -= uthis[i].lower().cell();
             i++;
         }
     }
 #if defined(Q_SPURIOUS_NON_VOID_WARNING)
     return -1;
 #endif
 }

int QString::find	(	const QRegExp &	rx,
		int	index = `0`
	)		const

Finds the first occurrence of the regular expression rx, starting at position index. If index is -1, the search starts at the last character; if -2, at the next to last character; etc.

Returns the position of the next match, or -1 if rx was not found.

See also: findRev() replace() contains()

Definition at line 13713 of file qstring.cpp.

 {
     if ( index < 0 )
         index += length();
     return rx.match( data(), index );
 }

int QString::find	(	const char *	str,
		int	index = `0`
	)		const

inline

Equivalent to find(QString(str), index).

Definition at line 741 of file qstring.h.

742 { return find(QString::fromLatin1(str), index); }

QString::fromLatin1

static QString fromLatin1(const char *, int len=-1)

Definition: qstring.cpp:14539

QString::find

int find(QChar c, int index=0, bool cs=TRUE) const

Definition: qstring.cpp:12902

index

Definition: ValidateOpDetReco.py:379

str

static QCString str

Definition: fortrancode.cpp:27098

bool QString::findArg	(	int &	pos,
		int &	len
	)		const

private

Just 1-digit arguments.

Definition at line 12674 of file qstring.cpp.

 {
     char lowest=0;
     for (uint i=0; i<length(); i++) {
         if ( at(i) == '%' && i+1<length() ) {
             char dig = at(i+1);
             if ( dig >= '0' && dig <= '9' ) {
                 if ( !lowest || dig < lowest ) {
                     lowest = dig;
                     pos = i;
                     len = 2;
                 }
             }
         }
     }
     return lowest != 0;
 }

int QString::findRev	(	QChar	c,
		int	index = `-1`,
		bool	cs = `TRUE`
	)		const

Finds the first occurrence of the character c, starting at position index and searching backwards. If index is -1, the search starts at the last character; if -2, at the next to last character; etc.

The search is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

Returns the position of c, or -1 if c could not be found.

Definition at line 13021 of file qstring.cpp.

 {
     QString t( c );
     return findRev( t, index, cs );
 }

int QString::findRev	(	char	c,
		int	index = `-1`,
		bool	cs = `TRUE`
	)		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 736 of file qstring.h.

737 { return findRev( QChar(c), index, cs ); }

The QChar class provides a light-weight Unicode character.

Definition: qstring.h:56

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString::findRev

int findRev(QChar c, int index=-1, bool cs=TRUE) const

Definition: qstring.cpp:13021

index

Definition: ValidateOpDetReco.py:379

cs

const char * cs

Definition: qtextcodec.cpp:1350

int QString::findRev	(	const QString &	str,
		int	index = `-1`,
		bool	cs = `TRUE`
	)		const

Finds the first occurrence of the string str, starting at position index and searching backwards. If index is -1, the search starts at the last character; -2, at the next to last character; etc.

The search is case sensitive if cs is TRUE, or case insensitive if cs is FALSE.

Returns the position of str, or -1 if str could not be found.

Definition at line 13039 of file qstring.cpp.

 {
     /*
       See QString::find() for explanations.
     */
     int lthis = length();
     if ( index < 0 )
         index += lthis;
 
     int lstr = str.length();
     int delta = lthis - lstr;
     if ( index < 0 || index > lthis || delta < 0 )
         return -1;
     if ( index > delta )
         index = delta;
 
     const QChar *uthis = unicode();
     const QChar *ustr = str.unicode();
     uint hthis = 0;
     uint hstr = 0;
     int i;
     if ( cs ) {
         for ( i = 0; i < lstr; i++ ) {
             hthis += uthis[index + i].cell();
             hstr += ustr[i].cell();
         }
         i = index;
         while ( TRUE ) {
             if ( hthis == hstr && ucstrncmp(uthis + i, ustr, lstr) == 0 )
                 return i;
             if ( i == 0 )
                 return -1;
             i--;
             hthis -= uthis[i + lstr].cell();
             hthis += uthis[i].cell();
         }
     } else {
         for ( i = 0; i < lstr; i++ ) {
             hthis += uthis[index + i].lower().cell();
             hstr += ustr[i].lower().cell();
         }
         i = index;
         while ( TRUE ) {
             if ( hthis == hstr && ucstrnicmp(uthis + i, ustr, lstr) == 0 )
                 return i;
             if ( i == 0 )
                 return -1;
             i--;
             hthis -= uthis[i + lstr].lower().cell();
             hthis += uthis[i].lower().cell();
         }
     }
 #if defined(Q_SPURIOUS_NON_VOID_WARNING)
     return -1;
 #endif
 }

int QString::findRev	(	const QRegExp &	rx,
		int	index = `-1`
	)		const

Finds the first occurrence of the regular expression rx, starting at position index and searching backwards. If index is -1, the search starts at the last character; if -2, at the next to last character; etc.

Returns the position of the next match (backwards), or -1 if rx was not found.

See also: find()

Definition at line 13732 of file qstring.cpp.

 {
     if ( index < 0 )                            // neg index ==> start from end
         index += length();
     if ( (uint)index > length() )               // bad index
         return -1;
     while( index >= 0 ) {
         if ( rx.match( data(), index ) == index )
             return index;
         index--;
     }
     return -1;
 }

int QString::findRev	(	const char *	str,
		int	index = `-1`
	)		const

inline

Equivalent to findRev(QString(str), index).

Definition at line 744 of file qstring.h.

745 { return findRev(QString::fromLatin1(str), index); }

QString::fromLatin1

static QString fromLatin1(const char *, int len=-1)

Definition: qstring.cpp:14539

QString::findRev

int findRev(QChar c, int index=-1, bool cs=TRUE) const

Definition: qstring.cpp:13021

index

Definition: ValidateOpDetReco.py:379

str

static QCString str

Definition: fortrancode.cpp:27098

QString QString::fromLatin1	(	const char *	chars,
		int	len = `-1`
	)

static

Creates a QString from Latin1 text. This is the same as the QString(const char*) constructor, but you can make that constructor invisible if you compile with the define QT_NO_CAST_ASCII, in which case you can explicitly create a QString from Latin-1 text using this function.

Definition at line 14539 of file qstring.cpp.

 {
     uint l;
     QChar *uc;
     if ( len < 0 ) {
         uc = internalAsciiToUnicode(chars,&l);
     } else {
         uc = internalAsciiToUnicode(chars,&l,len);
     }
     return QString(new QStringData(uc,l,l), TRUE);
 }

QString QString::fromLocal8Bit	(	const char *	local8Bit,
		int	len = `-1`
	)

static

Returns the unicode string decoded from the first len bytes of local8Bit. If len is -1 (the default), the length of local8Bit is used. If trailing partial characters are in local8Bit, they are ignored.

local8Bit is assumed to be encoded in a locale-specific format.

See QTextCodec for more diverse coding/decoding of Unicode strings.

Definition at line 14605 of file qstring.cpp.

 {
 #ifdef QT_NO_TEXTCODEC
     return fromLatin1( local8Bit, len );
 #else
 
     if ( !local8Bit )
         return QString::null;
 #ifdef _WS_X11_
     static QTextCodec* codec = QTextCodec::codecForLocale();
     if ( len < 0 ) len = qstrlen(local8Bit);
     return codec
             ? codec->toUnicode(local8Bit, len)
             : QString::fromLatin1(local8Bit,len);
 #endif
 #ifdef _WS_MAC_
     static QTextCodec* codec = QTextCodec::codecForLocale();
     if ( len < 0 ) len = qstrlen(local8Bit);
     return codec
             ? codec->toUnicode(local8Bit, len)
             : QString::fromLatin1(local8Bit,len);
 #endif
 // Should this be OS_WIN32?
 #ifdef _WS_WIN_
     if ( len >= 0 ) {
         QCString s(local8Bit,len+1);
         return qt_winMB2QString(s);
     }
     return qt_winMB2QString( local8Bit );
 #endif
 #ifdef _WS_QWS_
     return fromUtf8(local8Bit,len);
 #endif
 #endif // QT_NO_TEXTCODEC
 }

QString QString::fromUcs2 ( const unsigned short * str )

static

Constructs a string that is a deep copy of str, interpreted as a UCS2 encoded, zero terminated, Unicode string.

If str is 0, then a null string is created.

See also: isNull()

Definition at line 12119 of file qstring.cpp.

 {
   if ( !str ) {
     return QString::null;
   } else {
     int length = 0;
     while ( str[length] != 0 )
       length++;
     QChar* uc = QT_ALLOC_QCHAR_VEC( length );
     memcpy( uc, str, length*sizeof(QChar) );
     return QString( new QStringData( uc, length, length ), TRUE );
   }
 }

QString QString::fromUtf8	(	const char *	utf8,
		int	len = `-1`
	)

static

Returns the unicode string decoded from the first len bytes of utf8. If len is -1 (the default), the length of utf8 is used. If trailing partial characters are in utf8, they are ignored.

See QTextCodec for more diverse coding/decoding of Unicode strings.

Definition at line 14523 of file qstring.cpp.

 {
     static QTextCodec* codec = QTextCodec::codecForMib(106);
     if ( len < 0 ) len = qstrlen(utf8);
     return codec
             ? codec->toUnicode(utf8, len)
             : QString::fromLatin1(utf8, len);
 }

QString & QString::insert	(	uint	index,
		const QString &	s
	)

Insert s into the string before position index.

If index is beyond the end of the string, the string is extended with spaces (ASCII 32) to length index and s is then appended.

QString s = "I like fish";
s.insert( 2, "don't ");       // s == "I don't like fish"
s = "x";
s.insert( 3, "yz" );  // s == "x  yz"

Definition at line 13523 of file qstring.cpp.

 {
     // the sub function takes care of &s == this case.
     return insert( index, s.unicode(), s.length() );
 }

QString & QString::insert	(	uint	index,
		const QChar *	s,
		uint	len
	)

Insert len units of QChar data from s into the string before position index.

Definition at line 13534 of file qstring.cpp.

 {
     if ( len == 0 )
         return *this;
     uint olen = length();
     int nlen = olen + len;
 
     int df = (int)(s - d->unicode); // ### pointer subtraction, cast down to int
     if ( df >= 0 && (uint)df < d->maxl ) {
         // Part of me - take a copy.
         QChar *tmp = QT_ALLOC_QCHAR_VEC( len );
         memcpy(tmp,s,len*sizeof(QChar));
         insert(index,tmp,len);
         QT_DELETE_QCHAR_VEC( tmp );
         return *this;
     }
 
     if ( index >= olen ) {                      // insert after end of string
         setLength( len+index );
         int n = index-olen;
         QChar* uc = d->unicode+olen;
         while (n--)
             *uc++ = ' ';
         memcpy( d->unicode+index, s, sizeof(QChar)*len );
     } else {                                    // normal insert
         setLength( nlen );
         memmove( d->unicode+index+len, unicode()+index,
                  sizeof(QChar)*(olen-index) );
         memcpy( d->unicode+index, s, sizeof(QChar)*len );
     }
     return *this;
 }

QString & QString::insert	(	uint	index,
		QChar	c
	)

Insert c into the string at (before) position index and returns a reference to the string.

If index is beyond the end of the string, the string is extended with spaces (ASCII 32) to length index and c is then appended.

QString s = "Ys";
s.insert( 1, 'e' );           // s == "Yes"
s.insert( 3, '!');            // s == "Yes!"

See also: remove(), replace()

Definition at line 13584 of file qstring.cpp.

 {
     QString s( c );
     return insert( index, s );
 }

QString & QString::insert	(	uint	index,
		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.

Definition at line 448 of file qstring.h.

448 { return insert(index,QChar(c)); }

The QChar class provides a light-weight Unicode character.

Definition: qstring.h:56

dictionary c

Definition: ValidateOpDetSimulation.py:57

index

Definition: ValidateOpDetReco.py:379

QString & insert(uint index, const QString &)

Definition: qstring.cpp:13523

bool QString::isEmpty ( ) const

inline

Returns TRUE if the string is empty, i.e. if length() == 0. An empty string is not always a null string.

See example in isNull().

See also: isNull(), length()

Definition at line 682 of file qstring.h.

683 { return length() == 0; }

QString::length

uint length() const

Definition: qstring.h:679

bool QString::isNull ( ) const

inline

Returns TRUE if the string is null. A null string is also an empty string.

QString a;            // a.unicode() == 0,  a.length() == 0
QString b = "";       // b.unicode() == "", b.length() == 0
a.isNull();           // TRUE, because a.unicode() == 0
a.isEmpty();  // TRUE, because a.length() == 0
b.isNull();           // FALSE, because b.unicode() != 0
b.isEmpty();  // TRUE, because b.length() == 0

See also: isEmpty(), length()

Definition at line 379 of file qstring.h.

379 { return d == shared_null; }

QStringData * d

Definition: qstring.h:560

QString::shared_null

static QStringData * shared_null

Definition: qstring.h:561

const char * QString::latin1 ( ) const

Returns a Latin-1 representation of the string. Note that the returned value is undefined if the string contains non-Latin-1 characters. If you want to convert strings into formats other than Unicode, see the QTextCodec classes.

This function is mainly useful for boot-strapping legacy code to use Unicode.

The result remains valid so long as one unmodified copy of the source string exists.

See also: utf8(), local8Bit()

Definition at line 14457 of file qstring.cpp.

 {
     if ( d->ascii ) {
         if ( d->dirtyascii )
             delete [] d->ascii;
         else
             return d->ascii;
     }
     Q2HELPER(stat_get_ascii++)
     Q2HELPER(stat_get_ascii_size+=d->len)
     static QTextCodec* codec = QTextCodec::codecForMib(106);
     if (codec) // we use utf8 coding also for latin1 if possible
     {
       QCString utf8str(codec->fromUnicode(*this));
       d->ascii = new char[utf8str.length()+1];
       if (utf8str.isEmpty())
       {
         d->ascii[0]='\0'; // make empty string
       }
       else // copy string
       {
         qstrcpy(d->ascii,utf8str.data());
       }
     }
     else // fall back to latin1
     {
       d->ascii = unicodeToAscii( d->unicode, d->len );
     }
     QCString utf8str(utf8());
     d->dirtyascii = 0;
     return d->ascii;
 }

QString QString::left ( uint len ) const

Returns a substring that contains the len leftmost characters of the string.

The whole string is returned if len exceeds the length of the string.

QString s = "Pineapple";

QString t = s.left( 4 ); // t == "Pine"

See also: right(), mid(), isEmpty()

Definition at line 13199 of file qstring.cpp.

 {
     if ( isEmpty() ) {
         return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
         return QString::fromLatin1("");
     } else if ( len > length() ) {
         return *this;
     } else {
         QString s( len, TRUE );
         memcpy( s.d->unicode, d->unicode, len*sizeof(QChar) );
         s.d->len = len;
         return s;
     }
 }

QString QString::leftJustify	(	uint	width,
		QChar	fill = `' '`,
		bool	truncate = `FALSE`
	)		const

Returns a string of length width that contains this string and padded by the fill character.

If the length of the string exceeds width and truncate is FALSE, then the returned string is a copy of the string. If the length of the string exceeds width and truncate is TRUE, then the returned string is a left(width).

QString s("apple");

QString t = s.leftJustify(8, '.'); // t == "apple..."

See also: rightJustify()

Definition at line 13303 of file qstring.cpp.

 {
     QString result;
     int len = length();
     int padlen = width - len;
     if ( padlen > 0 ) {
         result.setLength(len+padlen);
         if ( len )
             memcpy( result.d->unicode, unicode(), sizeof(QChar)*len );
         QChar* uc = result.d->unicode + len;
         while (padlen--)
             *uc++ = fill;
     } else {
         if ( truncate )
             result = left( width );
         else
             result = *this;
     }
     return result;
 }

uint QString::length ( ) const

inline

Returns the length of the string.

Null strings and empty strings have zero length.

See also: isNull(), isEmpty()

Definition at line 679 of file qstring.h.

680 { return d->len; }

QStringData::len

uint len

Definition: qstring.h:344

QStringData * d

Definition: qstring.h:560

QCString QString::local8Bit ( ) const

Returns the string encoded in a locale-specific format. On X11, this is the QTextCodec::codecForLocale(). On Windows, it is a system-defined encoding.

See QTextCodec for more diverse coding/decoding of Unicode strings.

See also: QString::fromLocal8Bit(), latin1(), utf8()

Definition at line 14569 of file qstring.cpp.

 {
 #ifdef QT_NO_TEXTCODEC
     return latin1();
 #else
 #ifdef _WS_X11_
     static QTextCodec* codec = QTextCodec::codecForLocale();
     return codec
             ? codec->fromUnicode(*this)
             : QCString(latin1());
 #endif
 #ifdef _WS_MAC_
     static QTextCodec* codec = QTextCodec::codecForLocale();
     return codec
             ? codec->fromUnicode(*this)
             : QCString(latin1());
 #endif
 #ifdef _WS_WIN_
     return qt_winQString2MB( *this );
 #endif
 #ifdef _WS_QWS_
     return utf8(); // ##### if there is ANY 8 bit format supported?
 #endif
 #endif
 }

QString QString::lower ( ) const

Returns a new string that is the string converted to lower case.

QString s("TeX");

QString t = s.lower(); // t == "tex"

See also: upper()

Definition at line 13375 of file qstring.cpp.

 {
     QString s(*this);
     int l=length();
     if ( l ) {
         s.real_detach(); // could do this only when we find a change
         register QChar *p=s.d->unicode;
         if ( p ) {
             while ( l-- ) {
                 *p = p->lower();
                 p++;
             }
         }
     }
     return s;
 }

QStringData * QString::makeSharedNull ( )

staticprivate

Definition at line 12190 of file qstring.cpp.

 {
     return shared_null=new QStringData;
 }

QString QString::mid	(	uint	index,
		uint	len = `0xffffffff`
	)		const

Returns a substring that contains the len characters of this string, starting at position index.

Returns a null string if the string is empty or index is out of range. Returns the whole string from index if index+len exceeds the length of the string.

QString s = "Five pineapples";

QString t = s.mid( 5, 4 ); // t == "pine"

See also: left(), right()

Definition at line 13265 of file qstring.cpp.

 {
     uint slen = length();
     if ( isEmpty() || index >= slen ) {
         return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
         return QString::fromLatin1("");
     } else {
         if ( len > slen-index )
             len = slen - index;
         if ( index == 0 && len == length() )
             return *this;
         register const QChar *p = unicode()+index;
         QString s( len, TRUE );
         memcpy( s.d->unicode, p, len*sizeof(QChar) );
         s.d->len = len;
         return s;
     }
 }

QString QString::number	(	long	n,
		int	base = `10`
	)

static

A convenience factory function that returns a string representation of the number n.

See also: setNum()

Definition at line 14249 of file qstring.cpp.

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

QString QString::number	(	ulong	n,
		int	base = `10`
	)

static

A convenience factory function that returns a string representation of the number n.

See also: setNum()

Definition at line 14262 of file qstring.cpp.

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

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

static

A convenience factory function that returns a string representation of the number n.

See also: setNum()

Definition at line 14275 of file qstring.cpp.

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

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

static

A convenience factory function that returns a string representation of the number n.

See also: setNum()

Definition at line 14288 of file qstring.cpp.

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

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

static

This static function returns the printed value of n, formatted in the f format with prec precision.

f can be 'f', 'F', 'e', 'E', 'g' or 'G', all of which have the same meaning as for sprintf().

See also: setNum()

Definition at line 14304 of file qstring.cpp.

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

bool QString::operator! ( ) const

inline

Returns TRUE if it is a null string, otherwise FALSE. Thus you can write:

QString name = getName();
if ( !name )
  name = "Rodney";

Note that if you say:

QString name = getName();
if ( name )
  doSomethingWith(name);

Then this will call operator const char*(), which will do what you want, but rather inefficiently - you may wish to define the macro QT_NO_ASCII_CAST when writing code which you wish to strictly remain Unicode-clean.

When you want the above semantics, use !isNull() or even !!:

QString name = getName();
if ( !!name )
  doSomethingWith(name);

Definition at line 676 of file qstring.h.

677 { return isNull(); }

QString::isNull

bool isNull() const

Definition: qstring.h:379

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

Appends str to the string and returns a reference to the string.

Definition at line 14399 of file qstring.cpp.

 {
     uint len1 = length();
     uint len2 = str.length();
     if ( len2 ) {
         setLength(len1+len2);
         memcpy( d->unicode+len1, str.unicode(), sizeof(QChar)*len2 );
     } else if ( isNull() && !str.isNull() ) {   // ## just for 1.x compat:
         *this = fromLatin1("");
     }
     return *this;
 }

QString & QString::operator+= ( QChar c )

Appends c to the string and returns a reference to the string.

Definition at line 14416 of file qstring.cpp.

 {
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }

QString & QString::operator+= ( char c )

Appends c to the string and returns a reference to the string.

Definition at line 14427 of file qstring.cpp.

 {
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }

QString & QString::operator= ( const QString & s )

Assigns a shallow copy of s to this string and returns a reference to this string.

Definition at line 12402 of file qstring.cpp.

 {
     Q2HELPER(stat_fast_copy++)
     s.d->ref();
     deref();
     d = s.d;
     return *this;
 }

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

Assigns a deep copy of str, interpreted as a classic C string, to this string and returns a reference to this string.

If str is 0 a null string is created.

See also: isNull()

Definition at line 12429 of file qstring.cpp.

 {
     return setLatin1(str);
 }

QString & QString::operator= ( const QCString & cs )

Assigns a deep copy of cs, interpreted as a classic C string, to this string and returns a reference to this string.

Definition at line 12415 of file qstring.cpp.

 {
     return setLatin1(cs);
 }

QString & QString::operator= ( QChar c )

inline

Sets the string to contain just the single character c.

Definition at line 667 of file qstring.h.

668 { return *this = QString(c); }

QString()

Definition: qstring.h:652

QString & QString::operator= ( char c )

inline

Sets the string to contain just the single character c.

Definition at line 670 of file qstring.h.

671 { return *this = QString(QChar(c)); }

The QChar class provides a light-weight Unicode character.

Definition: qstring.h:56

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString()

Definition: qstring.h:652

QString& QString::operator= ( const Null & )

inline

Definition at line 378 of file qstring.h.

378 { *this = QString(); return *this; }

QString()

Definition: qstring.h:652

QChar QString::operator[] ( int i ) const

inline

Returns the character at i, or QChar::null if i is beyond the length of the string.

Note: If this QString is not const or const&, the non-const operator[] will be used instead, which will expand the string if i is beyond the length of the string.

Definition at line 494 of file qstring.h.

494 { return at((uint)i); }

QString::at

QChar at(uint i) const

Definition: qstring.h:492

uint

unsigned uint

Definition: qglobal.h:351

QCharRef QString::operator[] ( int i )

inline

Returns an object that references the character at i. This reference can then be assigned to, or otherwise used immediately, but becomes invalid once further modifications are made to the string. The QCharRef internal class can be used much like a constant QChar, but if you assign to it, you change the original string (which enlarges and detaches itself). You will get compilation errors if you try to use the result as anything but a QChar.

Definition at line 624 of file qstring.h.

624 { return at((uint)i); }

QString::at

QChar at(uint i) const

Definition: qstring.h:492

uint

unsigned uint

Definition: qglobal.h:351

QString & QString::prepend ( char ch )

inline

Prepends ch to the string and returns a reference to the result.

See also: insert()

Definition at line 694 of file qstring.h.

695 { return insert(0,c); }

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString & insert(uint index, const QString &)

Definition: qstring.cpp:13523

QString & QString::prepend ( QChar ch )

inline

Prepends ch to the string and returns a reference to the result.

See also: insert()

Definition at line 691 of file qstring.h.

692 { return insert(0,c); }

dictionary c

Definition: ValidateOpDetSimulation.py:57

QString & insert(uint index, const QString &)

Definition: qstring.cpp:13523

QString & QString::prepend ( const QString & s )

inline

Prepend s to the string. Equivalent to insert(0,s).

See also: insert()

Definition at line 688 of file qstring.h.

689 { return insert(0,s); }

QString & insert(uint index, const QString &)

Definition: qstring.cpp:13523

void QString::real_detach ( )

private

Deallocates any space reserved solely by this QString.

Definition at line 12368 of file qstring.cpp.

 {
     setLength( length() );
 }

QChar & QString::ref ( uint i )

inline

Returns the QChar at i by reference.

See also: constref()

Definition at line 500 of file qstring.h.

         { // Optimized for easy-inlining by simple compilers.
             if (d->count!=1 || i>=d->len)
                 subat(i);
             d->dirtyascii=1;
             return d->unicode[i];
         }

QString & QString::remove	(	uint	index,
		uint	len
	)

Removes len characters starting at position index from the string and returns a reference to the string.

If index is too big, nothing happens. If index is valid, but len is too large, the rest of the string is removed.

QString s = "Montreal";
s.remove( 1, 4 );
// s == "Meal"

See also: insert(), replace()

Definition at line 13633 of file qstring.cpp.

 {
     uint olen = length();
     if ( index + len >= olen ) {                // range problems
         if ( index < olen ) {                   // index ok
             setLength( index );
         }
     } else if ( len != 0 ) {
         real_detach();
         memmove( d->unicode+index, d->unicode+index+len,
                  sizeof(QChar)*(olen-index-len) );
         setLength( olen-len );
     }
     return *this;
 }

QString & QString::replace	(	uint	index,
		uint	len,
		const QString &	s
	)

Replaces len characters starting at position index from the string with s, and returns a reference to the string.

If index is too big, nothing is deleted and s is inserted at the end of the string. If index is valid, but len is too large, str replaces the rest of the string.

QString s = "Say yes!";

s.replace( 4, 3, "NO" ); // s == "Say NO!"

See also: insert(), remove()

Definition at line 13665 of file qstring.cpp.

 {
     return replace( index, len, s.unicode(), s.length() );
 }

QString & QString::replace	(	uint	index,
		uint	len,
		const QChar *	s,
		uint	slen
	)

Replaces len characters starting at position index by slen units ot QChar data from s, and returns a reference to the string.

See also: insert(), remove()

Definition at line 13678 of file qstring.cpp.

 {
     if ( len == slen && index + len <= length() ) {
         // Optimized common case: replace without size change
         real_detach();
         memcpy( d->unicode+index, s, len*sizeof(QChar) );
     } else {
         int df = (int)(s - d->unicode); // ### pointer subtraction, cast down to int
         if ( df >= 0 && (uint)df < d->maxl ) {
             // Part of me - take a copy.
             QChar *tmp = QT_ALLOC_QCHAR_VEC( slen );
             memcpy(tmp,s,slen*sizeof(QChar));
             replace(index,len,tmp,slen);
             QT_DELETE_QCHAR_VEC( tmp );
             return *this;
         }
 
         remove( index, len );
         insert( index, s, slen );
     }
     return *this;
 }

QString & QString::replace	(	const QRegExp &	rx,
		const QString &	str
	)

Replaces every occurrence of rx in the string with str. Returns a reference to the string.

Examples:

QString s = "banana";
s.replace( QRegExp("a.*a"), "" );             // becomes "b"
QString s = "banana";
s.replace( QRegExp("^[bn]a"), " " );  // becomes " nana"
QString s = "banana";
s.replace( QRegExp("^[bn]a"), "" );           // NOTE! becomes ""

See also: find() findRev()

Definition at line 13795 of file qstring.cpp.

 {
     if ( isEmpty() )
         return *this;
     int index = 0;
     int slen  = str.length();
     int len;
     while ( index < (int)length() ) {
         index = rx.match( data(), index, &len, FALSE );
         if ( index >= 0 ) {
             replace( index, len, str );
             index += slen;
             if ( !len )
                 break;  // Avoid infinite loop on 0-length matches, e.g. [a-z]*
         }
         else
             break;
     }
     return *this;
 }

QString QString::right ( uint len ) const

Returns a substring that contains the len rightmost characters of the string.

The whole string is returned if len exceeds the length of the string.

QString s = "Pineapple";

QString t = s.right( 5 ); // t == "apple"

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

Definition at line 13231 of file qstring.cpp.

 {
     if ( isEmpty() ) {
         return QString();
     } else if ( len == 0 ) {                    // ## just for 1.x compat:
         return QString::fromLatin1("");
     } else {
         uint l = length();
         if ( len > l )
             len = l;
         QString s( len, TRUE );
         memcpy( s.d->unicode, d->unicode+(l-len), len*sizeof(QChar) );
         s.d->len = len;
         return s;
     }
 }

QString QString::rightJustify	(	uint	width,
		QChar	fill = `' '`,
		bool	truncate = `FALSE`
	)		const

Returns a string of length width that contains pad characters followed by the string.

If the length of the string exceeds width and truncate is FALSE, then the returned string is a copy of the string. If the length of the string exceeds width and truncate is TRUE, then the returned string is a left(width).

QString s("pie");

QString t = s.rightJustify(8, '.'); // t == ".....pie"

See also: leftJustify()

Definition at line 13342 of file qstring.cpp.

 {
     QString result;
     int len = length();
     int padlen = width - len;
     if ( padlen > 0 ) {
         result.setLength( len+padlen );
         QChar* uc = result.d->unicode;
         while (padlen--)
             *uc++ = fill;
         if ( len )
             memcpy( uc, unicode(), sizeof(QChar)*len );
     } else {
         if ( truncate )
             result = left( width );
         else
             result = *this;
     }
     return result;
 }

void QString::setExpand	(	uint	index,
		QChar	c
	)

Sets the character at position index to c and expands the string if necessary, filling with spaces.

This method is redundant in Qt 2.x, because operator[] will expand the string as necessary.

Definition at line 14321 of file qstring.cpp.

 {
     int spaces = index - d->len;
     at(index) = c;
     while (spaces-->0)
         d->unicode[--index]=' ';
 }

QString & QString::setLatin1	(	const char *	str,
		int	len = `-1`
	)

Sets this string to str, interpreted as a classic Latin 1 C string. If the len argument is negative (default), it is set to strlen(str).

If str is 0 a null string is created. If str is "" an empty string is created.

See also: isNull(), isEmpty()

Definition at line 14804 of file qstring.cpp.

 {
     if ( str == 0 )
         return setUnicode(0,0);
     if ( len < 0 )
         len = qstrlen(str);
     if ( len == 0 ) {                           // won't make a null string
         deref();
         uint l;
         QChar *uc = internalAsciiToUnicode(str,&l);
         d = new QStringData(uc,l,l);
     } else {
         setUnicode( 0, len );                   // resize but not copy
         QChar *p = d->unicode;
         while ( len-- )
             *p++ = *str++;
     }
     return *this;
 }

void QString::setLength ( uint pos )

private

Definition at line 12508 of file qstring.cpp.

 {
     if ( d->count != 1 || newLen > d->maxl ||           // detach, grow, or
          ( newLen*4 < d->maxl && d->maxl > 4 ) ) {      // shrink
         Q2HELPER(stat_copy_on_write++)
         Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = 4;
         while ( newMax < newLen )
             newMax *= 2;
         QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
         uint len = QMIN( d->len, newLen );
         if ( d->unicode )
             memcpy( nd, d->unicode, sizeof(QChar)*len );
         deref();
         d = new QStringData( nd, newLen, newMax );
     } else {
         d->len = newLen;
         d->dirtyascii = 1;
     }
 }

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

inline

Sets the string to the printed value of n and returns a reference to the string.

Definition at line 706 of file qstring.h.

707 { return setNum((long)n, base); }

Definition: value_ptr_test_4.cc:5

QString & setNum(short, int base=10)

Definition: qstring.h:706

std::void_t< T > n

Definition: metaprogramming.h:28

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

inline

Sets the string to the printed unsigned value of n and returns a reference to the string.

Definition at line 709 of file qstring.h.

710 { return setNum((ulong)n, base); }

Definition: value_ptr_test_4.cc:5

QString & setNum(short, int base=10)

Definition: qstring.h:706

std::void_t< T > n

Definition: metaprogramming.h:28

unsigned long ulong

Definition: qglobal.h:352

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

inline

Sets the string to the printed value of n and returns a reference to the string.

Definition at line 712 of file qstring.h.

713 { return setNum((long)n, base); }

Definition: value_ptr_test_4.cc:5

QString & setNum(short, int base=10)

Definition: qstring.h:706

std::void_t< T > n

Definition: metaprogramming.h:28

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

inline

Sets the string to the printed unsigned value of n and returns a reference to the string.

Definition at line 715 of file qstring.h.

716 { return setNum((ulong)n, base); }

Definition: value_ptr_test_4.cc:5

QString & setNum(short, int base=10)

Definition: qstring.h:706

std::void_t< T > n

Definition: metaprogramming.h:28

unsigned long ulong

Definition: qglobal.h:352

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

Sets the string to the printed value of n and returns a reference to the string.

The value is converted to base notation (default is decimal). The base must be a value from 2 to 36.

Definition at line 14109 of file qstring.cpp.

 {
 #if defined(CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
         qWarning( "QString::setNum: Invalid base %d", base );
         base = 10;
     }
 #endif
     char   charbuf[65*sizeof(QChar)];
     QChar *buf = (QChar*)charbuf;
     QChar *p = &buf[64];
     int  len = 0;
     bool neg;
     if ( n < 0 ) {
         neg = TRUE;
         if ( n == INT_MIN ) {
             // Cannot always negate this special case
             QString s1, s2;
             s1.setNum(n/base);
             s2.setNum((-(n+base))%base);
             *this = s1 + s2;
             return *this;
         }
         n = -n;
     } else {
         neg = FALSE;
     }
     do {
         *--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
         n /= base;
         len++;
     } while ( n );
     if ( neg ) {
         *--p = '-';
         len++;
     }
     return setUnicode( p, len );
 }

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

Sets the string to the printed unsigned value of n and returns a reference to the string.

The value is converted to base notation (default is decimal). The base must be a value from 2 to 36.

Definition at line 14156 of file qstring.cpp.

 {
 #if defined(CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
         qWarning( "QString::setNum: Invalid base %d", base );
         base = 10;
     }
 #endif
     char   charbuf[65*sizeof(QChar)];
     QChar *buf = (QChar*)charbuf;
     QChar *p = &buf[64];
     int len = 0;
     do {
         *--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
         n /= base;
         len++;
     } while ( n );
     return setUnicode(p,len);
 }

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

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 718 of file qstring.h.

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

keras_to_tensorflow.f

f

Definition: keras_to_tensorflow.py:162

QString & setNum(short, int base=10)

Definition: qstring.h:706

std::void_t< T > n

Definition: metaprogramming.h:28

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

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

f can be 'f', 'F', 'e', 'E', 'g' or 'G', all of which have the same meaning as for sprintf().

Definition at line 14208 of file qstring.cpp.

 {
 #if defined(CHECK_RANGE)
     if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') ) {
         qWarning( "QString::setNum: Invalid format char '%c'", f );
         f = 'f';
     }
 #endif
     char format[20];
     char buf[120];                              // enough for 99 precision?
     char *fs = format;                          // generate format string
     *fs++ = '%';                                //   "%.<prec>l<f>"
     if ( prec >= 0 ) {
         if ( prec > 99 )                        // buf big enough for precision?
             prec = 99;
         *fs++ = '.';
         if ( prec >= 10 ) {
             *fs++ = prec / 10 + '0';
             *fs++ = prec % 10 + '0';
         } else {
             *fs++ = prec + '0';
         }
     }
     *fs++ = 'l';
     *fs++ = f;
     *fs = '\0';
     ::sprintf( buf, format, n );
     return setLatin1(buf);
 }

QString & QString::setUnicode	(	const QChar *	unicode,
		uint	len
	)

Resizes the string to len unicode characters and copies unicode into the string. If unicode is null, nothing is copied, but the string is resized to len anyway. If len is zero, the string becomes a null string.

See also: setLatin1(), isNull()

Definition at line 14736 of file qstring.cpp.

 {
     if ( len == 0 ) {                           // set to null string
         if ( d != shared_null ) {               // beware of nullstring being set to nullstring
             deref();
             d = shared_null ? shared_null : makeSharedNull();
             d->ref();
         }
     } else if ( d->count != 1 || len > d->maxl ||
          ( len*4 < d->maxl && d->maxl > 4 ) ) { // detach, grown or shrink
         Q2HELPER(stat_copy_on_write++)
         Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = 4;
         while ( newMax < len )
             newMax *= 2;
         QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
         if ( unicode )
             memcpy( nd, unicode, sizeof(QChar)*len );
         deref();
         d = new QStringData( nd, len, newMax );
     } else {
         d->len = len;
         d->dirtyascii = 1;
         if ( unicode )
             memcpy( d->unicode, unicode, sizeof(QChar)*len );
     }
     return *this;
 }

QString & QString::setUnicodeCodes	(	const ushort *	unicode_as_ushorts,
		uint	len
	)

Resizes the string to len unicode characters and copies unicode_as_ushorts into the string (on some X11 client platforms this will involve a byte-swapping pass).

If unicode is null, nothing is copied, but the string is resized to len anyway. If len is zero, the string becomes a null string.

See also: setLatin1(), isNull()

Definition at line 14776 of file qstring.cpp.

 {
     setUnicode((const QChar*)unicode_as_ushorts, len);
     QChar t(0x1234);
     if ( unicode_as_ushorts && *((ushort*)&t) == 0x3412 ) {
         // Need to byteswap
         char* b = (char*)d->unicode;
         while ( len-- ) {
             char c = b[0];
             b[0] = b[1];
             b[1] = c;
             b += sizeof(QChar);
         }
     }
     return *this;
 }

QString QString::simplifyWhiteSpace ( ) const

Returns a new string that has white space removed from the start and the end, plus any sequence of internal white space replaced with a single space (ASCII 32).

White space means any character for which QChar::isSpace() returns TRUE. This includes ASCII characters 9 (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR), and 32 (Space).

QString s = " lots\t of\nwhite space ";

QString t = s.simplifyWhiteSpace(); // t == "lots of white space"

See also: stripWhiteSpace()

Definition at line 13482 of file qstring.cpp.

 {
     if ( isEmpty() )                            // nothing to do
         return *this;
     QString result;
     result.setLength( length() );
     const QChar *from = unicode();
     const QChar *fromend = from+length();
     int outc=0;
     QChar *to   = result.d->unicode;
     while ( TRUE ) {
         while ( from!=fromend && from->isSpace() )
             from++;
         while ( from!=fromend && !from->isSpace() )
             to[outc++] = *from++;
         if ( from!=fromend )
             to[outc++] = ' ';
         else
             break;
     }
     if ( outc > 0 && to[outc-1] == ' ' )
         outc--;
     result.truncate( outc );
     return result;
 }

QString & QString::sprintf	(	const char *	cformat,
			...
	)

Safely builds a formatted string from a format string and an arbitrary list of arguments. The format string supports all the escape sequences of printf() in the standard C library.

The s escape sequence expects a utf8() encoded string. The format string cformat is expected to be in latin1. If you need a unicode format string, use QString::arg() instead. For typesafe string building, with full Unicode support, you can use QTextOStream like this:

QString str;
QString s = ...;
int x = ...;
QTextOStream(&str) << s << " : " << x;

For translations, especially if the strings contains more than one escape sequence, you should consider using the arg() function instead. This allows the order of the replacements to be controlled by the translator, and has Unicode support.

See also: arg()

Definition at line 12719 of file qstring.cpp.

 {
     va_list ap;
     va_start( ap, cformat );
 
     if ( !cformat || !*cformat ) {
         // Qt 1.x compat
         *this = QString::fromLatin1( "" );
         return *this;
     }
     QString format = QString::fromLatin1( cformat );
 
     static QRegExp *escape = 0;
     if (!escape)
         escape = new QRegExp( "%#?0?-? ?\\+?'?[0-9*]*\\.?[0-9*]*h?l?L?q?Z?" );
 
     QString result;
     uint last = 0;
 
     int len = 0;
     int pos;
     while ( 1 ) {
         pos = escape->match( cformat, last, &len );
         // Non-escaped text
         if ( pos > (int)last )
             result += format.mid(last,pos-last);
         if ( pos < 0 ) {
             // The rest
             if ( last < format.length() )
                 result += format.mid(last);
             break;
         }
         last = pos + len + 1;
 
         // Escape
         QString f = format.mid( pos, len );
         uint width, decimals;
         int params = 0;
         int wpos = f.find('*');
         if ( wpos >= 0 ) {
             params++;
             width = va_arg( ap, int );
             if ( f.find('*', wpos + 1) >= 0 ) {
                 decimals = va_arg( ap, int );
                 params++;
             } else {
                 decimals = 0;
             }
         } else {
             decimals = width = 0;
         }
         QString replacement;
         if ( format[pos+len] == 's' ||
              format[pos+len] == 'S' ||
              format[pos+len] == 'c' )
         {
             bool rightjust = ( f.find('-') < 0 );
             // Yes, %-5s really means left adjust in sprintf
 
             if ( wpos < 0 ) {
                 QRegExp num( "[0-9]+" );
                 QRegExp dot( "\\." );
                 int nlen;
                 int p = num.match( f.data(), 0, &nlen );
                 int q = dot.match( f.data(), 0 );
                 if ( q < 0 || (p < q && p >= 0) )
                     width = f.mid( p, nlen ).toInt();
                 if ( q >= 0 ) {
                     p = num.match( f.data(), q );
                     // "decimals" is used to specify string truncation
                     if ( p >= 0 )
                         decimals = f.mid( p, nlen ).toInt();
                 }
             }
 
             if ( format[pos+len] == 's' ) {
 #ifndef QT_NO_TEXTCODEC
                 QString s = QString::fromUtf8(va_arg(ap, char*));
 #else
                 QString s = QString::fromLatin1(va_arg(ap, char*));
 #endif
                 if ( decimals <= 0 )
                     replacement = s;
                 else
                     replacement = s.left(decimals);
             } else {
                 int ch = va_arg(ap, int);
                 replacement = QChar((ushort)ch);
             }
             if ( replacement.length() < width ) {
                 replacement = rightjust
                     ? replacement.rightJustify(width)
                     : replacement.leftJustify(width);
             }
         } else if ( format[pos+len] == '%' ) {
             replacement = '%';
         } else if ( format[pos+len] == 'n' ) {
             int* n = va_arg(ap, int*);
             *n = result.length();
         } else {
             char in[64], out[330] = "";
             strncpy(in,f.latin1(),63);
             char fch = format[pos+len].latin1();
             in[f.length()] = fch;
             switch ( fch ) {
               case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': {
                 int value = va_arg(ap, int);
                 switch (params) {
                   case 0: ::sprintf( out, in, value ); break;
                   case 1: ::sprintf( out, in, width, value ); break;
                   case 2: ::sprintf( out, in, width, decimals, value ); break;
                 }
               } break;
               case 'e': case 'E': case 'f': case 'g': case 'G': {
                 double value = va_arg(ap, double);
                 switch (params) {
                   case 0: ::sprintf( out, in, value ); break;
                   case 1: ::sprintf( out, in, width, value ); break;
                   case 2: ::sprintf( out, in, width, decimals, value ); break;
                 }
               } break;
               case 'p': {
                 void* value = va_arg(ap, void*);
                 switch (params) {
                   case 0: ::sprintf( out, in, value ); break;
                   case 1: ::sprintf( out, in, width, value ); break;
                   case 2: ::sprintf( out, in, width, decimals, value ); break;
                 }
               } break;
             }
             replacement = QString::fromLatin1(out);
         }
         result += replacement;
     }
     *this = result;
 
     va_end( ap );
     return *this;
 }

bool QString::startsWith ( const QString & s ) const

Returns whether the strings starts with s, or not.

Definition at line 15211 of file qstring.cpp.

 {
     for ( int i =0; i < (int) s.length(); i++ ) {
         if ( i >= (int) length() || d->unicode[i] != s[i] )
             return FALSE;
     }
     return TRUE;
 }

QString QString::stripWhiteSpace ( ) const

Returns a new string that has white space removed from the start and the end.

White space means any character for which QChar::isSpace() returns TRUE. This includes ASCII characters 9 (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR), and 32 (Space).

QString s = " space ";

QString t = s.stripWhiteSpace(); // t == "space"

See also: simplifyWhiteSpace()

Definition at line 13438 of file qstring.cpp.

 {
     if ( isEmpty() )                            // nothing to do
         return *this;
     if ( !at(0).isSpace() && !at(length()-1).isSpace() )
         return *this;
 
     register const QChar *s = unicode();
     QString result = fromLatin1("");
 
     int start = 0;
     int end = length() - 1;
     while ( start<=end && s[start].isSpace() )  // skip white space from start
         start++;
     if ( start > end ) {                        // only white space
         return result;
     }
     while ( end && s[end].isSpace() )           // skip white space from end
         end--;
     int l = end - start + 1;
     result.setLength( l );
     if ( l )
         memcpy( result.d->unicode, &s[start], sizeof(QChar)*l );
     return result;
 }

void QString::subat ( uint i )

private

Internal chunk of code to handle the uncommon cases of at() above.

Definition at line 14713 of file qstring.cpp.

 {
     uint olen = d->len;
     if ( i >= olen ) {
         setLength( i+1 );               // i is index; i+1 is needed length
         for ( uint j=olen; j<=i; j++ )
             d->unicode[j] = QChar::null;
     } else {
         // Just be sure to detach
         real_detach();
     }
 }

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

Returns the string converted to a double value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14071 of file qstring.cpp.

 {
     char *end;
 
     QCString a = latin1();
     // Just latin1() is not sufficient, since U0131 would look like '1'.
     for (uint i=0; i<d->len; i++)
         if ( d->unicode[i].row() )
             a[(int)i]='z';
 
     double val = strtod( a.data() ? a.data() : "", &end );
     if ( ok )
         *ok = ( a && *a && ( end == 0 || *end == '\0' ) );
     return val;
 }

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

Returns the string converted to a float value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14095 of file qstring.cpp.

 {
     return (float)toDouble( ok );
 }

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

Returns the string converted to a int value.

QString str("FF");
bool ok;
int hex = str.toInt( &ok, 16 ); // will return 255, and ok set to TRUE
int dec = str.toInt( &ok, 10 ); // will return 0, and ok set to FALSE

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14045 of file qstring.cpp.

 {
     return (int)toLong( ok, base );
 }

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

Returns the string converted to a long value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 13834 of file qstring.cpp.

 {
     const QChar *p = unicode();
     long val=0;
     int l = length();
     const long max_mult = INT_MAX / base;
     bool is_ok = FALSE;
     int neg = 0;
     if ( !p )
         goto bye;
     while ( l && p->isSpace() )                 // skip leading space
         l--,p++;
     if ( l && *p == '-' ) {
         l--;
         p++;
         neg = 1;
     } else if ( *p == '+' ) {
         l--;
         p++;
     }
 
     // NOTE: toULong() code is similar
     if ( !l || !ok_in_base(*p,base) )
         goto bye;
     while ( l && ok_in_base(*p,base) ) {
         l--;
         int dv;
         if ( p->isDigit() ) {
             dv = p->digitValue();
         } else {
             if ( *p >= 'a' && *p <= 'z' )
                 dv = *p - 'a' + 10;
             else
                 dv = *p - 'A' + 10;
         }
         if ( val > max_mult || (val == max_mult && dv > (INT_MAX%base)+neg) )
             goto bye;
         val = base*val + dv;
         p++;
     }
     if ( neg )
         val = -val;
     while ( l && p->isSpace() )                 // skip trailing space
         l--,p++;
     if ( !l )
         is_ok = TRUE;
 bye:
     if ( ok )
         *ok = is_ok;
     return is_ok ? val : 0;
 }

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

Returns the string converted to a short value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14001 of file qstring.cpp.

 {
     long v = toLong( ok, base );
     if ( ok && *ok && (v < -32768 || v > 32767) ) {
         *ok = FALSE;
         v = 0;
     }
     return (short)v;
 }

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

Returns the string converted to an unsigned int value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14058 of file qstring.cpp.

 {
     return (uint)toULong( ok, base );
 }

uint64 QString::toUInt64	(	bool *	ok = `0`,
		int	base = `10`
	)		const

Returns the string converted to an unsigned long value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 13948 of file qstring.cpp.

 {
     const QChar *p = unicode();
     uint64 val=0;
     int l = length();
     const uint64 max_mult = 1844674407370955161ULL;  // ULLONG_MAX/10, rounded down
     bool is_ok = FALSE;
     if ( !p )
         goto bye;
     while ( l && p->isSpace() )                 // skip leading space
         l--,p++;
     if ( *p == '+' )
         l--,p++;
 
     // NOTE: toULong() code is similar
     if ( !l || !ok_in_base(*p,base) )
         goto bye;
     while ( l && ok_in_base(*p,base) ) {
         l--;
         uint dv;
         if ( p->isDigit() ) {
             dv = p->digitValue();
         } else {
             if ( *p >= 'a' && *p <= 'z' )
                 dv = *p - 'a' + 10;
             else
                 dv = *p - 'A' + 10;
         }
         if ( val > max_mult || (val == max_mult && dv > (ULLONG_MAX%base)) )
             goto bye;
         val = base*val + dv;
         p++;
     }
 
     while ( l && p->isSpace() )                 // skip trailing space
         l--,p++;
     if ( !l )
         is_ok = TRUE;
 bye:
     if ( ok )
         *ok = is_ok;
     return is_ok ? val : 0;
 }

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

Returns the string converted to an unsigned long value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 13895 of file qstring.cpp.

 {
     const QChar *p = unicode();
     ulong val=0;
     int l = length();
     const ulong max_mult = 429496729;           // UINT_MAX/10, rounded down
     bool is_ok = FALSE;
     if ( !p )
         goto bye;
     while ( l && p->isSpace() )                 // skip leading space
         l--,p++;
     if ( *p == '+' )
         l--,p++;
 
     // NOTE: toLong() code is similar
     if ( !l || !ok_in_base(*p,base) )
         goto bye;
     while ( l && ok_in_base(*p,base) ) {
         l--;
         uint dv;
         if ( p->isDigit() ) {
             dv = p->digitValue();
         } else {
             if ( *p >= 'a' && *p <= 'z' )
                 dv = *p - 'a' + 10;
             else
                 dv = *p - 'A' + 10;
         }
         if ( val > max_mult || (val == max_mult && dv > (UINT_MAX%base)) )
             goto bye;
         val = base*val + dv;
         p++;
     }
 
     while ( l && p->isSpace() )                 // skip trailing space
         l--,p++;
     if ( !l )
         is_ok = TRUE;
 bye:
     if ( ok )
         *ok = is_ok;
     return is_ok ? val : 0;
 }

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

Returns the string converted to an unsigned short value.

If ok is non-null, *ok is set to TRUE if there are no conceivable errors, and FALSE if the string is not a number at all, or if it has trailing garbage.

Definition at line 14019 of file qstring.cpp.

 {
     ulong v = toULong( ok, base );
     if ( ok && *ok && (v > 65535) ) {
         *ok = FALSE;
         v = 0;
     }
     return (ushort)v;
 }

void QString::truncate ( uint newLen )

Truncates the string at position newLen if newLen is less than the current length . Otherwise, nothing happens.

QString s = "truncate this string";

s.truncate( 5 ); // s == "trunc"

In Qt 1.x, it was possible to "truncate" a string to a longer length. This is no longer possible.

Definition at line 12490 of file qstring.cpp.

 {
     if ( newLen < d->len )
         setLength( newLen );
 }

const unsigned short * QString::ucs2 ( ) const

Returns the QString as a zero terminated array of unsigned shorts if the string is not null; otherwise returns zero.

The result remains valid so long as one unmodified copy of the source string exists.

Definition at line 12092 of file qstring.cpp.

 {
   if ( ! d->unicode )
     return 0;
   unsigned int len = d->len;
   if ( d->maxl < len + 1 ) {
     // detach, grow or shrink
     uint newMax = computeNewMax( len + 1 );
     QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
     if ( nd ) {
       if ( d->unicode )
         memcpy( nd, d->unicode, sizeof(QChar)*len );
       ((QString *)this)->deref();
       ((QString *)this)->d = new QStringData( nd, len, newMax );
     }
   }
   d->unicode[len] = 0;
   return (unsigned short *) d->unicode;
 }

const QChar * QString::unicode ( ) const

inline

Returns the Unicode representation of the string. The result remains valid until the string is modified.

Definition at line 508 of file qstring.h.

508 { return d->unicode; }

QStringData * d

Definition: qstring.h:560

QStringData::unicode

QChar * unicode

Definition: qstring.h:342

char * QString::unicodeToAscii	(	const QChar *	uc,
		uint	l
	)

staticprivate

This utility function converts l 16-bit characters from uc to ASCII, returning a NUL-terminated string.

The caller is responsible for deleting the string with delete[].

Definition at line 12058 of file qstring.cpp.

 {
     if (!uc) {
         return 0;
     }
     char *a = new char[l+1];
     char *result = a;
     while (l--)
         *a++ = *uc++;
     *a = '\0';
     return result;
 }

QString QString::upper ( ) const

Returns a new string that is the string converted to upper case.

QString s("TeX");

QString t = s.upper(); // t == "TEX"

See also: lower()

Definition at line 13404 of file qstring.cpp.

 {
     QString s(*this);
     int l=length();
     if ( l ) {
         s.real_detach(); // could do this only when we find a change
         register QChar *p=s.d->unicode;
         if ( p ) {
             while ( l-- ) {
                 *p = p->upper();
                 p++;
             }
         }
     }
     return s;
 }

QCString QString::utf8 ( ) const

Returns the string encoded in UTF8 format.

See QTextCodec for more diverse coding/decoding of Unicode strings.

See also: QString::fromUtf8(), local8Bit(), latin1()

Definition at line 14507 of file qstring.cpp.

 {
     static QTextCodec* codec = QTextCodec::codecForMib(106);
     return codec
             ? codec->fromUnicode(*this)
             : QCString(latin1());
 }

QString QString::visual	(	int	index = `0`,
		int	len = `-1`
	)

This function returns the QString ordered visually. Useful for painting the string or when transforming to a visually ordered encoding.

Definition at line 11705 of file qstring.cpp.

 {
 #ifndef QT_NO_UNICODETABLES
     // #### This needs much more optimizing - it is called for
     // #### every text operation.
 
     unsigned char *level;
     QChar::Direction *dir;
     unsigned char base = 0;
 
     unsigned int l = length();
 
     // check bounds
     if (len == -1)
         len = length()-index;
     if ((uint)index > l)
         return QString::null;
 
     // find base direction
     unsigned int pos = 0;
     while ((pos < length()) &&
            (at(pos) != RLE) &&
            (at(pos) != LRE) &&
            (at(pos) != RLO) &&
            (at(pos) != LRO) &&
            (at(pos).direction() > 1) &&
            (at(pos).direction() != QChar::DirAL)
            ) // not R and not L
         pos++;
 
     if ((pos < length()) &&
             ((at(pos).direction() == QChar::DirR) ||
              (at(pos).direction() == QChar::DirAL) ||
             (at(pos) == RLE) ||
             (at(pos) == RLO)))
         base = 1;
 
     // is there any BiDi char at all?
     if ( base == 0 && pos == l ) {
         return mid(index, len);
     }
 
 
     level = new uchar[l];
     dir   = new QChar::Direction[l];
 
     // explicit override pass
     //unsigned int code_count = 0;
 
     QStack<QBidiState> stack;
     stack.setAutoDelete(TRUE);
 
     unsigned char    clevel   = base;
     signed char      override = -1;
 
     for (pos = 0; pos < l; pos++) {
 
         if (at(pos) == RLE) {
             //code_count++;
             stack.push(new QBidiState(clevel, override));
             if (clevel < 254)
                 clevel += 1 + clevel % 2;
             override = -1;
         }
         else if (at(pos) == LRE) {
             //code_count++;
             stack.push(new QBidiState(clevel, override));
             if (clevel < 254)
                 clevel += 2 - clevel % 2;
             override = -1;
         }
         else if (at(pos) == RLO) {
             //code_count++;
             stack.push(new QBidiState(clevel, override));
             if (clevel < 254)
                 clevel += 1 + clevel % 2;
             override = QChar::DirR;
         }
         else if (at(pos) == LRO) {
             //code_count++;
             stack.push(new QBidiState(clevel, override));
             if (clevel < 254)
                 clevel += 2 - clevel % 2;
             override = QChar::DirL;
         }
         else if (at(pos) == PDF) {
             //code_count++;
             if (!stack.isEmpty()) {
                 override = stack.top()->override;
                 clevel   = stack.top()->level;
                 stack.remove();
             }
         }
 
         // TODO: catch block separators (newlines, paras, etc.)
 
         level[pos] = clevel;
         if (override != -1)
             dir[pos] = (QChar::Direction) override;
         else
             dir[pos] = at(pos).direction();
     }
 
     // weak type pass
     for (pos = 0; pos < l; pos++) {
 
         int i;
 
         switch (at(pos).direction()) {
         case QChar::DirEN:
             i   = pos-1;
             while ((i >= 0) &&
                    !(at(i).direction() == QChar::DirAN) &&
                    !(at(i).direction() == QChar::DirAL) &&
                    !(at(i).direction() == QChar::DirB))
                 i--;
 
             if ((i >= 0) &&
                 ((at(i).direction() == QChar::DirAN) ||
                  (at(i).direction() == QChar::DirAL)))
                 dir[pos] = QChar::DirAN;
 
             break;
         case QChar::DirES:
         case QChar::DirCS:
             if ((pos > 0) && (pos < l-1) &&
                 (dir[pos-1] == dir[pos+1]))
                 dir[pos] = dir[pos-1];
             else
                 dir[pos] = QChar::DirON;
 
             break;
         case QChar::DirET:
             if (((pos > 0) && (dir[pos-1] == QChar::DirEN)) ||
                 ((pos < l-1) && (dir[pos+1] == QChar::DirEN)))
                 dir[pos] = QChar::DirEN;
             else
                 dir[pos] = QChar::DirON;
 
             break;
         case QChar::DirAL:
             dir[pos] = QChar::DirR;
             break;
         default:
             break;
         }
     }
 
     // neutral type pass
     for (pos = 0; pos < l; pos++) {
           QChar::Direction left,right; // declaring l here shadowed previous l
 
         if (is_neutral(dir[pos])) {
             if (pos > 0)
                 left = dir[pos-1];
             else
                 left = (base == 0 ? QChar::DirL : QChar::DirR);
 
             int i = pos;
 
             while ((i < (int)l-1) && is_neutral(dir[i+1]))
                 i++;
 
             if (i < (int)l-1)
                 right = dir[i+1];
             else
                 right = (base == 0 ? QChar::DirL : QChar::DirR);
 
             for (int j=pos; j <= i; j++) {
                   int a = 1, b = 1;
                   while ((a < 5) && (left != resolv[0][a]))
                         a++;
                   while ((b < 5) && (right != resolv[0][b]))
                         b++;
                   if ((a == 5) || (b == 5))
                         dir[j] = (base == 0 ? QChar::DirL : QChar::DirR);
                   else
                         dir[j] = resolv[a][b];
 
                   if (dir[j] == (QChar::Direction)(-1))
                         dir[j] = (base == 0 ? QChar::DirL : QChar::DirR);
             }
         }
     }
 
     // implicit level pass
     QChar::Direction prec = (base == 0 ? QChar::DirL : QChar::DirR);
 
     for (pos = 0; pos < l; pos++) {
         if (level[pos] % 2) {
             switch (dir[pos]) {
             case QChar::DirL:
             case QChar::DirAN:
             case QChar::DirEN:
                 level[pos] += 1;
                 break;
             default:
                 break;
             }
         } else {
             switch (dir[pos]) {
             case QChar::DirL:
                                 // do nothing
                 break;
             case QChar::DirR:
                 level[pos] += 1;
                 break;
             case QChar::DirEN:
                 if (prec == QChar::DirL)
                     continue;
                                 // fall through
             case QChar::DirAN:
                 level[pos] += 2;
                 break;
             default:
                 break;
             }
         }
 
         prec = dir[pos];
     }
 
         // now do the work!
         QString ret(*this);
     reverse(ret, level, index, index+len);
 
     delete [] level;
     delete [] dir;
 
     return ret;
 #else
     return mid(index,len);
 #endif
 }

Friends And Related Function Documentation

bool operator!=	(	const QString &	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) != 0.

Definition at line 14850 of file qstring.cpp.

14851 { return !(s1==s2); }

bool operator!=	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) != 0.

Definition at line 14872 of file qstring.cpp.

14873 { return !(s1==s2); }

bool operator!=	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) != 0.

Definition at line 14875 of file qstring.cpp.

14876 { return !(s1==s2); }

QString operator+	(	const QString &	s1,
		const QString &	s2
	)

Definition at line 774 of file qstring.h.

 {
     QString tmp( s1 );
     tmp += s2;
     return tmp;
 }

QString operator+	(	const QString &	s1,
		const char *	s2
	)

Definition at line 782 of file qstring.h.

 {
     QString tmp( s1 );
     tmp += QString::fromLatin1(s2);
     return tmp;
 }

QString operator+	(	const char *	s1,
		const QString &	s2
	)

Definition at line 789 of file qstring.h.

 {
     QString tmp = QString::fromLatin1( s1 );
     tmp += s2;
     return tmp;
 }

QString operator+	(	const QString &	s,
		char	c
	)

Definition at line 804 of file qstring.h.

 {
     QString tmp( s1 );
     tmp += c2;
     return tmp;
 }

QString operator+	(	char	c,
		const QString &	s
	)

Definition at line 819 of file qstring.h.

 {
     QString tmp;
     tmp += c1;
     tmp += s2;
     return tmp;
 }

bool operator<	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) < 0.

Definition at line 14878 of file qstring.cpp.

14879 { return ucstrcmp(s1,s2) < 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator<	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) < 0.

Definition at line 14881 of file qstring.cpp.

14882 { return ucstrcmp(s1,s2) < 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

QDataStream & operator<<	(	QDataStream &	s,
		const QString &	str
	)

See also: Format of the QDataStream operators

Definition at line 15066 of file qstring.cpp.

 {
     if ( s.version() == 1 ) {
         QCString l( str.latin1() );
         s << l;
     }
     else {
         const char* ub = (const char*)str.unicode();
         if ( ub || s.version() < 3 ) {
             if ( QChar::networkOrdered() ==
                     (s.byteOrder()==QDataStream::BigEndian) ) {
                 s.writeBytes( ub, (int)sizeof(QChar)*str.length() );
             } else {
                 static const uint auto_size = 1024;
                 char t[auto_size];
                 char *b;
                 if ( str.length()*sizeof(QChar) > auto_size ) {
                     b = new char[str.length()*sizeof(QChar)];
                 } else {
                     b = t;
                 }
                 int l = str.length();
                 char *c=b;
                 while ( l-- ) {
                     *c++ = ub[1];
                     *c++ = ub[0];
                     ub+=sizeof(QChar);
                 }
                 s.writeBytes( b, (int)sizeof(QChar)*str.length() );
                 if ( str.length()*sizeof(QChar) > auto_size )
                     delete [] b;
             }
         } else {
             // write null marker
             s << (Q_UINT32)0xffffffff;
         }
     }
     return s;
 }

bool operator<=	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) <= 0.

Definition at line 14884 of file qstring.cpp.

14885 { return ucstrcmp(s1,s2) <= 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator<=	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) <= 0.

Definition at line 14887 of file qstring.cpp.

14888 { return ucstrcmp(s1,s2) <= 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator==	(	const QString &	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) == 0.

Definition at line 14843 of file qstring.cpp.

 {
     return (s1.length() == s2.length()) && s1.isNull() == s2.isNull() &&
            (memcmp((char*)s1.unicode(),(char*)s2.unicode(),
                    s1.length()*sizeof(QChar)) ==0);
 }

bool operator==	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) == 0.

Definition at line 14866 of file qstring.cpp.

14867 { return s1==QString(s2); }

QString()

Definition: qstring.h:652

bool operator==	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) == 0.

Definition at line 14869 of file qstring.cpp.

14870 { return QString(s1)==s2; }

QString()

Definition: qstring.h:652

bool operator>	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) > 0.

Definition at line 14890 of file qstring.cpp.

14891 { return ucstrcmp(s1,s2) > 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator>	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) > 0.

Definition at line 14893 of file qstring.cpp.

14894 { return ucstrcmp(s1,s2) > 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator>=	(	const QString &	s1,
		const char *	s2
	)

Equivalent to qstrcmp(s1,s2) >= 0.

Definition at line 14896 of file qstring.cpp.

14897 { return ucstrcmp(s1,s2) >= 0; }

static int ucstrcmp(const QString &as, const QString &bs)

Definition: qstring.cpp:10693

bool operator>=	(	const char *	s1,
		const QString &	s2
	)

Equivalent to qstrcmp(s1,s2) >= 0.

Definition at line 14899 of file qstring.cpp.

14900 { return ucstrcmp(s1,s2) >= 0; }