← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/corelib/tools/qstring.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/corelib/tools/qstring.h
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the core module of the Qt Toolkit.
 
6
**
 
7
** This file may be distributed under the terms of the Q Public License
 
8
** as defined by Trolltech AS of Norway and appearing in the file
 
9
** LICENSE.QPL included in the packaging of this file.
 
10
**
 
11
** This file may be distributed and/or modified under the terms of the
 
12
** GNU General Public License version 2 as published by the Free Software
 
13
** Foundation and appearing in the file LICENSE.GPL included in the
 
14
** packaging of this file.
 
15
**
 
16
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
17
**   information about Qt Commercial License Agreements.
 
18
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
19
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
20
**
 
21
** Contact info@trolltech.com if any conditions of this licensing are
 
22
** not clear to you.
 
23
**
 
24
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
25
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
#ifndef QSTRING_H
 
30
#define QSTRING_H
 
31
 
 
32
#include "QtCore/qchar.h"
 
33
#include "QtCore/qbytearray.h"
 
34
#include "QtCore/qatomic.h"
 
35
#include "QtCore/qnamespace.h"
 
36
 
 
37
#ifdef QT_INCLUDE_COMPAT
 
38
#include <qcstring.h>
 
39
#endif
 
40
 
 
41
#ifndef QT_NO_STL
 
42
# if defined (Q_CC_MSVC_NET) && _MSV_VER < 1310 // Avoids nasty warning for xlocale, line 450
 
43
#  pragma warning (push)
 
44
#  pragma warning (disable : 4189)
 
45
#  include <string>
 
46
#  pragma warning (pop)
 
47
# else
 
48
#  include <string>
 
49
# endif
 
50
 
 
51
#ifndef QT_NO_STL_WCHAR
 
52
// workaround for some headers not typedef'ing std::wstring
 
53
typedef std::basic_string<wchar_t> QStdWString;
 
54
#endif // QT_NO_STL_WCHAR
 
55
 
 
56
#endif // QT_NO_STL
 
57
 
 
58
 
 
59
#include <stdarg.h>
 
60
 
 
61
// POSIX defines truncate to truncate64
 
62
#ifdef truncate
 
63
#error qstring.h must be included before any header file that defines truncate
 
64
#endif
 
65
 
 
66
class QCharRef;
 
67
class QRegExp;
 
68
class QStringList;
 
69
class QTextCodec;
 
70
class QLatin1String;
 
71
 
 
72
class Q_CORE_EXPORT QString
 
