author | kergoth <kergoth> | 2002-11-01 00:10:42 (UTC) |
---|---|---|
committer | kergoth <kergoth> | 2002-11-01 00:10:42 (UTC) |
commit | 5042e3cf0d3514552769e441f5aad590c8eaf967 (patch) (unidiff) | |
tree | 4a5ea45f3519d981a172ab5275bf38c6fa778dec /qmake/include/qstring.h | |
parent | 108c1c753e74e989cc13923086996791428c9af4 (diff) | |
download | opie-5042e3cf0d3514552769e441f5aad590c8eaf967.zip opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.gz opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.bz2 |
Adding qmake in preperation for new build system
-rw-r--r-- | qmake/include/qstring.h | 950 |
1 files changed, 950 insertions, 0 deletions
diff --git a/qmake/include/qstring.h b/qmake/include/qstring.h new file mode 100644 index 0000000..2a87a5a --- a/dev/null +++ b/qmake/include/qstring.h | |||
@@ -0,0 +1,950 @@ | |||
1 | /**************************************************************************** | ||
2 | ** $Id$ | ||
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 | |||
47 | /***************************************************************************** | ||
48 | QString class | ||
49 | *****************************************************************************/ | ||
50 | |||
51 | class QRegExp; | ||
52 | class QString; | ||
53 | class QCharRef; | ||
54 | template <class T> class QDeepCopy; | ||
55 | |||
56 | class Q_EXPORT 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_Dash, // Pd | ||
106 | Punctuation_Dask = Punctuation_Dash, // oops | ||
107 | Punctuation_Open, // Ps | ||
108 | Punctuation_Close, // Pe | ||
109 | Punctuation_InitialQuote, // Pi | ||
110 | Punctuation_FinalQuote, // Pf | ||
111 | Punctuation_Other, // Po | ||
112 | |||
113 | Symbol_Math, // Sm | ||
114 | Symbol_Currency, // Sc | ||
115 | Symbol_Modifier, // Sk | ||
116 | Symbol_Other // So | ||
117 | }; | ||
118 | |||
119 | enum Direction | ||
120 | { | ||
121 | DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON, | ||
122 | DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN | ||
123 | }; | ||
124 | |||
125 | enum Decomposition | ||
126 | { | ||
127 | Single, Canonical, Font, NoBreak, Initial, Medial, | ||
128 | Final, Isolated, Circle, Super, Sub, Vertical, | ||
129 | Wide, Narrow, Small, Square, Compat, Fraction | ||
130 | }; | ||
131 | |||
132 | enum Joining | ||
133 | { | ||
134 | OtherJoining, Dual, Right, Center | ||
135 | }; | ||
136 | |||
137 | enum CombiningClass | ||
138 | { | ||
139 | Combining_BelowLeftAttached = 200, | ||
140 | Combining_BelowAttached = 202, | ||
141 | Combining_BelowRightAttached = 204, | ||
142 | Combining_LeftAttached = 208, | ||
143 | Combining_RightAttached = 210, | ||
144 | Combining_AboveLeftAttached = 212, | ||
145 | Combining_AboveAttached = 214, | ||
146 | Combining_AboveRightAttached = 216, | ||
147 | |||
148 | Combining_BelowLeft = 218, | ||
149 | Combining_Below = 220, | ||
150 | Combining_BelowRight = 222, | ||
151 | Combining_Left = 224, | ||
152 | Combining_Right = 226, | ||
153 | Combining_AboveLeft = 228, | ||
154 | Combining_Above = 230, | ||
155 | Combining_AboveRight = 232, | ||
156 | |||
157 | Combining_DoubleBelow = 233, | ||
158 | Combining_DoubleAbove = 234, | ||
159 | Combining_IotaSubscript = 240 | ||
160 | }; | ||
161 | |||
162 | // ****** WHEN ADDING FUNCTIONS, CONSIDER ADDING TO QCharRef TOO | ||
163 | |||
164 | int digitValue() const; | ||
165 | QChar lower() const; | ||
166 | QChar upper() const; | ||
167 | |||
168 | Category category() const; | ||
169 | Direction direction() const; | ||
170 | Joining joining() const; | ||
171 | bool mirrored() const; | ||
172 | QChar mirroredChar() const; | ||
173 | const QString &decomposition() const; // ### return just QString in 4.0 | ||
174 | Decomposition decompositionTag() const; | ||
175 | unsigned char combiningClass() const; | ||
176 | |||
177 | char latin1() const { return ucs > 0xff ? 0 : (char) ucs; } | ||
178 | ushort unicode() const { return ucs; } | ||
179 | ushort &unicode() { return ucs; } | ||
180 | #ifndef QT_NO_CAST_ASCII | ||
181 | // like all ifdef'd code this is undocumented | ||
182 | operator char() const { return latin1(); } | ||
183 | #endif | ||
184 | |||
185 | bool isNull() const { return unicode()==0; } | ||
186 | bool isPrint() const; | ||
187 | bool isPunct() const; | ||
188 | bool isSpace() const; | ||
189 | bool isMark() const; | ||
190 | bool isLetter() const; | ||
191 | bool isNumber() const; | ||
192 | bool isLetterOrNumber() const; | ||
193 | bool isDigit() const; | ||
194 | bool isSymbol() const; | ||
195 | |||
196 | uchar cell() const { return ((uchar) ucs & 0xff); } | ||
197 | uchar row() const { return ((uchar) (ucs>>8)&0xff); } | ||
198 | void setCell( uchar cell ) { ucs = (ucs & 0xff00) + cell; } | ||
199 | void setRow( uchar row ) { ucs = (((ushort) row)<<8) + (ucs&0xff); } | ||
200 | |||
201 | static bool networkOrdered() { | ||
202 | int wordSize; | ||
203 | bool bigEndian = FALSE; | ||
204 | qSysInfo( &wordSize, &bigEndian ); | ||
205 | return bigEndian; | ||
206 | } | ||
207 | |||
208 | friend inline bool operator==( char ch, QChar c ); | ||
209 | friend inline bool operator==( QChar c, char ch ); | ||
210 | friend inline bool operator==( QChar c1, QChar c2 ); | ||
211 | friend inline bool operator!=( QChar c1, QChar c2 ); | ||
212 | friend inline bool operator!=( char ch, QChar c ); | ||
213 | friend inline bool operator!=( QChar c, char ch ); | ||
214 | friend inline bool operator<=( QChar c, char ch ); | ||
215 | friend inline bool operator<=( char ch, QChar c ); | ||
216 | friend inline bool operator<=( QChar c1, QChar c2 ); | ||
217 | |||
218 | private: | ||
219 | ushort ucs; | ||
220 | #if defined(QT_QSTRING_UCS_4) | ||
221 | ushort grp; | ||
222 | #endif | ||
223 | } Q_PACKED; | ||
224 | |||
225 | inline QChar::QChar() : ucs( 0 ) | ||
226 | #ifdef QT_QSTRING_UCS_4 | ||
227 | , grp( 0 ) | ||
228 | #endif | ||
229 | { | ||
230 | } | ||
231 | inline QChar::QChar( char c ) : ucs( (uchar)c ) | ||
232 | #ifdef QT_QSTRING_UCS_4 | ||
233 | , grp( 0 ) | ||
234 | #endif | ||
235 | { | ||
236 | } | ||
237 | inline QChar::QChar( uchar c ) : ucs( c ) | ||
238 | #ifdef QT_QSTRING_UCS_4 | ||
239 | , grp( 0 ) | ||
240 | #endif | ||
241 | { | ||
242 | } | ||
243 | inline QChar::QChar( uchar c, uchar r ) : ucs( (r << 8) | c ) | ||
244 | #ifdef QT_QSTRING_UCS_4 | ||
245 | , grp( 0 ) | ||
246 | #endif | ||
247 | { | ||
248 | } | ||
249 | inline QChar::QChar( const QChar& c ) : ucs( c.ucs ) | ||
250 | #ifdef QT_QSTRING_UCS_4 | ||
251 | , grp( c.grp ) | ||
252 | #endif | ||
253 | { | ||
254 | } | ||
255 | |||
256 | inline QChar::QChar( ushort rc ) : ucs( rc ) | ||
257 | #ifdef QT_QSTRING_UCS_4 | ||
258 | , grp( 0 ) | ||
259 | #endif | ||
260 | { | ||
261 | } | ||
262 | inline QChar::QChar( short rc ) : ucs( (ushort) rc ) | ||
263 | #ifdef QT_QSTRING_UCS_4 | ||
264 | , grp( 0 ) | ||
265 | #endif | ||
266 | { | ||
267 | } | ||
268 | inline QChar::QChar( uint rc ) : ucs( (ushort ) (rc & 0xffff) ) | ||
269 | #ifdef QT_QSTRING_UCS_4 | ||
270 | , grp( (ushort) ((rc >> 16) & 0xffff) ) | ||
271 | #endif | ||
272 | { | ||
273 | } | ||
274 | inline QChar::QChar( int rc ) : ucs( (ushort) (rc & 0xffff) ) | ||
275 | #ifdef QT_QSTRING_UCS_4 | ||
276 | , grp( (ushort) ((rc >> 16) & 0xffff) ) | ||
277 | #endif | ||
278 | { | ||
279 | } | ||
280 | |||
281 | inline bool operator==( char ch, QChar c ) | ||
282 | { | ||
283 | return ((uchar) ch) == c.ucs; | ||
284 | } | ||
285 | |||
286 | inline bool operator==( QChar c, char ch ) | ||
287 | { | ||
288 | return ((uchar) ch) == c.ucs; | ||
289 | } | ||
290 | |||
291 | inline bool operator==( QChar c1, QChar c2 ) | ||
292 | { | ||
293 | return c1.ucs == c2.ucs; | ||
294 | } | ||
295 | |||
296 | inline bool operator!=( QChar c1, QChar c2 ) | ||
297 | { | ||
298 | return c1.ucs != c2.ucs; | ||
299 | } | ||
300 | |||
301 | inline bool operator!=( char ch, QChar c ) | ||
302 | { | ||
303 | return ((uchar)ch) != c.ucs; | ||
304 | } | ||
305 | |||
306 | inline bool operator!=( QChar c, char ch ) | ||
307 | { | ||
308 | return ((uchar) ch) != c.ucs; | ||
309 | } | ||
310 | |||
311 | inline bool operator<=( QChar c, char ch ) | ||
312 | { | ||
313 | return c.ucs <= ((uchar) ch); | ||
314 | } | ||
315 | |||
316 | inline bool operator<=( char ch, QChar c ) | ||
317 | { | ||
318 | return ((uchar) ch) <= c.ucs; | ||
319 | } | ||
320 | |||
321 | inline bool operator<=( QChar c1, QChar c2 ) | ||
322 | { | ||
323 | return c1.ucs <= c2.ucs; | ||
324 | } | ||
325 | |||
326 | inline bool operator>=( QChar c, char ch ) { return ch <= c; } | ||
327 | inline bool operator>=( char ch, QChar c ) { return c <= ch; } | ||
328 | inline bool operator>=( QChar c1, QChar c2 ) { return c2 <= c1; } | ||
329 | inline bool operator<( QChar c, char ch ) { return !(ch<=c); } | ||
330 | inline bool operator<( char ch, QChar c ) { return !(c<=ch); } | ||
331 | inline bool operator<( QChar c1, QChar c2 ) { return !(c2<=c1); } | ||
332 | inline bool operator>( QChar c, char ch ) { return !(ch>=c); } | ||
333 | inline bool operator>( char ch, QChar c ) { return !(c>=ch); } | ||
334 | inline bool operator>( QChar c1, QChar c2 ) { return !(c2>=c1); } | ||
335 | |||
336 | // internal | ||
337 | struct Q_EXPORT QStringData : public QShared { | ||
338 | QStringData() : | ||
339 | QShared(), unicode(0), ascii(0), len(0), simpletext(1), maxl(0), dirty(0) { ref(); } | ||
340 | QStringData(QChar *u, uint l, uint m) : | ||
341 | QShared(), unicode(u), ascii(0), len(l), simpletext(1), maxl(m), dirty(1) { } | ||
342 | ~QStringData() { if ( unicode ) delete[] ((char*)unicode); | ||
343 | if ( ascii ) delete[] ascii; } | ||
344 | |||
345 | void deleteSelf(); | ||
346 | QChar *unicode; | ||
347 | char *ascii; | ||
348 | void setDirty() { | ||
349 | if ( ascii ) { | ||
350 | delete [] ascii; | ||
351 | ascii = 0; | ||
352 | } | ||
353 | dirty = 1; | ||
354 | } | ||
355 | #ifdef Q_OS_MAC9 | ||
356 | uint len; | ||
357 | #else | ||
358 | uint len : 30; | ||
359 | #endif | ||
360 | uint simpletext : 1; | ||
361 | #ifdef Q_OS_MAC9 | ||
362 | uint maxl; | ||
363 | #else | ||
364 | uint maxl : 30; | ||
365 | #endif | ||
366 | uint dirty : 1; | ||
367 | |||
368 | private: | ||
369 | #if defined(Q_DISABLE_COPY) | ||
370 | QStringData( const QStringData& ); | ||
371 | QStringData& operator=( const QStringData& ); | ||
372 | #endif | ||
373 | }; | ||
374 | |||
375 | |||
376 | class Q_EXPORT QString | ||
377 | { | ||
378 | public: | ||
379 | QString(); // make null string | ||
380 | QString( QChar ); // one-char string | ||
381 | QString( const QString & ); // impl-shared copy | ||
382 | QString( const QByteArray& ); // deep copy | ||
383 | QString( const QChar* unicode, uint length ); // deep copy | ||
384 | #ifndef QT_NO_CAST_ASCII | ||
385 | QString( const char *str ); // deep copy | ||
386 | #endif | ||
387 | ~QString(); | ||
388 | |||
389 | QString &operator=( const QString & ); // impl-shared copy | ||
390 | #ifndef QT_NO_CAST_ASCII | ||
391 | QString &operator=( const char * ); // deep copy | ||
392 | #endif | ||
393 | QString &operator=( const QCString& ); // deep copy | ||
394 | QString &operator=( QChar c ); | ||
395 | QString &operator=( char c ); | ||
396 | |||
397 | QT_STATIC_CONST QString null; | ||
398 | |||
399 | bool isNull() const; | ||
400 | bool isEmpty() const; | ||
401 | uint length() const; | ||
402 | void truncate( uint pos ); | ||
403 | |||
404 | QString & fill( QChar c, int len = -1 ); | ||
405 | |||
406 | QString copy() const; | ||
407 | |||
408 | QString arg( long a, int fieldwidth=0, int base=10 ) const; | ||
409 | QString arg( ulong a, int fieldwidth=0, int base=10 ) const; | ||
410 | QString arg( int a, int fieldwidth=0, int base=10 ) const; | ||
411 | QString arg( uint a, int fieldwidth=0, int base=10 ) const; | ||
412 | QString arg( short a, int fieldwidth=0, int base=10 ) const; | ||
413 | QString arg( ushort a, int fieldwidth=0, int base=10 ) const; | ||
414 | QString arg( char a, int fieldwidth=0 ) const; | ||
415 | QString arg( QChar a, int fieldwidth=0 ) const; | ||
416 | QString arg( const QString& a, int fieldwidth=0 ) const; | ||
417 | QString arg( double a, int fieldwidth=0, char fmt='g', int prec=-1 ) const; | ||
418 | |||
419 | #ifndef QT_NO_SPRINTF | ||
420 | QString &sprintf( const char* format, ... ) | ||
421 | #if defined(Q_CC_GNU) && !defined(__INSURE__) | ||
422 | __attribute__ ((format (printf, 2, 3))) | ||
423 | #endif | ||
424 | ; | ||
425 | #endif | ||
426 | |||
427 | int find( QChar c, int index=0, bool cs=TRUE ) const; | ||
428 | int find( char c, int index=0, bool cs=TRUE ) const; | ||
429 | int find( const QString &str, int index=0, bool cs=TRUE ) const; | ||
430 | #ifndef QT_NO_REGEXP | ||
431 | int find( const QRegExp &, int index=0 ) const; | ||
432 | #endif | ||
433 | #ifndef QT_NO_CAST_ASCII | ||
434 | int find( const char* str, int index=0 ) const; | ||
435 | #endif | ||
436 | int findRev( QChar c, int index=-1, bool cs=TRUE) const; | ||
437 | int findRev( char c, int index=-1, bool cs=TRUE) const; | ||
438 | int findRev( const QString &str, int index=-1, bool cs=TRUE) const; | ||
439 | #ifndef QT_NO_REGEXP | ||
440 | int findRev( const QRegExp &, int index=-1 ) const; | ||
441 | #endif | ||
442 | #ifndef QT_NO_CAST_ASCII | ||
443 | int findRev( const char* str, int index=-1 ) const; | ||
444 | #endif | ||
445 | int contains( QChar c, bool cs=TRUE ) const; | ||
446 | int contains( char c, bool cs=TRUE ) const | ||
447 | { return contains(QChar(c), cs); } | ||
448 | #ifndef QT_NO_CAST_ASCII | ||
449 | int contains( const char* str, bool cs=TRUE ) const; | ||
450 | #endif | ||
451 | int contains( const QString &str, bool cs=TRUE ) const; | ||
452 | #ifndef QT_NO_REGEXP | ||
453 | int contains( const QRegExp & ) const; | ||
454 | #endif | ||
455 | |||
456 | enum SectionFlags { | ||
457 | SectionDefault = 0x00, | ||
458 | SectionSkipEmpty = 0x01, | ||
459 | SectionIncludeLeadingSep = 0x02, | ||
460 | SectionIncludeTrailingSep = 0x04, | ||
461 | SectionCaseInsensitiveSeps = 0x08 | ||
462 | }; | ||
463 | QString section( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; | ||
464 | QString section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; | ||
465 | #ifndef QT_NO_CAST_ASCII | ||
466 | QString section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; | ||
467 | #endif | ||
468 | QString section( const QString &in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const; | ||
469 | #ifndef QT_NO_REGEXP | ||
470 | QString section( const QRegExp ®, int start, int end = 0xffffffff, int flags = SectionDefault ) const; | ||
471 | #endif | ||
472 | |||
473 | QString left( uint len ) const; | ||
474 | QString right( uint len ) const; | ||
475 | QString mid( uint index, uint len=0xffffffff) const; | ||
476 | |||
477 | QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const; | ||
478 | QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const; | ||
479 | |||
480 | QString lower() const; | ||
481 | QString upper() const; | ||
482 | |||
483 | QString stripWhiteSpace() const; | ||
484 | QString simplifyWhiteSpace() const; | ||
485 | |||
486 | QString &insert( uint index, const QString & ); | ||
487 | QString &insert( uint index, const QChar*, uint len ); | ||
488 | QString &insert( uint index, QChar ); | ||
489 | QString &insert( uint index, char c ) { return insert(index,QChar(c)); } | ||
490 | QString &append( char ); | ||
491 | QString &append( QChar ); | ||
492 | QString &append( const QString & ); | ||
493 | #ifndef QT_NO_CAST_ASCII | ||
494 | QString &append( const QByteArray & ); | ||
495 | QString &append( const char * ); | ||
496 | #endif | ||
497 | QString &prepend( char ); | ||
498 | QString &prepend( QChar ); | ||
499 | QString &prepend( const QString & ); | ||
500 | #ifndef QT_NO_CAST_ASCII | ||
501 | QString &prepend( const QByteArray & ); | ||
502 | QString &prepend( const char * ); | ||
503 | #endif | ||
504 | QString &remove( uint index, uint len ); | ||
505 | QString &remove( QChar c ); | ||
506 | QString &remove( char c ) { return remove( QChar(c) ); } | ||
507 | QString &remove( const QString & ); | ||
508 | #ifndef QT_NO_REGEXP | ||
509 | QString &remove( const QRegExp & ); | ||
510 | #endif | ||
511 | #ifndef QT_NO_CAST_ASCII | ||
512 | QString &remove( const char * ); | ||
513 | #endif | ||
514 | QString &replace( uint index, uint len, const QString & ); | ||
515 | QString &replace( uint index, uint len, const QChar*, uint clen ); | ||
516 | QString &replace( uint index, uint len, QChar ); | ||
517 | QString &replace( uint index, uint len, char c ) | ||
518 | { return replace( index, len, QChar(c) ); } | ||
519 | QString &replace( QChar c, const QString & ); | ||
520 | QString &replace( char c, const QString & after ) | ||
521 | { return replace( QChar(c), after ); } | ||
522 | QString &replace( const QString &, const QString & ); | ||
523 | #ifndef QT_NO_REGEXP_CAPTURE | ||
524 | QString &replace( const QRegExp &, const QString & ); | ||
525 | #endif | ||
526 | QString &replace( QChar, QChar ); | ||
527 | |||
528 | short toShort( bool *ok=0, int base=10 ) const; | ||
529 | ushort toUShort( bool *ok=0, int base=10 ) const; | ||
530 | int toInt( bool *ok=0, int base=10 ) const; | ||
531 | uint toUInt( bool *ok=0, int base=10 ) const; | ||
532 | long toLong( bool *ok=0, int base=10 ) const; | ||
533 | ulong toULong( bool *ok=0, int base=10 ) const; | ||
534 | float toFloat( bool *ok=0 ) const; | ||
535 | double toDouble( bool *ok=0 ) const; | ||
536 | |||
537 | QString &setNum( short, int base=10 ); | ||
538 | QString &setNum( ushort, int base=10 ); | ||
539 | QString &setNum( int, int base=10 ); | ||
540 | QString &setNum( uint, int base=10 ); | ||
541 | QString &setNum( long, int base=10 ); | ||
542 | QString &setNum( ulong, int base=10 ); | ||
543 | QString &setNum( float, char f='g', int prec=6 ); | ||
544 | QString &setNum( double, char f='g', int prec=6 ); | ||
545 | |||
546 | static QString number( long, int base=10 ); | ||
547 | static QString number( ulong, int base=10); | ||
548 | static QString number( int, int base=10 ); | ||
549 | static QString number( uint, int base=10); | ||
550 | static QString number( double, char f='g', int prec=6 ); | ||
551 | |||
552 | void setExpand( uint index, QChar c ); | ||
553 | |||
554 | QString &operator+=( const QString &str ); | ||
555 | #ifndef QT_NO_CAST_ASCII | ||
556 | QString &operator+=( const QByteArray &str ); | ||
557 | QString &operator+=( const char *str ); | ||
558 | #endif | ||
559 | QString &operator+=( QChar c ); | ||
560 | QString &operator+=( char c ); | ||
561 | |||
562 | QChar at( uint i ) const | ||
563 | { return i < d->len ? d->unicode[i] : QChar::null; } | ||
564 | QChar operator[]( int i ) const { return at((uint)i); } | ||
565 | QCharRef at( uint i ); | ||
566 | QCharRef operator[]( int i ); | ||
567 | |||
568 | QChar constref(uint i) const | ||
569 | { return at(i); } | ||
570 | QChar& ref(uint i) | ||
571 | { // Optimized for easy-inlining by simple compilers. | ||
572 | if ( d->count != 1 || i >= d->len ) | ||
573 | subat( i ); | ||
574 | d->setDirty(); | ||
575 | return d->unicode[i]; | ||
576 | } | ||
577 | |||
578 | const QChar* unicode() const { return d->unicode; } | ||
579 | const char* ascii() const { return latin1(); } | ||
580 | const char* latin1() const; | ||
581 | static QString fromLatin1(const char*, int len=-1); | ||
582 | QCString utf8() const; | ||
583 | static QString fromUtf8(const char*, int len=-1); | ||
584 | QCString local8Bit() const; | ||
585 | static QString fromLocal8Bit(const char*, int len=-1); | ||
586 | bool operator!() const; | ||
587 | #ifndef QT_NO_ASCII_CAST | ||
588 | operator const char *() const { return latin1(); } | ||
589 | #endif | ||
590 | static QString fromUcs2( const unsigned short *ucs2 ); | ||
591 | const unsigned short *ucs2() const; | ||
592 | |||
593 | QString &setUnicode( const QChar* unicode, uint len ); | ||
594 | QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len ); | ||
595 | QString &setLatin1( const char*, int len=-1 ); | ||
596 | |||
597 | int compare( const QString& s ) const; | ||
598 | static int compare( const QString& s1, const QString& s2 ) | ||
599 | { return s1.compare( s2 ); } | ||
600 | |||
601 | int localeAwareCompare( const QString& s ) const; | ||
602 | static int localeAwareCompare( const QString& s1, const QString& s2 ) | ||
603 | { return s1.localeAwareCompare( s2 ); } | ||
604 | |||
605 | #ifndef QT_NO_DATASTREAM | ||
606 | friend Q_EXPORT QDataStream &operator>>( QDataStream &, QString & ); | ||
607 | #endif | ||
608 | |||
609 | void compose(); | ||
610 | |||
611 | #ifndef QT_NO_COMPAT | ||
612 | const char* data() const { return latin1(); } | ||
613 | #endif | ||
614 | |||
615 | bool startsWith( const QString& ) const; | ||
616 | bool endsWith( const QString& ) const; | ||
617 | |||
618 | void setLength( uint newLength ); | ||
619 | |||
620 | bool simpleText() const { if ( d->dirty ) checkSimpleText(); return (bool)d->simpletext; } | ||
621 | bool isRightToLeft() const; | ||
622 | |||
623 | |||
624 | private: | ||
625 | QString( int size, bool /* dummy */ );// allocate size incl. \0 | ||
626 | |||
627 | void deref(); | ||
628 | void real_detach(); | ||
629 | void subat( uint ); | ||
630 | bool findArg(int& pos, int& len) const; | ||
631 | |||
632 | void checkSimpleText() const; | ||
633 | |||
634 | static QChar* asciiToUnicode( const char*, uint * len, uint maxlen=(uint)-1 ); | ||
635 | static QChar* asciiToUnicode( const QByteArray&, uint * len ); | ||
636 | static char* unicodeToAscii( const QChar*, uint len ); | ||
637 | |||
638 | QStringData *d; | ||
639 | static QStringData* shared_null; | ||
640 | static QStringData* makeSharedNull(); | ||
641 | |||
642 | friend class QConstString; | ||
643 | friend class QTextStream; | ||
644 | QString( QStringData* dd, bool /* dummy */ ) : d(dd) { } | ||
645 | |||
646 | // needed for QDeepCopy | ||
647 | void detach(); | ||
648 | friend class QDeepCopy<QString>; | ||
649 | }; | ||
650 | |||
651 | class Q_EXPORT QCharRef { | ||
652 | friend class QString; | ||
653 | QString& s; | ||
654 | uint p; | ||
655 | QCharRef(QString* str, uint pos) : s(*str), p(pos) { } | ||
656 | |||
657 | public: | ||
658 | // most QChar operations repeated here... | ||
659 | |||
660 | // all this is not documented: We just say "like QChar" and let it be. | ||
661 | #ifndef Q_QDOC | ||
662 | ushort unicode() const { return s.constref(p).unicode(); } | ||
663 | char latin1() const { return s.constref(p).latin1(); } | ||
664 | |||
665 | // An operator= for each QChar cast constructor... | ||
666 | QCharRef operator=(char c ) { s.ref(p)=c; return *this; } | ||
667 | QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; } | ||
668 | QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; } | ||
669 | QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; } | ||
670 | QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; } | ||
671 | QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; } | ||
672 | QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; } | ||
673 | QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; } | ||
674 | |||
675 | operator QChar () const { return s.constref(p); } | ||
676 | |||
677 | // each function... | ||
678 | bool isNull() const { return unicode()==0; } | ||
679 | bool isPrint() const { return s.constref(p).isPrint(); } | ||
680 | bool isPunct() const { return s.constref(p).isPunct(); } | ||
681 | bool isSpace() const { return s.constref(p).isSpace(); } | ||
682 | bool isMark() const { return s.constref(p).isMark(); } | ||
683 | bool isLetter() const { return s.constref(p).isLetter(); } | ||
684 | bool isNumber() const { return s.constref(p).isNumber(); } | ||
685 | bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); } | ||
686 | bool isDigit() const { return s.constref(p).isDigit(); } | ||
687 | |||
688 | int digitValue() const { return s.constref(p).digitValue(); } | ||
689 | QChar lower() const { return s.constref(p).lower(); } | ||
690 | QChar upper() const { return s.constref(p).upper(); } | ||
691 | |||
692 | QChar::Category category() const { return s.constref(p).category(); } | ||
693 | QChar::Direction direction() const { return s.constref(p).direction(); } | ||
694 | QChar::Joining joining() const { return s.constref(p).joining(); } | ||
695 | bool mirrored() const { return s.constref(p).mirrored(); } | ||
696 | QChar mirroredChar() const { return s.constref(p).mirroredChar(); } | ||
697 | const QString &decomposition() const { return s.constref(p).decomposition(); } | ||
698 | QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); } | ||
699 | unsigned char combiningClass() const { return s.constref(p).combiningClass(); } | ||
700 | |||
701 | // Not the non-const ones of these. | ||
702 | uchar cell() const { return s.constref(p).cell(); } | ||
703 | uchar row() const { return s.constref(p).row(); } | ||
704 | #endif | ||
705 | }; | ||
706 | |||
707 | inline QCharRef QString::at( uint i ) { return QCharRef(this,i); } | ||
708 | inline QCharRef QString::operator[]( int i ) { return at((uint)i); } | ||
709 | |||
710 | |||
711 | class Q_EXPORT QConstString : private QString { | ||
712 | public: | ||
713 | QConstString( const QChar* unicode, uint length ); | ||
714 | ~QConstString(); | ||
715 | const QString& string() const { return *this; } | ||
716 | }; | ||
717 | |||
718 | |||
719 | /***************************************************************************** | ||
720 | QString stream functions | ||
721 | *****************************************************************************/ | ||
722 | #ifndef QT_NO_DATASTREAM | ||
723 | Q_EXPORT QDataStream &operator<<( QDataStream &, const QString & ); | ||
724 | Q_EXPORT QDataStream &operator>>( QDataStream &, QString & ); | ||
725 | #endif | ||
726 | |||
727 | /***************************************************************************** | ||
728 | QString inline functions | ||
729 | *****************************************************************************/ | ||
730 | |||
731 | // These two move code into makeSharedNull() and deletesData() | ||
732 | // to improve cache-coherence (and reduce code bloat), while | ||
733 | // keeping the common cases fast. | ||
734 | // | ||
735 | // No safe way to pre-init shared_null on ALL compilers/linkers. | ||
736 | inline QString::QString() : | ||
737 | d(shared_null ? shared_null : makeSharedNull()) | ||
738 | { | ||
739 | d->ref(); | ||
740 | } | ||
741 | // | ||
742 | inline QString::~QString() | ||
743 | { | ||
744 | if ( d->deref() ) { | ||
745 | if ( d != shared_null ) | ||
746 | d->deleteSelf(); | ||
747 | } | ||
748 | } | ||
749 | |||
750 | // needed for QDeepCopy | ||
751 | inline void QString::detach() | ||
752 | { real_detach(); } | ||
753 | |||
754 | inline QString QString::section( QChar sep, int start, int end, int flags ) const | ||
755 | { return section(QString(sep), start, end, flags); } | ||
756 | |||
757 | inline QString QString::section( char sep, int start, int end, int flags ) const | ||
758 | { return section(QChar(sep), start, end, flags); } | ||
759 | |||
760 | #ifndef QT_NO_CAST_ASCII | ||
761 | inline QString QString::section( const char *in_sep, int start, int end, int flags ) const | ||
762 | { return section(QString(in_sep), start, end, flags); } | ||
763 | #endif | ||
764 | |||
765 | inline QString &QString::operator=( QChar c ) | ||
766 | { *this = QString(c); return *this; } | ||
767 | |||
768 | inline QString &QString::operator=( char c ) | ||
769 | { *this = QString(QChar(c)); return *this; } | ||
770 | |||
771 | inline bool QString::isNull() const | ||
772 | { return unicode() == 0; } | ||
773 | |||
774 | inline bool QString::operator!() const | ||
775 | { return isNull(); } | ||
776 | |||
777 | inline uint QString::length() const | ||
778 | { return d->len; } | ||
779 | |||
780 | inline bool QString::isEmpty() const | ||
781 | { return length() == 0; } | ||
782 | |||
783 | inline QString QString::copy() const | ||
784 | { return QString( *this ); } | ||
785 | |||
786 | inline QString &QString::prepend( const QString & s ) | ||
787 | { return insert(0,s); } | ||
788 | |||
789 | inline QString &QString::prepend( QChar c ) | ||
790 | { return insert(0,c); } | ||
791 | |||
792 | inline QString &QString::prepend( char c ) | ||
793 | { return insert(0,c); } | ||
794 | |||
795 | #ifndef QT_NO_CAST_ASCII | ||
796 | inline QString &QString::prepend( const QByteArray & s ) | ||
797 | { return insert(0,s.data()); } | ||
798 | #endif | ||
799 | |||
800 | inline QString &QString::append( const QString & s ) | ||
801 | { return operator+=(s); } | ||
802 | |||
803 | #ifndef QT_NO_CAST_ASCII | ||
804 | inline QString &QString::append( const QByteArray &s ) | ||
805 | { return operator+=(s.data()); } | ||
806 | |||
807 | inline QString &QString::append( const char * s ) | ||
808 | { return operator+=(s); } | ||
809 | #endif | ||
810 | |||
811 | inline QString &QString::append( QChar c ) | ||
812 | { return operator+=(c); } | ||
813 | |||
814 | inline QString &QString::append( char c ) | ||
815 | { return operator+=(c); } | ||
816 | |||
817 | #ifndef QT_NO_CAST_ASCII | ||
818 | inline QString &QString::operator+=( const QByteArray &s ) | ||
819 | { return operator+=(s.data()); } | ||
820 | #endif | ||
821 | |||
822 | inline QString &QString::setNum( short n, int base ) | ||
823 | { return setNum((long)n, base); } | ||
824 | |||
825 | inline QString &QString::setNum( ushort n, int base ) | ||
826 | { return setNum((ulong)n, base); } | ||
827 | |||
828 | inline QString &QString::setNum( int n, int base ) | ||
829 | { return setNum((long)n, base); } | ||
830 | |||
831 | inline QString &QString::setNum( uint n, int base ) | ||
832 | { return setNum((ulong)n, base); } | ||
833 | |||
834 | inline QString &QString::setNum( float n, char f, int prec ) | ||
835 | { return setNum((double)n,f,prec); } | ||
836 | |||
837 | inline QString QString::arg(int a, int fieldwidth, int base) const | ||
838 | { return arg((long)a, fieldwidth, base); } | ||
839 | |||
840 | inline QString QString::arg(uint a, int fieldwidth, int base) const | ||
841 | { return arg((ulong)a, fieldwidth, base); } | ||
842 | |||
843 | inline QString QString::arg(short a, int fieldwidth, int base) const | ||
844 | { return arg((long)a, fieldwidth, base); } | ||
845 | |||
846 | inline QString QString::arg(ushort a, int fieldwidth, int base) const | ||
847 | { return arg((ulong)a, fieldwidth, base); } | ||
848 | |||
849 | inline int QString::find( char c, int index, bool cs ) const | ||
850 | { return find(QChar(c), index, cs); } | ||
851 | |||
852 | inline int QString::findRev( char c, int index, bool cs) const | ||
853 | { return findRev( QChar(c), index, cs ); } | ||
854 | |||
855 | #ifndef QT_NO_CAST_ASCII | ||
856 | inline int QString::find( const char* str, int index ) const | ||
857 | { return find(QString::fromLatin1(str), index); } | ||
858 | |||
859 | inline int QString::findRev( const char* str, int index ) const | ||
860 | { return findRev(QString::fromLatin1(str), index); } | ||
861 | #endif | ||
862 | |||
863 | |||
864 | /***************************************************************************** | ||
865 | QString non-member operators | ||
866 | *****************************************************************************/ | ||
867 | |||
868 | Q_EXPORT bool operator!=( const QString &s1, const QString &s2 ); | ||
869 | Q_EXPORT bool operator<( const QString &s1, const QString &s2 ); | ||
870 | Q_EXPORT bool operator<=( const QString &s1, const QString &s2 ); | ||
871 | Q_EXPORT bool operator==( const QString &s1, const QString &s2 ); | ||
872 | Q_EXPORT bool operator>( const QString &s1, const QString &s2 ); | ||
873 | Q_EXPORT bool operator>=( const QString &s1, const QString &s2 ); | ||
874 | #ifndef QT_NO_CAST_ASCII | ||
875 | Q_EXPORT bool operator!=( const QString &s1, const char *s2 ); | ||
876 | Q_EXPORT bool operator<( const QString &s1, const char *s2 ); | ||
877 | Q_EXPORT bool operator<=( const QString &s1, const char *s2 ); | ||
878 | Q_EXPORT bool operator==( const QString &s1, const char *s2 ); | ||
879 | Q_EXPORT bool operator>( const QString &s1, const char *s2 ); | ||
880 | Q_EXPORT bool operator>=( const QString &s1, const char *s2 ); | ||
881 | Q_EXPORT bool operator!=( const char *s1, const QString &s2 ); | ||
882 | Q_EXPORT bool operator<( const char *s1, const QString &s2 ); | ||
883 | Q_EXPORT bool operator<=( const char *s1, const QString &s2 ); | ||
884 | Q_EXPORT bool operator==( const char *s1, const QString &s2 ); | ||
885 | //Q_EXPORT bool operator>( const char *s1, const QString &s2 ); // MSVC++ | ||
886 | Q_EXPORT bool operator>=( const char *s1, const QString &s2 ); | ||
887 | #endif | ||
888 | |||
889 | Q_EXPORT inline const QString operator+( const QString &s1, const QString &s2 ) | ||
890 | { | ||
891 | QString tmp( s1 ); | ||
892 | tmp += s2; | ||
893 | return tmp; | ||
894 | } | ||
895 | |||
896 | #ifndef QT_NO_CAST_ASCII | ||
897 | Q_EXPORT inline const QString operator+( const QString &s1, const char *s2 ) | ||
898 | { | ||
899 | QString tmp( s1 ); | ||
900 | tmp += QString::fromLatin1(s2); | ||
901 | return tmp; | ||
902 | } | ||
903 | |||
904 | Q_EXPORT inline const QString operator+( const char *s1, const QString &s2 ) | ||
905 | { | ||
906 | QString tmp = QString::fromLatin1( s1 ); | ||
907 | tmp += s2; | ||
908 | return tmp; | ||
909 | } | ||
910 | #endif | ||
911 | |||
912 | Q_EXPORT inline const QString operator+( const QString &s1, QChar c2 ) | ||
913 | { | ||
914 | QString tmp( s1 ); | ||
915 | tmp += c2; | ||
916 | return tmp; | ||
917 | } | ||
918 | |||
919 | Q_EXPORT inline const QString operator+( const QString &s1, char c2 ) | ||
920 | { | ||
921 | QString tmp( s1 ); | ||
922 | tmp += c2; | ||
923 | return tmp; | ||
924 | } | ||
925 | |||
926 | Q_EXPORT inline const QString operator+( QChar c1, const QString &s2 ) | ||
927 | { | ||
928 | QString tmp; | ||
929 | tmp += c1; | ||
930 | tmp += s2; | ||
931 | return tmp; | ||
932 | } | ||
933 | |||
934 | Q_EXPORT inline const QString operator+( char c1, const QString &s2 ) | ||
935 | { | ||
936 | QString tmp; | ||
937 | tmp += c1; | ||
938 | tmp += s2; | ||
939 | return tmp; | ||
940 | } | ||
941 | |||
942 | #if defined(Q_OS_WIN32) | ||
943 | extern Q_EXPORT QString qt_winQString(void*); | ||
944 | extern Q_EXPORT const void* qt_winTchar(const QString& str, bool addnul); | ||
945 | extern Q_EXPORT void* qt_winTchar_new(const QString& str); | ||
946 | extern Q_EXPORT QCString qt_winQString2MB( const QString& s, int len=-1 ); | ||
947 | extern Q_EXPORT QString qt_winMB2QString( const char* mb, int len=-1 ); | ||
948 | #endif | ||
949 | |||
950 | #endif // QSTRING_H | ||