ISLEman
qstring.h
1 /****************************************************************************
2 **
3 **
4 ** Definition of the QString class, and related Unicode
5 ** functions.
6 **
7 ** Created : 920609
8 **
9 ** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
10 **
11 ** This file is part of the tools module of the Qt GUI Toolkit.
12 **
13 ** This file may be distributed under the terms of the Q Public License
14 ** as defined by Trolltech AS of Norway and appearing in the file
15 ** LICENSE.QPL included in the packaging of this file.
16 **
17 ** This file may be distributed and/or modified under the terms of the
18 ** GNU General Public License version 2 as published by the Free Software
19 ** Foundation and appearing in the file LICENSE.GPL included in the
20 ** packaging of this file.
21 **
22 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
23 ** licenses may use this file in accordance with the Qt Commercial License
24 ** Agreement provided with the Software.
25 **
26 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
27 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
28 **
29 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
30 ** information about Qt Commercial License Agreements.
31 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
32 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
33 **
34 ** Contact info@trolltech.com if any conditions of this licensing are
35 ** not clear to you.
36 **
37 **********************************************************************/
38 
39 #ifndef QSTRING_H
40 #define QSTRING_H
41 
42 #ifndef QT_H
43 #include "qcstring.h"
44 #endif // QT_H
45 
46 #define QT_NO_ASCII_CAST
47 
48 /*****************************************************************************
49  QString class
50  *****************************************************************************/
51 
52 class QRegExp;
53 class QString;
54 class QCharRef;
55 
56 class Q_EXPORT Q_PACKED QChar {
57 public:
58  QChar();
59  QChar( char c );
60  QChar( uchar c );
61  QChar( uchar c, uchar r );
62  QChar( const QChar& c );
63  QChar( ushort rc );
64  QChar( short rc );
65  QChar( uint rc );
66  QChar( int rc );
67 
68  QT_STATIC_CONST QChar null; // 0000
69  QT_STATIC_CONST QChar replacement; // FFFD
70  QT_STATIC_CONST QChar byteOrderMark; // FEFF
71  QT_STATIC_CONST QChar byteOrderSwapped; // FFFE
72  QT_STATIC_CONST QChar nbsp; // 00A0
73 
74  // Unicode information
75 
76  enum Category
77  {
78  NoCategory,
79 
80  Mark_NonSpacing, // Mn
81  Mark_SpacingCombining, // Mc
82  Mark_Enclosing, // Me
83 
84  Number_DecimalDigit, // Nd
85  Number_Letter, // Nl
86  Number_Other, // No
87 
88  Separator_Space, // Zs
89  Separator_Line, // Zl
90  Separator_Paragraph, // Zp
91 
92  Other_Control, // Cc
93  Other_Format, // Cf
94  Other_Surrogate, // Cs
95  Other_PrivateUse, // Co
96  Other_NotAssigned, // Cn
97 
98  Letter_Uppercase, // Lu
99  Letter_Lowercase, // Ll
100  Letter_Titlecase, // Lt
101  Letter_Modifier, // Lm
102  Letter_Other, // Lo
103 
104  Punctuation_Connector, // Pc
105  Punctuation_Dask, // Pd
106  Punctuation_Open, // Ps
107  Punctuation_Close, // Pe
108  Punctuation_InitialQuote, // Pi
109  Punctuation_FinalQuote, // Pf
110  Punctuation_Other, // Po
111 
112  Symbol_Math, // Sm
113  Symbol_Currency, // Sc
114  Symbol_Modifier, // Sk
115  Symbol_Other // So
116  };
117 
118  enum Direction
119  {
120  DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
121  DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
122  };
123 
124  enum Decomposition
125  {
126  Single, Canonical, Font, NoBreak, Initial, Medial,
127  Final, Isolated, Circle, Super, Sub, Vertical,
128  Wide, Narrow, Small, Square, Compat, Fraction
129  };
130 
131  enum Joining
132  {
133  OtherJoining, Dual, Right, Center
134  };
135 
136  // ****** WHEN ADDING FUNCTIONS, CONSIDER ADDING TO QCharRef TOO
137 
138  int digitValue() const;
139  QChar lower() const;
140  QChar upper() const;
141 
142  Category category() const;
143  Direction direction() const;
144  Joining joining() const;
145  bool mirrored() const;
146  QChar mirroredChar() const;
147  QString decomposition() const;
148  Decomposition decompositionTag() const;
149 
150  char latin1() const { return rw ? 0 : cl; }
151  ushort unicode() const { return (rw << 8) | cl; }
152 #ifndef QT_NO_CAST_ASCII
153  // like all ifdef'd code this is undocumented
154  operator char() const { return latin1(); }
155 #endif
156 
157  bool isNull() const { return unicode()==0; }
158  bool isPrint() const;
159  bool isPunct() const;
160  bool isSpace() const;
161  bool isMark() const;
162  bool isLetter() const;
163  bool isNumber() const;
164  bool isLetterOrNumber() const;
165  bool isDigit() const;
166 
167  uchar& cell() { return cl; }
168  uchar& row() { return rw; }
169  uchar cell() const { return cl; }
170  uchar row() const { return rw; }
171 
172  static bool networkOrdered() { return (int)net_ordered == 1; }
173 
174  friend inline int operator==( char ch, QChar c );
175  friend inline int operator==( QChar c, char ch );
176  friend inline int operator==( QChar c1, QChar c2 );
177  friend inline int operator!=( QChar c1, QChar c2 );
178  friend inline int operator!=( char ch, QChar c );
179  friend inline int operator!=( QChar c, char ch );
180  friend inline int operator<=( QChar c, char ch );
181  friend inline int operator<=( char ch, QChar c );
182  friend inline int operator<=( QChar c1, QChar c2 );
183 
184 private:
185 #if defined(_WS_X11_) || defined(_OS_WIN32_BYTESWAP_) || defined( _WS_QWS_ )
186  // XChar2b on X11, ushort on _OS_WIN32_BYTESWAP_
187  //### QWS must be defined on a platform by platform basis
188  uchar rw;
189  uchar cl;
190 #if defined(QT_QSTRING_UCS_4)
191  ushort grp;
192 #endif
193  enum { net_ordered = 1 };
194 #else
195  // ushort on _OS_WIN32_
196  uchar cl;
197  uchar rw;
198 #if defined(QT_QSTRING_UCS_4)
199  ushort grp;
200 #endif
201  enum { net_ordered = 0 };
202 #endif
203 };
204 
205 inline QChar::QChar()
206 {
207  rw = 0; cl = 0;
208 #ifdef QT_QSTRING_UCS_4
209  grp = 0;
210 #endif
211 }
212 inline QChar::QChar( char c )
213 {
214  rw = 0; cl = (uchar)c;
215 #ifdef QT_QSTRING_UCS_4
216  grp = 0;
217 #endif
218 }
219 inline QChar::QChar( uchar c )
220 {
221  rw = 0; cl = c;
222 #ifdef QT_QSTRING_UCS_4
223  grp = 0;
224 #endif
225 }
226 inline QChar::QChar( uchar c, uchar r )
227 {
228  rw = r; cl = c;
229 #ifdef QT_QSTRING_UCS_4
230  grp = 0;
231 #endif
232 }
233 inline QChar::QChar( const QChar& c )
234 {
235  rw = c.rw; cl = c.cl;
236 #ifdef QT_QSTRING_UCS_4
237  grp = 0;
238 #endif
239 }
240 inline QChar::QChar( ushort rc )
241 {
242  rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
243 #ifdef QT_QSTRING_UCS_4
244  grp = 0;
245 #endif
246 }
247 inline QChar::QChar( short rc )
248 {
249  rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
250 #ifdef QT_QSTRING_UCS_4
251  grp = 0;
252 #endif
253 }
254 inline QChar::QChar( uint rc )
255 {
256  rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
257 #ifdef QT_QSTRING_UCS_4
258  grp = 0;
259 #endif
260 }
261 inline QChar::QChar( int rc )
262 {
263  rw = (uchar)((rc>>8)&0xff); cl = (uchar)(rc&0xff);
264 #ifdef QT_QSTRING_UCS_4
265  grp = 0;
266 #endif
267 }
268 
269 
270 inline int operator==( char ch, QChar c )
271 {
272  return ch == c.cl && !c.rw;
273 }
274 
275 inline int operator==( QChar c, char ch )
276 {
277  return ch == c.cl && !c.rw;
278 }
279 
280 inline int operator==( QChar c1, QChar c2 )
281 {
282  return c1.cl == c2.cl
283  && c1.rw == c2.rw;
284 }
285 
286 inline int operator!=( QChar c1, QChar c2 )
287 {
288  return c1.cl != c2.cl
289  || c1.rw != c2.rw;
290 }
291 
292 inline int operator!=( char ch, QChar c )
293 {
294  return ch != c.cl || c.rw;
295 }
296 
297 inline int operator!=( QChar c, char ch )
298 {
299  return ch != c.cl || c.rw;
300 }
301 
302 inline int operator<=( QChar c, char ch )
303 {
304  return !(ch < c.cl || c.rw);
305 }
306 
307 inline int operator<=( char ch, QChar c )
308 {
309  return ch <= c.cl || c.rw;
310 }
311 
312 inline int operator<=( QChar c1, QChar c2 )
313 {
314  return c1.rw > c2.rw
315  ? FALSE
316  : c1.rw < c2.rw
317  ? TRUE
318  : c1.cl <= c2.cl;
319 }
320 
321 inline int operator>=( QChar c, char ch ) { return ch <= c; }
322 inline int operator>=( char ch, QChar c ) { return c <= ch; }
323 inline int operator>=( QChar c1, QChar c2 ) { return c2 <= c1; }
324 inline int operator<( QChar c, char ch ) { return !(ch<=c); }
325 inline int operator<( char ch, QChar c ) { return !(c<=ch); }
326 inline int operator<( QChar c1, QChar c2 ) { return !(c2<=c1); }
327 inline int operator>( QChar c, char ch ) { return !(ch>=c); }
328 inline int operator>( char ch, QChar c ) { return !(c>=ch); }
329 inline int operator>( QChar c1, QChar c2 ) { return !(c2>=c1); }
330 
331 // internal
332 struct Q_EXPORT QStringData : public QShared {
333  QStringData() :
334  unicode(0), ascii(0), len(0), maxl(0), dirtyascii(0) { ref(); }
335  QStringData(QChar *u, uint l, uint m) :
336  unicode(u), ascii(0), len(l), maxl(m), dirtyascii(0) { }
337 
338  ~QStringData() { if ( unicode ) delete[] ((char*)unicode);
339  if ( ascii ) delete[] ascii; }
340 
341  void deleteSelf();
342  QChar *unicode;
343  char *ascii;
344  uint len;
345  uint maxl:30;
346  uint dirtyascii:1;
347 };
348 
349 
350 class Q_EXPORT QString
351 {
352 public:
353  QString(); // make null string
354  QString( QChar ); // one-char string
355  QString( const QString & ); // impl-shared copy
356  QString( const QByteArray& ); // deep copy
357  QString( const QCString& ); // deep copy
358  QString( const QChar* unicode, uint length ); // deep copy
359 #ifndef QT_NO_CAST_ASCII
360  QString( const char *str ); // deep copy
361 #endif
362  ~QString();
363 
364  QString &operator=( const QString & ); // impl-shared copy
365 #ifndef QT_NO_CAST_ASCII
366  QString &operator=( const char * ); // deep copy
367 #endif
368  QString &operator=( const QCString& ); // deep copy
369  QString &operator=( QChar c );
370  QString &operator=( char c );
371 
372  //QT_STATIC_CONST QString null;
373  //bool isNull() const;
374 
375  struct Null { };
376  static const Null null;
377  inline QString(const Null &): d(shared_null) { d->ref(); }
378  inline QString &operator=(const Null &) { *this = QString(); return *this; }
379  inline bool isNull() const { return d == shared_null; }
380 
381  bool isEmpty() const;
382  uint length() const;
383  void truncate( uint pos );
384 
385 #if QT_VERSION >= 300
386 #error "fill() Should return *this, or QChar constructor should take count=1"
387 #endif
388  void fill( QChar c, int len = -1 );
389 
390  QString copy() const;
391 
392  QString arg(long a, int fieldwidth=0, int base=10) const;
393  QString arg(ulong a, int fieldwidth=0, int base=10) const;
394  QString arg(int a, int fieldwidth=0, int base=10) const;
395  QString arg(uint a, int fieldwidth=0, int base=10) const;
396  QString arg(short a, int fieldwidth=0, int base=10) const;
397  QString arg(ushort a, int fieldwidth=0, int base=10) const;
398  QString arg(char a, int fieldwidth=0) const;
399  QString arg(QChar a, int fieldwidth=0) const;
400  QString arg(const QString& a, int fieldwidth=0) const;
401  QString arg(double a, int fieldwidth=0, char fmt='g', int prec=-1) const;
402 
403  QString &sprintf( const char* format, ... )
404 #if defined(_CC_GNU_) && !defined(__INSURE__)
405  __attribute__ ((format (printf, 2, 3)))
406 #endif
407  ;
408 
409  int find( QChar c, int index=0, bool cs=TRUE ) const;
410  int find( char c, int index=0, bool cs=TRUE ) const;
411  int find( const QString &str, int index=0, bool cs=TRUE ) const;
412  int find( const QRegExp &, int index=0 ) const;
413 #ifndef QT_NO_CAST_ASCII
414  int find( const char* str, int index=0 ) const;
415 #endif
416  int findRev( QChar c, int index=-1, bool cs=TRUE) const;
417  int findRev( char c, int index=-1, bool cs=TRUE) const;
418  int findRev( const QString &str, int index=-1, bool cs=TRUE) const;
419  int findRev( const QRegExp &, int index=-1 ) const;
420 #ifndef QT_NO_CAST_ASCII
421  int findRev( const char* str, int index=-1 ) const;
422 #endif
423  int contains( QChar c, bool cs=TRUE ) const;
424  int contains( char c, bool cs=TRUE ) const
425  { return contains(QChar(c), cs); }
426 #ifndef QT_NO_CAST_ASCII
427  int contains( const char* str, bool cs=TRUE ) const;
428 #endif
429  int contains( const QString &str, bool cs=TRUE ) const;
430  int contains( const QRegExp & ) const;
431 
432  QString left( uint len ) const;
433  QString right( uint len ) const;
434  QString mid( uint index, uint len=0xffffffff) const;
435 
436  QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const;
437  QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const;
438 
439  QString lower() const;
440  QString upper() const;
441 
442  QString stripWhiteSpace() const;
443  QString simplifyWhiteSpace() const;
444 
445  QString &insert( uint index, const QString & );
446  QString &insert( uint index, const QChar*, uint len );
447  QString &insert( uint index, QChar );
448  QString &insert( uint index, char c ) { return insert(index,QChar(c)); }
449  QString &append( char );
450  QString &append( QChar );
451  QString &append( const QString & );
452  QString &prepend( char );
453  QString &prepend( QChar );
454  QString &prepend( const QString & );
455  QString &remove( uint index, uint len );
456  QString &replace( uint index, uint len, const QString & );
457  QString &replace( uint index, uint len, const QChar*, uint clen );
458  QString &replace( const QRegExp &, const QString & );
459 
460  short toShort( bool *ok=0, int base=10 ) const;
461  ushort toUShort( bool *ok=0, int base=10 ) const;
462  int toInt( bool *ok=0, int base=10 ) const;
463  uint toUInt( bool *ok=0, int base=10 ) const;
464  long toLong( bool *ok=0, int base=10 ) const;
465  ulong toULong( bool *ok=0, int base=10 ) const;
466  uint64 toUInt64( bool *ok=0, int base=10 ) const;
467  float toFloat( bool *ok=0 ) const;
468  double toDouble( bool *ok=0 ) const;
469 
470  QString &setNum( short, int base=10 );
471  QString &setNum( ushort, int base=10 );
472  QString &setNum( int, int base=10 );
473  QString &setNum( uint, int base=10 );
474  QString &setNum( long, int base=10 );
475  QString &setNum( ulong, int base=10 );
476  QString &setNum( float, char f='g', int prec=6 );
477  QString &setNum( double, char f='g', int prec=6 );
478 
479  static QString number( long, int base=10 );
480  static QString number( ulong, int base=10);
481  static QString number( int, int base=10 );
482  static QString number( uint, int base=10);
483  static QString number( double, char f='g', int prec=6 );
484 
485  void setExpand( uint index, QChar c );
486 
487  QString &operator+=( const QString &str );
488  QString &operator+=( QChar c );
489  QString &operator+=( char c );
490 
491  // Your compiler is smart enough to use the const one if it can.
492  QChar at( uint i ) const
493  { return i<d->len ? d->unicode[i] : QChar::null; }
494  QChar operator[]( int i ) const { return at((uint)i); }
495  QCharRef at( uint i );
496  QCharRef operator[]( int i );
497 
498  QChar constref(uint i) const
499  { return at(i); }
500  QChar& ref(uint i)
501  { // Optimized for easy-inlining by simple compilers.
502  if (d->count!=1 || i>=d->len)
503  subat(i);
504  d->dirtyascii=1;
505  return d->unicode[i];
506  }
507 
508  const QChar* unicode() const { return d->unicode; }
509  const char* ascii() const;
510  const char* latin1() const;
511  static QString fromLatin1(const char*, int len=-1);
512  const unsigned short *ucs2() const;
513  static QString fromUcs2( const unsigned short *ucs2 );
514 #ifndef QT_NO_TEXTCODEC
515  QCString utf8() const;
516  static QString fromUtf8(const char*, int len=-1);
517 #endif
518  QCString local8Bit() const;
519  static QString fromLocal8Bit(const char*, int len=-1);
520  bool operator!() const;
521 #ifndef QT_NO_ASCII_CAST
522  operator const char *() const { return latin1(); }
523 #endif
524 
525  QString &setUnicode( const QChar* unicode, uint len );
526  QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len );
527  QString &setLatin1( const char*, int len=-1 );
528 
529  int compare( const QString& s ) const;
530  static int compare( const QString& s1, const QString& s2 )
531  { return s1.compare(s2); }
532 
533 #ifndef QT_NO_DATASTREAM
534  friend Q_EXPORT QDataStream &operator>>( QDataStream &, QString & );
535 #endif
536  // new functions for BiDi
537  void compose();
538  QChar::Direction basicDirection();
539  QString visual(int index = 0, int len = -1);
540 
541 #ifndef QT_NO_COMPAT
542  const char* data() const { return latin1(); }
543 #endif
544 
545  bool startsWith( const QString& ) const;
546 
547 private:
548  QString( int size, bool dummy ); // allocate size incl. \0
549 
550  void deref();
551  void real_detach();
552  void setLength( uint pos );
553  void subat( uint );
554  bool findArg(int& pos, int& len) const;
555 
556  static QChar* asciiToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
557  static QChar* asciiToUnicode( const QByteArray&, uint * len );
558  static char* unicodeToAscii( const QChar*, uint len );
559 
560  QStringData *d;
561  static QStringData* shared_null;
562  static QStringData* makeSharedNull();
563 
564  friend class QConstString;
565  QString(QStringData* dd, bool /*dummy*/) : d(dd) { }
566 };
567 
568 class Q_EXPORT QCharRef {
569  friend class QString;
570  QString& s;
571  uint p;
572  QCharRef(QString* str, uint pos) : s(*str), p(pos) { }
573 
574 public:
575  // Most QChar operations repeated here...
576 
577  // all this is not documented: We just say "like QChar" and let it be.
578 #if 1
579  ushort unicode() const { return s.constref(p).unicode(); }
580  char latin1() const { return s.constref(p).latin1(); }
581 
582  // An operator= for each QChar cast constructor...
583  QCharRef operator=(char c ) { s.ref(p)=c; return *this; }
584  QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
585  QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; }
586  QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; }
587  QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
588  QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
589  QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
590  QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }
591 
592  operator QChar () const { return s.constref(p); }
593 
594  // each function...
595  bool isNull() const { return unicode()==0; }
596  bool isPrint() const { return s.constref(p).isPrint(); }
597  bool isPunct() const { return s.constref(p).isPunct(); }
598  bool isSpace() const { return s.constref(p).isSpace(); }
599  bool isMark() const { return s.constref(p).isMark(); }
600  bool isLetter() const { return s.constref(p).isLetter(); }
601  bool isNumber() const { return s.constref(p).isNumber(); }
602  bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
603  bool isDigit() const { return s.constref(p).isDigit(); }
604 
605  int digitValue() const { return s.constref(p).digitValue(); }
606  QChar lower() { return s.constref(p).lower(); }
607  QChar upper() { return s.constref(p).upper(); }
608 
609  QChar::Category category() const { return s.constref(p).category(); }
610  QChar::Direction direction() const { return s.constref(p).direction(); }
611  QChar::Joining joining() const { return s.constref(p).joining(); }
612  bool mirrored() const { return s.constref(p).mirrored(); }
613  QChar mirroredChar() const { return s.constref(p).mirroredChar(); }
614  QString decomposition() const { return s.constref(p).decomposition(); }
615  QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
616 
617  // Not the non-const ones of these.
618  uchar cell() const { return s.constref(p).cell(); }
619  uchar row() const { return s.constref(p).row(); }
620 #endif
621 };
622 
623 inline QCharRef QString::at( uint i ) { return QCharRef(this,i); }
624 inline QCharRef QString::operator[]( int i ) { return at((uint)i); }
625 
626 
627 class Q_EXPORT QConstString : private QString {
628 public:
629  QConstString( QChar* unicode, uint length );
630  ~QConstString();
631  const QString& string() const { return *this; }
632 };
633 
634 
635 /*****************************************************************************
636  QString stream functions
637  *****************************************************************************/
638 #ifndef QT_NO_DATASTREAM
639 Q_EXPORT QDataStream &operator<<( QDataStream &, const QString & );
640 Q_EXPORT QDataStream &operator>>( QDataStream &, QString & );
641 #endif
642 
643 /*****************************************************************************
644  QString inline functions
645  *****************************************************************************/
646 
647 // These two move code into makeSharedNull() and deletesData()
648 // to improve cache-coherence (and reduce code bloat), while
649 // keeping the common cases fast.
650 //
651 // No safe way to pre-init shared_null on ALL compilers/linkers.
652 inline QString::QString() :
653  d(shared_null ? shared_null : makeSharedNull())
654 {
655  d->ref();
656 }
657 //
658 inline QString::~QString()
659 {
660  if ( d->deref() ) {
661  if ( d == shared_null )
662  shared_null = 0;
663  d->deleteSelf();
664  }
665 }
666 
667 inline QString &QString::operator=( QChar c )
668 { return *this = QString(c); }
669 
670 inline QString &QString::operator=( char c )
671 { return *this = QString(QChar(c)); }
672 
673 //inline bool QString::isNull() const
674 //{ return unicode() == 0; }
675 
676 inline bool QString::operator!() const
677 { return isNull(); }
678 
679 inline uint QString::length() const
680 { return d->len; }
681 
682 inline bool QString::isEmpty() const
683 { return length() == 0; }
684 
685 inline QString QString::copy() const
686 { return QString( *this ); }
687 
688 inline QString &QString::prepend( const QString & s )
689 { return insert(0,s); }
690 
691 inline QString &QString::prepend( QChar c )
692 { return insert(0,c); }
693 
694 inline QString &QString::prepend( char c )
695 { return insert(0,c); }
696 
697 inline QString &QString::append( const QString & s )
698 { return operator+=(s); }
699 
700 inline QString &QString::append( QChar c )
701 { return operator+=(c); }
702 
703 inline QString &QString::append( char c )
704 { return operator+=(c); }
705 
706 inline QString &QString::setNum( short n, int base )
707 { return setNum((long)n, base); }
708 
709 inline QString &QString::setNum( ushort n, int base )
710 { return setNum((ulong)n, base); }
711 
712 inline QString &QString::setNum( int n, int base )
713 { return setNum((long)n, base); }
714 
715 inline QString &QString::setNum( uint n, int base )
716 { return setNum((ulong)n, base); }
717 
718 inline QString &QString::setNum( float n, char f, int prec )
719 { return setNum((double)n,f,prec); }
720 
721 inline QString QString::arg(int a, int fieldwidth, int base) const
722 { return arg((long)a, fieldwidth, base); }
723 
724 inline QString QString::arg(uint a, int fieldwidth, int base) const
725 { return arg((ulong)a, fieldwidth, base); }
726 
727 inline QString QString::arg(short a, int fieldwidth, int base) const
728 { return arg((long)a, fieldwidth, base); }
729 
730 inline QString QString::arg(ushort a, int fieldwidth, int base) const
731 { return arg((ulong)a, fieldwidth, base); }
732 
733 inline int QString::find( char c, int index, bool cs ) const
734 { return find(QChar(c), index, cs); }
735 
736 inline int QString::findRev( char c, int index, bool cs) const
737 { return findRev( QChar(c), index, cs ); }
738 
739 
740 #ifndef QT_NO_CAST_ASCII
741 inline int QString::find( const char* str, int index ) const
742 { return find(QString::fromLatin1(str), index); }
743 
744 inline int QString::findRev( const char* str, int index ) const
745 { return findRev(QString::fromLatin1(str), index); }
746 #endif
747 
748 
749 /*****************************************************************************
750  QString non-member operators
751  *****************************************************************************/
752 
753 Q_EXPORT bool operator!=( const QString &s1, const QString &s2 );
754 Q_EXPORT bool operator<( const QString &s1, const QString &s2 );
755 Q_EXPORT bool operator<=( const QString &s1, const QString &s2 );
756 Q_EXPORT bool operator==( const QString &s1, const QString &s2 );
757 Q_EXPORT bool operator>( const QString &s1, const QString &s2 );
758 Q_EXPORT bool operator>=( const QString &s1, const QString &s2 );
759 #ifndef QT_NO_CAST_ASCII
760 Q_EXPORT bool operator!=( const QString &s1, const char *s2 );
761 Q_EXPORT bool operator<( const QString &s1, const char *s2 );
762 Q_EXPORT bool operator<=( const QString &s1, const char *s2 );
763 Q_EXPORT bool operator==( const QString &s1, const char *s2 );
764 Q_EXPORT bool operator>( const QString &s1, const char *s2 );
765 Q_EXPORT bool operator>=( const QString &s1, const char *s2 );
766 Q_EXPORT bool operator!=( const char *s1, const QString &s2 );
767 Q_EXPORT bool operator<( const char *s1, const QString &s2 );
768 Q_EXPORT bool operator<=( const char *s1, const QString &s2 );
769 Q_EXPORT bool operator==( const char *s1, const QString &s2 );
770 //Q_EXPORT bool operator>( const char *s1, const QString &s2 ); // MSVC++
771 Q_EXPORT bool operator>=( const char *s1, const QString &s2 );
772 #endif
773 
774 Q_EXPORT inline QString operator+( const QString &s1, const QString &s2 )
775 {
776  QString tmp( s1 );
777  tmp += s2;
778  return tmp;
779 }
780 
781 #ifndef QT_NO_CAST_ASCII
782 Q_EXPORT inline QString operator+( const QString &s1, const char *s2 )
783 {
784  QString tmp( s1 );
785  tmp += QString::fromLatin1(s2);
786  return tmp;
787 }
788 
789 Q_EXPORT inline QString operator+( const char *s1, const QString &s2 )
790 {
791  QString tmp = QString::fromLatin1( s1 );
792  tmp += s2;
793  return tmp;
794 }
795 #endif
796 
797 Q_EXPORT inline QString operator+( const QString &s1, QChar c2 )
798 {
799  QString tmp( s1 );
800  tmp += c2;
801  return tmp;
802 }
803 
804 Q_EXPORT inline QString operator+( const QString &s1, char c2 )
805 {
806  QString tmp( s1 );
807  tmp += c2;
808  return tmp;
809 }
810 
811 Q_EXPORT inline QString operator+( QChar c1, const QString &s2 )
812 {
813  QString tmp;
814  tmp += c1;
815  tmp += s2;
816  return tmp;
817 }
818 
819 Q_EXPORT inline QString operator+( char c1, const QString &s2 )
820 {
821  QString tmp;
822  tmp += c1;
823  tmp += s2;
824  return tmp;
825 }
826 
827 #if defined(_OS_WIN32_)
828 extern Q_EXPORT QString qt_winQString(void*);
829 extern Q_EXPORT const void* qt_winTchar(const QString& str, bool addnul);
830 extern Q_EXPORT void* qt_winTchar_new(const QString& str);
831 extern Q_EXPORT QCString qt_winQString2MB( const QString& s, int len=-1 );
832 extern Q_EXPORT QString qt_winMB2QString( const char* mb, int len=-1 );
833 #endif
834 
835 #endif // QSTRING_H
QChar::Joining
Joining
Definition: qstring.h:131
QConstString
A QString which uses constant Unicode data.
Definition: qstring.h:627
QChar::Category
Category
Definition: qstring.h:76
QChar::QChar
QChar()
Definition: qstring.h:205
QString::latin1
const char * latin1() const
Definition: qstring.cpp:14457
QString::operator!
bool operator!() const
Definition: qstring.h:676
QRegExp
The QRegExp class provides pattern matching using regular expressions or wildcards.
Definition: qregexp.h:46
QChar::unicode
ushort unicode() const
Definition: qstring.h:151
QChar::isNull
bool isNull() const
Definition: qstring.h:157
QString::copy
QString copy() const
Definition: qstring.h:685
QChar::upper
QChar upper() const
Definition: qstring.cpp:11248
QChar::latin1
char latin1() const
Definition: qstring.h:150
QString::insert
QString & insert(uint index, char c)
Definition: qstring.h:448
QChar::decompositionTag
Decomposition decompositionTag() const
Definition: qstring.cpp:11210
QString::append
QString & append(char)
Definition: qstring.h:703
QString::operator<
bool operator<(const QString &s1, const char *s2)
Definition: qstring.cpp:14878
QString
The QString class provides an abstraction of Unicode text and the classic C null-terminated char arra...
Definition: qstring.h:350
QString::contains
int contains(char c, bool cs=TRUE) const
Definition: qstring.h:424
QString::operator>=
bool operator>=(const QString &s1, const char *s2)
Definition: qstring.cpp:14896
QChar::isPrint
bool isPrint() const
Definition: qstring.cpp:10996
QStringData
Definition: qstring.h:332
QString::data
const char * data() const
Definition: qstring.h:542
QString::fromLatin1
static QString fromLatin1(const char *, int len=-1)
Definition: qstring.cpp:14539
QChar
The QChar class provides a light-weight Unicode character.
Definition: qstring.h:56
QChar::category
Category category() const
Definition: qstring.cpp:11096
QString::~QString
~QString()
Definition: qstring.h:658
QChar::cell
uchar & cell()
Definition: qstring.h:167
QString::operator<=
bool operator<=(const QString &s1, const char *s2)
Definition: qstring.cpp:14884
QString::prepend
QString & prepend(char)
Definition: qstring.h:694
QString::constref
QChar constref(uint i) const
Definition: qstring.h:498
QString::unicode
const QChar * unicode() const
Definition: qstring.h:508
QString::setNum
QString & setNum(short, int base=10)
Definition: qstring.h:706
QString::isEmpty
bool isEmpty() const
Definition: qstring.h:682
QString::operator+=
QString & operator+=(const QString &str)
Definition: qstring.cpp:14399
QString::length
uint length() const
Definition: qstring.h:679
QChar::networkOrdered
static bool networkOrdered()
Definition: qstring.h:172
QChar::mirroredChar
QChar mirroredChar() const
Definition: qstring.cpp:11165
QChar::lower
QChar lower() const
Definition: qstring.cpp:11229
QString::operator+
QString operator+(const QString &s1, const QString &s2)
Definition: qstring.h:774
QString::lower
QString lower() const
Definition: qstring.cpp:13375
QString::upper
QString upper() const
Definition: qstring.cpp:13404
QString::isNull
bool isNull() const
Definition: qstring.h:379
QString::at
QChar at(uint i) const
Definition: qstring.h:492
QString::operator=
QString & operator=(const QString &)
Definition: qstring.cpp:12402
QString::compare
int compare(const QString &s) const
Definition: qstring.cpp:14838
QChar::Direction
Direction
Definition: qstring.h:118
QString::operator[]
QChar operator[](int i) const
Definition: qstring.h:494
QString::operator>
bool operator>(const QString &s1, const char *s2)
Definition: qstring.cpp:14890
QString::operator==
bool operator==(const QString &s1, const QString &s2)
Definition: qstring.cpp:14843
QCharRef
The QCharRef class is a helper class for QString.
Definition: qstring.h:568
QChar::cell
uchar cell() const
Definition: qstring.h:169
QString::arg
QString arg(long a, int fieldwidth=0, int base=10) const
Definition: qstring.cpp:12593
QString::findRev
int findRev(QChar c, int index=-1, bool cs=TRUE) const
Definition: qstring.cpp:13021
QChar::row
uchar & row()
Definition: qstring.h:168
QShared
The QShared struct is internally used for implementing shared classes.
Definition: qshared.h:46
QString::operator!=
bool operator!=(const QString &s1, const QString &s2)
Definition: qstring.cpp:14850
QDataStream
The QDataStream class provides serialization of binary data to a QIODevice.
Definition: qdatastream.h:47
QString::ref
QChar & ref(uint i)
Definition: qstring.h:500
QString::Null
Definition: qstring.h:375
QCString
This is an alternative implementation of QCString.
Definition: qcstring.h:131
QChar::decomposition
QString decomposition() const
Definition: qstring.cpp:11186
QString::compare
static int compare(const QString &s1, const QString &s2)
Definition: qstring.h:530
QChar::row
uchar row() const
Definition: qstring.h:170
QString::insert
QString & insert(uint index, const QString &)
Definition: qstring.cpp:13523
QString::find
int find(QChar c, int index=0, bool cs=TRUE) const
Definition: qstring.cpp:12902
QString::QString
QString()
Definition: qstring.h:652
QConstString::string
const QString & string() const
Definition: qstring.h:631
QChar::Decomposition
Decomposition
Definition: qstring.h:124
Generated by   doxygen 1.8.12