73
{
 
74
public:
 
75
    inline QString();
 
76
    QString(const QChar *unicode, int size);
 
77
    explicit QString(QChar c);
 
78
    QString(int size, QChar c);
 
79
    inline QString(const QLatin1String &latin1);
 
80
    inline QString(const QString &);
 
81
    inline ~QString();
 
82
    QString &operator=(QChar c);
 
83
    QString &operator=(const QString &);
 
84
    inline QString &operator=(const QLatin1String &);
 
85
 
 
86
    inline int size() const { return d->size; }
 
87
    inline int count() const { return d->size; }
 
88
    inline int length() const;
 
89
    inline bool isEmpty() const;
 
90
    void resize(int size);
 
91
 
 
92
    QString &fill(QChar c, int size = -1);
 
93
    void truncate(int pos);
 
94
    void chop(int n);
 
95
 
 
96
    int capacity() const;
 
97
    inline void reserve(int size);
 
98
    inline void squeeze() { if (d->size < d->alloc) realloc(); }
 
99
 
 
100
    inline const QChar *unicode() const;
 
101
    inline QChar *data();
 
102
    inline const QChar *data() const;
 
103
    inline const QChar *constData() const;
 
104
 
 
105
    inline void detach();
 
106
    inline bool isDetached() const;
 
107
    void clear();
 
108
 
 
109
    inline const QChar at(int i) const;
 
110
    const QChar operator[](int i) const;
 
111
    QCharRef operator[](int i);
 
112
    const QChar operator[](uint i) const;
 
113
    QCharRef operator[](uint i);
 
114
 
 
115
    QString arg(qlonglong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
 
116
    QString arg(qulonglong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
 
117
    QString arg(long a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
 
118
    QString arg(ulong a, int fieldwidth=0, int base=10, const QChar &fillChar = QLatin1Char(' ')) const;
 
119
    QString arg(int a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
 
120
    QString arg(uint a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
 
121
    QString arg(short a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
 
122
    QString arg(ushort a, int fieldWidth = 0, int base = 10, const QChar &fillChar = QLatin1Char(' ')) const;
 
123
    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, const QChar &fillChar = QLatin1Char(' ')) const;
 
124
    QString arg(char a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
 
125
    QString arg(QChar a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
 
126
    QString arg(const QString &a, int fieldWidth = 0, const QChar &fillChar = QLatin1Char(' ')) const;
 
127
    QString arg(const QString &a1, const QString &a2) const;
 
128
    QString arg(const QString &a1, const QString &a2, const QString &a3) const;
 
129
    QString arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4) const;
 
130
 
 
131
#ifndef QT_NO_SPRINTF
 
132
    QString    &vsprintf(const char *format, va_list ap);
 
133
    QString    &sprintf(const char *format, ...)
 
134
#if defined(Q_CC_GNU) && !defined(__INSURE__)
 
135
        __attribute__ ((format (printf, 2, 3)))
 
136
#endif
 
137
        ;
 
138
#endif
 
139
 
 
140
    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
141
    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
142
    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
143
    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
144
 
 
145
    inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
146
    inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
147
    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
148
    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
149
 
 
150
#ifndef QT_NO_REGEXP
 
151
    int indexOf(const QRegExp &, int from = 0) const;
 
152
    int lastIndexOf(const QRegExp &, int from = -1) const;
 
153
    inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
 
154
    int count(const QRegExp &) const;
 
155
#endif
 
156
 
 
157
    enum SectionFlag {
 
158
        SectionDefault             = 0x00,
 
159
        SectionSkipEmpty           = 0x01,
 
160
        SectionIncludeLeadingSep   = 0x02,
 
161
        SectionIncludeTrailingSep  = 0x04,
 
162
        SectionCaseInsensitiveSeps = 0x08
 
163
    };
 
164
    Q_DECLARE_FLAGS(SectionFlags, SectionFlag)
 
165
 
 
166
    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 
167
    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 
168
#ifndef QT_NO_REGEXP
 
169
    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 
170
#endif
 
171
 
 
172
    QString left(int len) const;
 
173
    QString right(int len) const;
 
174
    QString mid(int i, int len = -1) const;
 
175
 
 
176
    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
177
    bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
178
    bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
179
    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
180
    bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
181
    bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
182
 
 
183
    QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;
 
184
    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;
 
185
 
 
186
    QString toLower() const;
 
187
    QString toUpper() const;
 
188
 
 
189
    QString trimmed() const;
 
190
    QString simplified() const;
 
191
 
 
192
    QString &insert(int i, QChar c);
 
193
    QString &insert(int i, const QChar *uc, int len);
 
194
    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
 
195
    QString &insert(int i, const QLatin1String &s);
 
196
    QString &append(QChar c);
 
197
    QString &append(const QString &s);
 
198
    QString &append(const QLatin1String &s);
 
199
    inline QString &prepend(QChar c) { return insert(0, c); }
 
200
    inline QString &prepend(const QString &s) { return insert(0, s); }
 
201
    inline QString &prepend(const QLatin1String &s) { return insert(0, s); }
 
202
    inline QString &operator+=(QChar c) { return append(c); }
 
203
    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
 
204
    inline QString &operator+=(const QString &s) { return append(s); }
 
205
    inline QString &operator+=(const QLatin1String &s) { return append(s); }
 
206
 
 
207
    QString &remove(int i, int len);
 
208
    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
209
    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
210
    QString &replace(int i, int len, QChar after);
 
211
    QString &replace(int i, int len, const QChar *s, int slen);
 
212
    QString &replace(int i, int len, const QString &after);
 
213
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
214
    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
215
    QString &replace(const QString &before, const QString &after,
 
216
                     Qt::CaseSensitivity cs = Qt::CaseSensitive);
 
217
#ifndef QT_NO_REGEXP_CAPTURE
 
218
    QString &replace(const QRegExp &rx, const QString &after);
 
219
    inline QString &remove(const QRegExp &rx)
 
220
    { return replace(rx, QString()); }
 
221
#endif
 
222
 
 
223
    enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };
 
224
 
 
225
    QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
 
226
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
227
    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,
 
228
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
229
    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const;
 
230
 
 
231
    enum NormalizationForm {
 
232
        NormalizationForm_D,
 
233
        NormalizationForm_C,
 
234
        NormalizationForm_KD,
 
235
        NormalizationForm_KC
 
236
    };
 
237
    QString normalized(NormalizationForm mode) const;
 
238
    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const;
 
239
 
 
240
    const ushort *utf16() const;
 
241
 
 
242
    QByteArray toAscii() const;
 
243
    QByteArray toLatin1() const;
 
244
    QByteArray toUtf8() const;
 
245
    QByteArray toLocal8Bit() const;
 
246
 
 
247
    static QString fromAscii(const char *, int size = -1);
 
248
    static QString fromLatin1(const char *, int size = -1);
 
249
    static QString fromUtf8(const char *, int size = -1);
 
250
    static QString fromLocal8Bit(const char *, int size = -1);
 
251
    static QString fromUtf16(const ushort *, int size = -1);
 
252
    static QString fromRawData(const QChar *, int size);
 
253
 
 
254
    QString &setUnicode(const QChar *unicode, int size);
 
255
    inline QString &setUtf16(const ushort *utf16, int size);
 
256
 
 
257
    int compare(const QString &s) const;
 
258
    static inline int compare(const QString &s1, const QString &s2)
 
259
    { return s1.compare(s2); }
 
260
    int localeAwareCompare(const QString& s) const;
 
261
    static int localeAwareCompare(const QString& s1, const QString& s2)
 
262
    { return s1.localeAwareCompare(s2); }
 
263
 
 
264
    short  toShort(bool *ok=0, int base=10) const;
 
265
    ushort toUShort(bool *ok=0, int base=10) const;
 
266
    int toInt(bool *ok=0, int base=10) const;
 
267
    uint toUInt(bool *ok=0, int base=10) const;
 
268
    long toLong(bool *ok=0, int base=10) const;
 
269
    ulong toULong(bool *ok=0, int base=10) const;
 
270
    qlonglong toLongLong(bool *ok=0, int base=10) const;
 
271
    qulonglong toULongLong(bool *ok=0, int base=10) const;
 
272
    float toFloat(bool *ok=0) const;
 
273
    double toDouble(bool *ok=0) const;
 
274
 
 
275
    QString &setNum(short, int base=10);
 
276
    QString &setNum(ushort, int base=10);
 
277
    QString &setNum(int, int base=10);
 
278
    QString &setNum(uint, int base=10);
 
279
    QString &setNum(long, int base=10);
 
280
    QString &setNum(ulong, int base=10);
 
281
    QString &setNum(qlonglong, int base=10);
 
282
    QString &setNum(qulonglong, int base=10);
 
283
    QString &setNum(float, char f='g', int prec=6);
 
284
    QString &setNum(double, char f='g', int prec=6);
 
285
 
 
286
    static QString number(int, int base=10);
 
287
    static QString number(uint, int base=10);
 
288
    static QString number(long, int base=10);
 
289
    static QString number(ulong, int base=10);
 
290
    static QString number(qlonglong, int base=10);
 
291
    static QString number(qulonglong, int base=10);
 
292
    static QString number(double, char f='g', int prec=6);
 
293
 
 
294
    bool operator==(const QString &s) const;
 
295
    bool operator<(const QString &s) const;
 
296
    inline bool operator>(const QString &s) const { return s < *this; }
 
297
    inline bool operator!=(const QString &s) const { return !operator==(s); }
 
298
    inline bool operator<=(const QString &s) const { return !operator>(s); }
 
299
    inline bool operator>=(const QString &s) const { return !operator<(s); }
 
300
 
 
301
    bool operator==(const QLatin1String &s) const;
 
302
    bool operator<(const QLatin1String &s) const;
 
303
    bool operator>(const QLatin1String &s) const;
 
304
    inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }
 
305
    inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }
 
306
    inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }
 
307
 
 
308
    // ASCII compatibility
 
309
#ifndef QT_NO_CAST_FROM_ASCII
 
310
    inline QString(const char *ch) : d(&shared_null)
 
311
    { d->ref.ref(); *this = fromAscii(ch); }
 
312
    inline QString(const QByteArray &a) : d(&shared_null)
 
313
    { d->ref.ref(); *this = fromAscii(a); }
 
314
    inline QString &operator=(const char *ch)
 
315
    { return (*this = fromAscii(ch)); }
 
316
    inline QString &operator=(const QByteArray &a)
 
317
    { return (*this = fromAscii(a)); }
 
318
    inline QString &operator=(char c)
 
319
    { return (*this = QChar(c)); }
 
320
 
 
321
    // these are needed, so it compiles with STL support enabled
 
322
    inline QString &prepend(const char *s)
 
323
    { return prepend(QString::fromAscii(s)); }
 
324
    inline QString &prepend(const QByteArray &s)
 
325
    { return prepend(QString(s)); }
 
326
    inline QString &append(const char *s)
 
327
    { return append(QString::fromAscii(s)); }
 
328
    inline QString &append(const QByteArray &s)
 
329
    { return append(QString(s)); }
 
330
    inline QString &operator+=(const char *s)
 
331
    { return append(QString::fromAscii(s)); }
 
332
    inline QString &operator+=(const QByteArray &s)
 
333
    { return append(QString(s)); }
 
334
    inline QString &operator+=(char c)
 
335
    { return append(QChar(c)); }
 
336
 
 
337
    inline bool operator==(const char *s) const;
 
338
    inline bool operator!=(const char *s) const;
 
339
    inline bool operator<(const char *s) const;
 
340
    inline bool operator<=(const char *s2) const;
 
341
    inline bool operator>(const char *s2) const;
 
342
    inline bool operator>=(const char *s2) const;
 
343
 
 
344
    inline bool operator==(const QByteArray &s) const { return (*this == s.constData()); }
 
345
    inline bool operator!=(const QByteArray &s) const { return !(*this == s.constData()); }
 
346
    inline bool operator<(const QByteArray &s) const { return *this < s.constData(); }
 
347
    inline bool operator>(const QByteArray &s) const { return *this > s.constData(); }
 
348
    inline bool operator<=(const QByteArray &s) const { return *this <= s.constData(); }
 
349
    inline bool operator>=(const QByteArray &s) const { return *this >= s.constData(); }
 
350
#endif
 
351
 
 
352
    typedef QChar *iterator;
 
353
    typedef const QChar *const_iterator;
 
354
    typedef iterator Iterator;
 
355
    typedef const_iterator ConstIterator;
 
356
    iterator begin();
 
357
    const_iterator begin() const;
 
358
    const_iterator constBegin() const;
 
359
    iterator end();
 
360
    const_iterator end() const;
 
361
    const_iterator constEnd() const;
 
362
 
 
363
    // STL compatibility
 
364
    inline void push_back(QChar c) { append(c); }
 
365
    inline void push_back(const QString &s) { append(s); }
 
366
    inline void push_front(QChar c) { prepend(c); }
 
367
    inline void push_front(const QString &s) { prepend(s); }
 
368
 
 
369
#ifndef QT_NO_STL
 
370
    static inline QString fromStdString(const std::string &s);
 
371
    inline std::string toStdString() const;
 
372
# ifdef qdoc
 
373
    static inline QString fromStdWString(const std::wstring &s);
 
374
    inline std::wstring toStdWString() const;
 
375
# else
 
376
#  ifndef QT_NO_STL_WCHAR
 
377
    static inline QString fromStdWString(const QStdWString &s);
 
378
    inline QStdWString toStdWString() const;
 
379
#  endif // QT_NO_STL_WCHAR
 
380
# endif // qdoc
 
381
#endif
 
382
 
 
383
    // compatibility
 
384
    struct Null { };
 
385
    static const Null null;
 
386
    inline QString(const Null &): d(&shared_null) { d->ref.ref(); }
 
387
    inline QString &operator=(const Null &) { *this = QString(); return *this; }
 
388
    inline bool isNull() const { return d == &shared_null; }
 
389
 
 
390
#ifdef QT3_SUPPORT
 
391
    inline QT3_SUPPORT const char *ascii() const { return ascii_helper(); }
 
392
    inline QT3_SUPPORT const char *latin1() const { return latin1_helper(); }
 
393
    inline QT3_SUPPORT QByteArray utf8() const { return toUtf8(); }
 
394
    inline QT3_SUPPORT QByteArray local8Bit() const{ return toLocal8Bit(); }
 
395
    inline QT3_SUPPORT void setLength(int nl) { resize(nl); }
 
396
    inline QT3_SUPPORT QString copy() const { return *this; }
 
397
    inline QT3_SUPPORT QString &remove(QChar c, bool cs)
 
398
    { return remove(c, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
399
    inline QT3_SUPPORT QString &remove(const QString  &s, bool cs)
 
400
    { return remove(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
401
    inline QT3_SUPPORT QString &replace(QChar c, const QString  &after, bool cs)
 
402
    { return replace(c, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
403
    inline QT3_SUPPORT QString &replace(const QString &before, const QString &after, bool cs)
 
404
    { return replace(before, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
405
#ifndef QT_NO_CAST_FROM_ASCII
 
406
    inline QT3_SUPPORT QString &replace(char c, const QString &after, bool cs)
 
407
    { return replace(QChar(c), after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
408
    // strange overload, required to avoid GCC 3.3 error
 
409
    inline QT3_SUPPORT QString &replace(char c, const QString &after, Qt::CaseSensitivity cs)
 
410
    { return replace(QChar(c), after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
411
#endif
 
412
    inline QT3_SUPPORT int find(QChar c, int i = 0, bool cs = true) const
 
413
    { return indexOf(c, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
414
    inline QT3_SUPPORT int find(const QString &s, int i = 0, bool cs = true) const
 
415
    { return indexOf(s, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
416
    inline QT3_SUPPORT int findRev(QChar c, int i = -1, bool cs = true) const
 
417
    { return lastIndexOf(c, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
418
    inline QT3_SUPPORT int findRev(const QString &s, int i = -1, bool cs = true) const
 
419
    { return lastIndexOf(s, i, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
420
#ifndef QT_NO_REGEXP
 
421
    inline QT3_SUPPORT int find(const QRegExp &rx, int i=0) const
 
422
    { return indexOf(rx, i); }
 
423
    inline QT3_SUPPORT int findRev(const QRegExp &rx, int i=-1) const
 
424
    { return lastIndexOf(rx, i); }
 
425
#endif
 
426
    inline QT3_SUPPORT QBool contains(QChar c, bool cs) const
 
427
    { return contains(c, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
428
    inline QT3_SUPPORT QBool contains(const QString &s, bool cs) const
 
429
    { return contains(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
430
    inline QT3_SUPPORT bool startsWith(const QString &s, bool cs) const
 
431
    { return startsWith(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
432
    inline QT3_SUPPORT bool endsWith(const QString &s, bool cs) const
 
433
    { return endsWith(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }
 
434
    inline QT3_SUPPORT QChar constref(uint i) const
 
435
    { return at(i); }
 
436
    QT3_SUPPORT QChar &ref(uint i);
 
437
    inline QT3_SUPPORT QString leftJustify(int width, QChar fill = QLatin1Char(' '), bool trunc=false) const
 
438
    { return leftJustified(width, fill, trunc); }
 
439
    inline QT3_SUPPORT QString rightJustify(int width, QChar fill = QLatin1Char(' '), bool trunc=false) const
 
440
    { return rightJustified(width, fill, trunc); }
 
441
    inline QT3_SUPPORT QString lower() const { return toLower(); }
 
442
    inline QT3_SUPPORT QString upper() const { return toUpper(); }
 
443
    inline QT3_SUPPORT QString stripWhiteSpace() const { return trimmed(); }
 
444
    inline QT3_SUPPORT QString simplifyWhiteSpace() const { return simplified(); }
 
445
    inline QT3_SUPPORT QString &setUnicodeCodes(const ushort *unicode_as_ushorts, int size)
 
446
    { return setUtf16(unicode_as_ushorts, size); }
 
447
    inline QT3_SUPPORT const ushort *ucs2() const { return utf16(); }
 
448
    inline static QT3_SUPPORT QString fromUcs2(const ushort *unicode, int size = -1)
 
449
    { return fromUtf16(unicode, size); }
 
450
    inline QT3_SUPPORT QString &setAscii(const char *str, int len = -1)
 
451
    { *this = fromAscii(str, len); return *this; }
 
452
    inline QT3_SUPPORT QString &setLatin1(const char *str, int len = -1)
 
453
    { *this = fromLatin1(str, len); return *this; }
 
454
protected:
 
455
    friend class QObject;
 
456
    const char *ascii_helper() const;
 
457
    const char *latin1_helper() const;
 
458
public:
 
459
#ifndef QT_NO_CAST_TO_ASCII
 
460
    inline QT3_SUPPORT operator const char *() const { return ascii_helper(); }
 
461
private:
 
462
    QT3_SUPPORT operator QNoImplicitBoolCast() const;
 
463
public:
 
464
#endif
 
465
#endif
 
466
 
 
467
    bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
 
468
    bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }
 
469
 
 
470
private:
 
471
#if defined(QT_NO_CAST_FROM_ASCII) && !defined(Q_NO_DECLARED_NOT_DEFINED)
 
472
    QString &operator+=(const char *s);
 
473
    QString &operator+=(const QByteArray &s);
 
474
    QString(const char *ch);
 
475
    QString(const QByteArray &a);
 
476
    QString &operator=(const char  *ch);
 
477
    QString &operator=(const QByteArray &a);
 
478
#endif
 
479
 
 
480
    struct Data {
 
481
        QBasicAtomic ref;
 
482
        int alloc, size;
 
483
        ushort *data;
 
484
        ushort clean : 1;
 
485
        ushort simpletext : 1;
 
486
        ushort righttoleft : 1;
 
487
        ushort asciiCache : 1;
 
488
        ushort reserved : 12;
 
489
        ushort array[1];
 
490
    };
 
491
    static Data shared_null;
 
492
    static Data shared_empty;
 
493
    Data *d;
 
494
    QString(Data *dd, int /*dummy*/) : d(dd) {}
 
495
#ifndef QT_NO_TEXTCODEC
 
496
    static QTextCodec *codecForCStrings;
 
497
#endif
 
498
    static int grow(int);
 
499
    static void free(Data *);
 
500
    void realloc();
 
501
    void realloc(int alloc);
 
502
    void expand(int i);
 
503
    void updateProperties() const;
 
504
    QString multiArg(int numArgs, const QString **args) const;
 
505
#ifndef QT_NO_STL
 
506
    int toWCharArray(wchar_t *array) const;
 
507
    static QString fromWCharArray(const wchar_t *, int);
 
508
#endif
 
509
    friend class QCharRef;
 
510
    friend class QTextCodec;
 
511
};
 
512
 
 
513
 
 
514
class Q_CORE_EXPORT QLatin1String
 
515
{
 
516
public:
 
517
    inline explicit QLatin1String(const char *s) : chars(s) {}
 
518
    inline const char *latin1() const { return chars; }
 
519
 
 
520
    inline bool operator==(const QString &s) const
 
521
    { return s == *this; }
 
522
    inline bool operator!=(const QString &s) const
 
523
    { return s != *this; }
 
524
    inline bool operator>(const QString &s) const
 
525
    { return s < *this; }
 
526
    inline bool operator<(const QString &s) const
 
527
    { return s > *this; }
 
528
    inline bool operator>=(const QString &s) const
 
529
    { return s <= *this; }
 
530
    inline bool operator<=(const QString &s) const
 
531
    { return s >= *this; }
 
532
 
 
533
private:
 
534
    const char *chars;
 
535
};
 
536
 
 
537
 
 
538
inline QString::QString(const QLatin1String &latin1) : d(&shared_null)
 
539
{ d->ref.ref(); *this = fromLatin1(latin1.latin1()); }
 
540
inline int QString::length() const
 
541
{ return d->size; }
 
542
inline const QChar QString::at(int i) const
 
543
{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
 
544
inline const QChar QString::operator[](int i) const
 
545
{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
 
546
inline const QChar QString::operator[](uint i) const
 
547
{ Q_ASSERT(i < uint(size())); return d->data[i]; }
 
548
inline bool QString::isEmpty() const
 
549
{ return d->size == 0; }
 
550
inline const QChar *QString::unicode() const
 
551
{ return reinterpret_cast<const QChar*>(d->data); }
 
552
inline const QChar *QString::data() const
 
553
{ return reinterpret_cast<const QChar*>(d->data); }
 
554
inline QChar *QString::data()
 
555
{ detach(); return reinterpret_cast<QChar*>(d->data); }
 
556
inline const QChar *QString::constData() const
 
557
{ return reinterpret_cast<const QChar*>(d->data); }
 
558
inline void QString::detach()
 
559
{ if (d->ref != 1 || d->data != d->array) realloc(); }
 
560
inline bool QString::isDetached() const
 
561
{ return d->ref == 1; }
 
562
inline QString &QString::operator=(const QLatin1String &s)
 
563
{
 
564
    *this = fromLatin1(s.latin1());
 
565
    return *this;
 
566
}
 
567
inline void QString::clear()
 
568
{ if (!isNull()) *this = QString(); }
 
569
inline QString::QString(const QString &s) : d(s.d)
 
570
{ Q_ASSERT(&s != this); d->ref.ref(); }
 
571
inline int QString::capacity() const
 
572
{ return d->alloc; }
 
573
inline QString &QString::setNum(short n, int base)
 
574
{ return setNum(qlonglong(n), base); }
 
575
inline QString &QString::setNum(ushort n, int base)
 
576
{ return setNum(qulonglong(n), base); }
 
577
inline QString &QString::setNum(int n, int base)
 
578
{ return setNum(qlonglong(n), base); }
 
579
inline QString &QString::setNum(uint n, int base)
 
580
{ return setNum(qulonglong(n), base); }
 
581
inline QString &QString::setNum(long n, int base)
 
582
{ return setNum(qlonglong(n), base); }
 
583
inline QString &QString::setNum(ulong n, int base)
 
584
{ return setNum(qulonglong(n), base); }
 
585
inline QString &QString::setNum(float n, char f, int prec)
 
586
{ return setNum(double(n),f,prec); }
 
587
inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const
 
588
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
 
589
inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const
 
590
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
 
591
inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const
 
592
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
 
593
inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const
 
594
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
 
595
inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const
 
596
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
 
597
inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const
 
598
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
 
599
inline QString QString::arg(const QString &a1, const QString &a2) const
 
600
{ const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); }
 
601
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
 
602
{ const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); }
 
603
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4) const
 
604
{ const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); }
 
605
inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
 
606
{ return section(QString(asep), astart, aend, aflags); }
 
607
 
 
608
 
 
609
class Q_CORE_EXPORT QCharRef {
 
610
    QString &s;
 
611
    int i;
 
612
    inline QCharRef(QString &str, int idx)
 
613
        : s(str),i(idx) {}
 
614
    friend class QString;
 
615
public:
 
616
 
 
617
    // most QChar operations repeated here
 
618
 
 
619
    // all this is not documented: We just say "like QChar" and let it be.
 
620
    inline operator QChar() const
 
621
        { return i < s.d->size ? s.d->data[i] : 0; }
 
622
    inline QCharRef &operator=(const QChar &c)
 
623
        { if (s.d->ref != 1 || i >= s.d->size) s.expand(i);
 
624
          s.d->data[i] = c.unicode();  return *this; }
 
625
 
 
626
    // An operator= for each QChar cast constructors
 
627
#ifndef QT_NO_CAST_FROM_ASCII
 
628
    inline QCharRef &operator=(char c) { return operator=(QChar(c)); }
 
629
    inline QCharRef &operator=(uchar c) { return operator=(QChar(c)); }
 
630
#endif
 
631
    inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
 
632
    inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
 
633
    inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
 
634
    inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
 
635
    inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }
 
636
 
 
637
    // each function...
 
638
    inline bool isNull() const { return QChar(*this).isNull(); }
 
639
    inline bool isPrint() const { return QChar(*this).isPrint(); }
 
640
    inline bool isPunct() const { return QChar(*this).isPunct(); }
 
641
    inline bool isSpace() const { return QChar(*this).isSpace(); }
 
642
    inline bool isMark() const { return QChar(*this).isMark(); }
 
643
    inline bool isLetter() const { return QChar(*this).isLetter(); }
 
644
    inline bool isNumber() const { return QChar(*this).isNumber(); }
 
645
    inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
 
646
    inline bool isDigit() const { return QChar(*this).isDigit(); }
 
647
 
 
648
    inline int digitValue() const { return QChar(*this).digitValue(); }
 
649
    QChar toLower() const { return QChar(*this).toLower(); }
 
650
    QChar toUpper() const { return QChar(*this).toUpper(); }
 
651
#ifdef QT3_SUPPORT
 
652
    inline QT3_SUPPORT QChar lower() const { return QChar(*this).toLower(); }
 
653
    inline QT3_SUPPORT QChar upper() const { return QChar(*this).toUpper(); }
 
654
#endif
 
655
 
 
656
    QChar::Category category() const { return QChar(*this).category(); }
 
657
    QChar::Direction direction() const { return QChar(*this).direction(); }
 
658
    QChar::Joining joining() const { return QChar(*this).joining(); }
 
659
    bool hasMirrored() const { return QChar(*this).hasMirrored(); }
 
660
#ifdef QT3_SUPPORT
 
661
    inline bool QT3_SUPPORT mirrored() const { return hasMirrored(); }
 
662
#endif
 
663
    QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
 
664
    QString decomposition() const { return QChar(*this).decomposition(); }
 
665
    QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
 
666
    uchar combiningClass() const { return QChar(*this).combiningClass(); }
 
667
 
 
668
    QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }
 
669
 
 
670
    inline uchar cell() const { return QChar(*this).cell(); }
 
671
    inline uchar row() const { return QChar(*this).row(); }
 
672
    inline void setCell(uchar cell);
 
673
    inline void setRow(uchar row);
 
674
 
 
675
    const char toAscii() const { return QChar(*this).toAscii(); }
 
676
    const char toLatin1() const { return QChar(*this).toLatin1(); }
 
677
#ifdef QT3_SUPPORT
 
678
    const char latin1() const { return QChar(*this).toLatin1(); }
 
679
    const char ascii() const { return QChar(*this).toAscii(); }
 
680
#endif
 
681
    const ushort unicode() const { return QChar(*this).unicode(); }
 
682
};
 
683
 
 
684
inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
 
685
inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }
 
686
 
 
687
 
 
688
inline QString::QString() : d(&shared_null) { d->ref.ref(); }
 
689
inline QString::~QString() { if (!d->ref.deref()) free(d); }
 
690
inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); }
 
691
inline QString &QString::setUtf16(const ushort *autf16, int asize)
 
692
{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
 
693
inline QCharRef QString::operator[](int i)
 
694
{ Q_ASSERT(i >= 0); return QCharRef(*this, i); }
 
695
inline QCharRef QString::operator[](uint i)
 
696
{ return QCharRef(*this, i); }
 
697
inline QString::iterator QString::begin()
 
698
{ detach(); return reinterpret_cast<QChar*>(d->data); }
 
699
inline QString::const_iterator QString::begin() const
 
700
{ return reinterpret_cast<const QChar*>(d->data); }
 
701
inline QString::const_iterator QString::constBegin() const
 
702
{ return reinterpret_cast<const QChar*>(d->data); }
 
703
inline QString::iterator QString::end()
 
704
{ detach(); return reinterpret_cast<QChar*>(d->data + d->size); }
 
705
inline QString::const_iterator QString::end() const
 
706
{ return reinterpret_cast<const QChar*>(d->data + d->size); }
 
707
inline QString::const_iterator QString::constEnd() const
 
708
{ return reinterpret_cast<const QChar*>(d->data + d->size); }
 
709
inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
 
710
{ return QBool(indexOf(s, 0, cs) != -1); }
 
711
inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const
 
712
{ return QBool(indexOf(c, 0, cs) != -1); }
 
713
 
 
714
 
 
715
inline bool operator==(QString::Null, QString::Null) { return true; }
 
716
inline bool operator==(QString::Null, const QString &s) { return s.isNull(); }
 
717
inline bool operator==(const QString &s, QString::Null) { return s.isNull(); }
 
718
inline bool operator!=(QString::Null, QString::Null) { return false; }
 
719
inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); }
 
720
inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); }
 
721
 
 
722
#ifndef QT_NO_CAST_FROM_ASCII
 
723
inline bool QString::operator==(const char *s) const {
 
724
#  ifndef QT_NO_TEXTCODEC
 
725
    if (codecForCStrings) return (*this == QString::fromAscii(s));
 
726
#  endif
 
727
    return (*this == QLatin1String(s));
 
728
}
 
729
inline bool QString::operator!=(const char *s) const{ return !(*this == s); }
 
730
inline bool QString::operator<(const char *s) const { return *this < QString::fromAscii(s); }
 
731
inline bool QString::operator>(const char *s) const { return *this > QString::fromAscii(s); }
 
732
inline bool QString::operator<=(const char *s) const { return *this <= QString::fromAscii(s); }
 
733
inline bool QString::operator>=(const char *s) const { return *this >= QString::fromAscii(s); }
 
734
 
 
735
inline bool operator==(const char *s1, const QString &s2) { return (s2 == s1); }
 
736
inline bool operator!=(const char *s1, const QString &s2) { return !(s2 == s1); }
 
737
inline bool operator<(const char *s1, const QString &s2) { return (QString::fromAscii(s1) < s2); }
 
738
inline bool operator>(const char *s1, const QString &s2) { return (QString::fromAscii(s1) > s2); }
 
739
inline bool operator<=(const char *s1, const QString &s2) { return (QString::fromAscii(s1) <= s2); }
 
740
inline bool operator>=(const char *s1, const QString &s2) { return (QString::fromAscii(s1) >= s2); }
 
741
 
 
742
inline bool QByteArray::operator==(const QString &s) const { return constData() == s; }
 
743
inline bool QByteArray::operator!=(const QString &s) const { return !(constData() == s); }
 
744
inline bool QByteArray::operator<(const QString &s) const { return constData() < s; }
 
745
inline bool QByteArray::operator>(const QString &s) const { return constData() > s; }
 
746
inline bool QByteArray::operator<=(const QString &s) const { return constData() <= s; }
 
747
inline bool QByteArray::operator>=(const QString &s) const { return constData() >= s; }
 
748
#endif   // QT_NO_CAST_FROM_ASCII
 
749
 
 
750
#ifndef QT_NO_CAST_TO_ASCII
 
751
inline QByteArray &QByteArray::append(const QString &s)
 
752
{ return append(s.toAscii()); }
 
753
inline QByteArray &QByteArray::insert(int i, const QString &s)
 
754
{ return insert(i, s.toAscii()); }
 
755
inline QByteArray &QByteArray::replace(char c, const QString &after)
 
756
{ return replace(c, after.toAscii()); }
 
757
inline QByteArray &QByteArray::replace(const QString &before, const char *after)
 
758
{ return replace(before.toAscii(), after); }
 
759
inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)
 
760
{ return replace(before, after.constData()); }
 
761
inline QByteArray &QByteArray::operator+=(const QString &s)
 
762
{ return operator+=(s.toAscii()); }
 
763
inline int QByteArray::indexOf(const QString &s, int from) const
 
764
{ return indexOf(s.toAscii(), from); }
 
765
inline int QByteArray::lastIndexOf(const QString &s, int from) const
 
766
{ return lastIndexOf(s.toAscii(), from); }
 
767
#ifdef QT3_SUPPORT
 
768
inline int QByteArray::find(const QString &s, int from) const
 
769
{ return indexOf(s, from); }
 
770
inline int QByteArray::findRev(const QString &s, int from) const
 
771
{ return lastIndexOf(s, from); }
 
772
#endif // QT3_SUPPORT
 
773
#endif // QT_NO_CAST_TO_ASCII
 
774
 
 
775
inline const QString operator+(const QString &s1, const QString &s2)
 
776
{ QString t(s1); t += s2; return t; }
 
777
inline const QString operator+(const QString &s1, QChar s2)
 
778
{ QString t(s1); t += s2; return t; }
 
779
inline const QString operator+(QChar s1, const QString &s2)
 
780
{ QString t(s1); t += s2; return t; }
 
781
#ifndef QT_NO_CAST_FROM_ASCII
 
782
inline const QString operator+(const QString &s1, const char *s2)
 
783
{ QString t(s1); t += QString::fromAscii(s2); return t; }
 
784
inline const QString operator+(const char *s1, const QString &s2)
 
785
{ QString t(s1); t += s2; return t; }
 
786
inline const QString operator+(char c, const QString &s)
 
787
{ QString t = s; t.prepend(QChar(c)); return t; }
 
788
inline const QString operator+(const QString &s, char c)
 
789
{ QString t(s); t += c; return t; }
 
790
inline const QString operator+(const QByteArray &ba, const QString &s)
 
791
{ QString t(ba); t += s; return t; }
 
792
inline const QString operator+(const QString &s, const QByteArray &ba)
 
793
{ QString t(s); t += ba; return t; }
 
794
#endif
 
795
 
 
796
#ifndef QT_NO_STL
 
797
inline std::string QString::toStdString() const
 
798
{ return toAscii().data(); }
 
799
 
 
800
inline QString QString::fromStdString(const std::string &s)
 
801
{ return fromAscii(s.c_str()); }
 
802
 
 
803
# ifndef QT_NO_STL_WCHAR
 
804
inline QStdWString QString::toStdWString() const
 
805
{
 
806
    QStdWString str;
 
807
    str.resize(length());
 
808
    str.resize(toWCharArray(&(*str.begin())));
 
809
    return str;
 
810
}
 
811
inline QString QString::fromStdWString(const QStdWString &s)
 
812
{ return fromWCharArray(s.c_str(), s.length()); }
 
813
# endif
 
814
#endif
 
815
 
 
816
#ifdef QT3_SUPPORT
 
817
inline QChar &QString::ref(uint i)
 
818
{
 
819
    if (int(i) > d->size || d->ref != 1)
 
820
        resize(qMax(int(i), d->size));
 
821
    return reinterpret_cast<QChar&>(d->data[i]);
 
822
}
 
823
#endif
 
824
 
 
825
#ifndef QT_NO_DATASTREAM
 
826
Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QString &);
 
827
Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QString &);
 
828
#endif
 
829
 
 
830
#ifdef QT3_SUPPORT
 
831
class QConstString : public QString
 
832
{
 
833
public:
 
834
    inline QT3_SUPPORT_CONSTRUCTOR QConstString(const QChar *unicode, int size)
 
835
        :QString(unicode, size){} // cannot use fromRawData() due to changed semantics
 
836
    inline QT3_SUPPORT const QString &string() const { return *this; }
 
837
};
 
838
#endif
 
839
 
 
840
Q_DECLARE_TYPEINFO(QString, Q_MOVABLE_TYPE);
 
841
Q_DECLARE_SHARED(QString)
 
842
Q_DECLARE_OPERATORS_FOR_FLAGS(QString::SectionFlags)
 
843
 
 
844
#if defined(Q_OS_WIN32)
 
845
extern Q_CORE_EXPORT QByteArray qt_winQString2MB(const QString& s, int len=-1);
 
846
extern Q_CORE_EXPORT QByteArray qt_winQString2MB(const QChar *ch, int len);
 
847
extern Q_CORE_EXPORT QString qt_winMB2QString(const char* mb, int len=-1);
 
848
#endif
 
849
 
 
850
#endif // QSTRING_H