src/corelib/tools/qstring.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtCore module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QSTRING_H
  43 #define QSTRING_H
  44
  45 #include <QtCore/qchar.h>
  46 #include <QtCore/qbytearray.h>
  47 #include <QtCore/qrefcount.h>
  48 #include <QtCore/qnamespace.h>
  49
  50 #include <string>
  51
  52 #include <stdarg.h>
  53
  54 #ifdef truncate
  55 #error qstring.h must be included before any header file that defines truncate
  56 #endif
  57
  58 QT_BEGIN_HEADER
  59
  60 QT_BEGIN_NAMESPACE
  61
  62
  63 class QCharRef;
  64 class QRegExp;
  65 class QRegularExpression;
  66 class QStringList;
  67 class QTextCodec;
  68 class QLatin1String;
  69 class QStringRef;
  70 template <typename T> class QVector;
  71
  72 struct QStringData {
  73     QtPrivate::RefCount ref;
  74     int size;
  75     uint alloc : 31;
  76     uint capacityReserved : 1;
  77
  78     qptrdiff offset;
  79
  80     inline ushort *data() { return reinterpret_cast<ushort *>(reinterpret_cast<char *>(this) + offset); }
  81     inline const ushort *data() const { return reinterpret_cast<const ushort *>(reinterpret_cast<const char *>(this) + offset); }
  82 };
  83
  84 #if defined(Q_COMPILER_UNICODE_STRINGS)
  85
  86 #define QT_UNICODE_LITERAL_II(str) u"" str
  87 typedef char16_t qunicodechar;
  88
  89 #elif defined(Q_OS_WIN) \
  90        || (defined(__SIZEOF_WCHAR_T__) && __SIZEOF_WCHAR_T__ == 2) \
  91        || (!defined(__SIZEOF_WCHAR_T__) && defined(WCHAR_MAX) && (WCHAR_MAX - 0 < 65536))
  92 // wchar_t is 2 bytes
  93
  94 #if defined(Q_CC_MSVC)
  95 #    define QT_UNICODE_LITERAL_II(str) L##str
  96 #else
  97 #    define QT_UNICODE_LITERAL_II(str) L"" str
  98 #endif
  99 typedef wchar_t qunicodechar;
 100
 101 #else
 102
 103 #define QT_NO_UNICODE_LITERAL
 104 typedef ushort qunicodechar;
 105
 106 #endif
 107
 108 Q_STATIC_ASSERT_X(sizeof(qunicodechar) == 2,
 109         "qunicodechar must typedef an integral type of size 2");
 110
 111 #ifndef QT_NO_UNICODE_LITERAL
 112 #  define QT_UNICODE_LITERAL(str) QT_UNICODE_LITERAL_II(str)
 113 # if defined(Q_COMPILER_LAMBDA)
 114
 115 #  define QStringLiteral(str) \
 116     ([]() -> QStringDataPtr { \
 117         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
 118         static const QStaticStringData<Size> qstring_literal = { \
 119             Q_STATIC_STRING_DATA_HEADER_INITIALIZER(Size), \
 120             QT_UNICODE_LITERAL(str) }; \
 121         QStringDataPtr holder = { qstring_literal.data_ptr() }; \
 122         return holder; \
 123     }()) \
 124     /**/
 125
 126 # elif defined(Q_CC_GNU)
 127 // We need to create a QStringData in the .rodata section of memory
 128 // and the only way to do that is to create a "static const" variable.
 129 // To do that, we need the __extension__ {( )} trick which only GCC supports
 130
 131 #  define QStringLiteral(str) \
 132     __extension__ ({ \
 133         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
 134         static const QStaticStringData<Size> qstring_literal = { \
 135             Q_STATIC_STRING_DATA_HEADER_INITIALIZER(Size), \
 136             QT_UNICODE_LITERAL(str) }; \
 137         QStringDataPtr holder = { qstring_literal.data_ptr() }; \
 138         holder; \
 139     }) \
 140     /**/
 141
 142 # endif
 143 #endif // QT_NO_UNICODE_LITERAL
 144
 145 #ifndef QStringLiteral
 146 // no lambdas, not GCC, or GCC in C++98 mode with 4-byte wchar_t
 147 // fallback, uses QLatin1String as next best options
 148
 149 # define QStringLiteral(str) QLatin1String(str)
 150 #endif
 151
 152 #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) \
 153     { Q_REFCOUNT_INITIALIZE_STATIC, size, 0, 0, offset } \
 154     /**/
 155
 156 #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER(size) \
 157     Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, sizeof(QStringData)) \
 158     /**/
 159
 160 template <int N>
 161 struct QStaticStringData
 162 {
 163     QStringData str;
 164     qunicodechar data[N + 1];
 165
 166     QStringData *data_ptr() const
 167     {
 168         Q_ASSERT(str.ref.isStatic());
 169         return const_cast<QStringData *>(&str);
 170     }
 171 };
 172
 173 struct QStringDataPtr
 174 {
 175     QStringData *ptr;
 176 };
 177
 178 class Q_CORE_EXPORT QString
 179 {
 180 public:
 181     typedef QStringData Data;
 182
 183     inline QString();
 184     explicit QString(const QChar *unicode, int size = -1);
 185     QString(QChar c);
 186     QString(int size, QChar c);
 187     inline QString(const QLatin1String &latin1);
 188     inline QString(const QString &);
 189     inline ~QString();
 190     QString &operator=(QChar c);
 191     QString &operator=(const QString &);
 192     inline QString &operator=(const QLatin1String &);
 193 #ifdef Q_COMPILER_RVALUE_REFS
 194     inline QString &operator=(QString &&other)
 195     { qSwap(d, other.d); return *this; }
 196 #endif
 197     inline void swap(QString &other) { qSwap(d, other.d); }
 198     inline int size() const { return d->size; }
 199     inline int count() const { return d->size; }
 200     inline int length() const;
 201     inline bool isEmpty() const;
 202     void resize(int size);
 203
 204     QString &fill(QChar c, int size = -1);
 205     void truncate(int pos);
 206     void chop(int n);
 207
 208     int capacity() const;
 209     inline void reserve(int size);
 210     inline void squeeze();
 211
 212     inline const QChar *unicode() const;
 213     inline QChar *data();
 214     inline const QChar *data() const;
 215     inline const QChar *constData() const;
 216
 217     inline void detach();
 218     inline bool isDetached() const;
 219     inline bool isSharedWith(const QString &other) const { return d == other.d; }
 220     void clear();
 221
 222     inline const QChar at(int i) const;
 223     const QChar operator[](int i) const;
 224     QCharRef operator[](int i);
 225     const QChar operator[](uint i) const;
 226     QCharRef operator[](uint i);
 227
 228     QString arg(qlonglong a, int fieldwidth=0, int base=10,
 229                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 230     QString arg(qulonglong a, int fieldwidth=0, int base=10,
 231                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 232     QString arg(long a, int fieldwidth=0, int base=10,
 233                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 234     QString arg(ulong a, int fieldwidth=0, int base=10,
 235                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 236     QString arg(int a, int fieldWidth = 0, int base = 10,
 237                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 238     QString arg(uint a, int fieldWidth = 0, int base = 10,
 239                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 240     QString arg(short a, int fieldWidth = 0, int base = 10,
 241                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 242     QString arg(ushort a, int fieldWidth = 0, int base = 10,
 243                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 244     QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
 245                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 246     QString arg(char a, int fieldWidth = 0,
 247                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 248     QString arg(QChar a, int fieldWidth = 0,
 249                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 250     QString arg(const QString &a, int fieldWidth = 0,
 251                 QChar fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;
 252     QString arg(const QString &a1, const QString &a2) const Q_REQUIRED_RESULT;
 253     QString arg(const QString &a1, const QString &a2, const QString &a3) const Q_REQUIRED_RESULT;
 254     QString arg(const QString &a1, const QString &a2, const QString &a3,
 255                 const QString &a4) const Q_REQUIRED_RESULT;
 256     QString arg(const QString &a1, const QString &a2, const QString &a3,
 257                 const QString &a4, const QString &a5) const Q_REQUIRED_RESULT;
 258     QString arg(const QString &a1, const QString &a2, const QString &a3,
 259                 const QString &a4, const QString &a5, const QString &a6) const Q_REQUIRED_RESULT;
 260     QString arg(const QString &a1, const QString &a2, const QString &a3,
 261                 const QString &a4, const QString &a5, const QString &a6,
 262                 const QString &a7) const Q_REQUIRED_RESULT;
 263     QString arg(const QString &a1, const QString &a2, const QString &a3,
 264                 const QString &a4, const QString &a5, const QString &a6,
 265                 const QString &a7, const QString &a8) const Q_REQUIRED_RESULT;
 266     QString arg(const QString &a1, const QString &a2, const QString &a3,
 267                 const QString &a4, const QString &a5, const QString &a6,
 268                 const QString &a7, const QString &a8, const QString &a9) const Q_REQUIRED_RESULT;
 269
 270     QString    &vsprintf(const char *format, va_list ap)
 271 #if defined(Q_CC_GNU) && !defined(__INSURE__)
 272         __attribute__ ((format (printf, 2, 0)))
 273 #endif
 274         ;
 275     QString    &sprintf(const char *format, ...)
 276 #if defined(Q_CC_GNU) && !defined(__INSURE__)
 277         __attribute__ ((format (printf, 2, 3)))
 278 #endif
 279         ;
 280
 281     int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 282     int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 283     int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 284     int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 285     int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 286     int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 287     int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 288     int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 289
 290     inline bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 291     inline bool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 292     inline bool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 293     int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 294     int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 295     int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 296
 297 #ifndef QT_NO_REGEXP
 298     int indexOf(const QRegExp &, int from = 0) const;
 299     int lastIndexOf(const QRegExp &, int from = -1) const;
 300     inline bool contains(const QRegExp &rx) const { return indexOf(rx) != -1; }
 301     int count(const QRegExp &) const;
 302
 303     int indexOf(QRegExp &, int from = 0) const;
 304     int lastIndexOf(QRegExp &, int from = -1) const;
 305     inline bool contains(QRegExp &rx) const { return indexOf(rx) != -1; }
 306 #endif
 307
 308 #ifndef QT_NO_REGEXP
 309     int indexOf(const QRegularExpression &re, int from = 0) const;
 310     int lastIndexOf(const QRegularExpression &re, int from = -1) const;
 311     bool contains(const QRegularExpression &re) const;
 312     int count(const QRegularExpression &re) const;
 313 #endif
 314
 315     enum SectionFlag {
 316         SectionDefault             = 0x00,
 317         SectionSkipEmpty           = 0x01,
 318         SectionIncludeLeadingSep   = 0x02,
 319         SectionIncludeTrailingSep  = 0x04,
 320         SectionCaseInsensitiveSeps = 0x08
 321     };
 322     Q_DECLARE_FLAGS(SectionFlags, SectionFlag)
 323
 324     QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 325     QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 326 #ifndef QT_NO_REGEXP
 327     QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 328 #endif
 329 #ifndef QT_NO_REGEXP
 330     QString section(const QRegularExpression &re, int start, int end = -1, SectionFlags flags = SectionDefault) const;
 331 #endif
 332     QString left(int n) const Q_REQUIRED_RESULT;
 333     QString right(int n) const Q_REQUIRED_RESULT;
 334     QString mid(int position, int n = -1) const Q_REQUIRED_RESULT;
 335     QStringRef leftRef(int n) const Q_REQUIRED_RESULT;
 336     QStringRef rightRef(int n) const Q_REQUIRED_RESULT;
 337     QStringRef midRef(int position, int n = -1) const Q_REQUIRED_RESULT;
 338
 339     bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 340     bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 341     bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 342     bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 343     bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 344     bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 345     bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 346     bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 347
 348     QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT;
 349     QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT;
 350
 351     QString toLower() const Q_REQUIRED_RESULT;
 352     QString toUpper() const Q_REQUIRED_RESULT;
 353     QString toCaseFolded() const Q_REQUIRED_RESULT;
 354
 355     QString trimmed() const Q_REQUIRED_RESULT;
 356     QString simplified() const Q_REQUIRED_RESULT;
 357     QString toHtmlEscaped() const Q_REQUIRED_RESULT;
 358
 359     QString &insert(int i, QChar c);
 360     QString &insert(int i, const QChar *uc, int len);
 361     inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
 362     QString &insert(int i, const QLatin1String &s);
 363     QString &append(QChar c);
 364     QString &append(const QString &s);
 365     QString &append(const QStringRef &s);
 366     QString &append(const QLatin1String &s);
 367     inline QString &prepend(QChar c) { return insert(0, c); }
 368     inline QString &prepend(const QString &s) { return insert(0, s); }
 369     inline QString &prepend(const QLatin1String &s) { return insert(0, s); }
 370
 371     inline QString &operator+=(QChar c) {
 372         if (d->ref.isShared() || d->size + 1 > int(d->alloc))
 373             reallocData(d->size + 1, true);
 374         d->data()[d->size++] = c.unicode();
 375         d->data()[d->size] = '\0';
 376         return *this;
 377     }
 378
 379     inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
 380     inline QString &operator+=(const QString &s) { return append(s); }
 381     inline QString &operator+=(const QStringRef &s) { return append(s); }
 382     inline QString &operator+=(const QLatin1String &s) { return append(s); }
 383
 384     QString &remove(int i, int len);
 385     QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 386     QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 387     QString &replace(int i, int len, QChar after);
 388     QString &replace(int i, int len, const QChar *s, int slen);
 389     QString &replace(int i, int len, const QString &after);
 390     QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 391     QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 392     QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 393     QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 394     QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 395     QString &replace(const QString &before, const QString &after,
 396                      Qt::CaseSensitivity cs = Qt::CaseSensitive);
 397     QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 398     QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
 399 #ifndef QT_NO_REGEXP
 400     QString &replace(const QRegExp &rx, const QString &after);
 401     inline QString &remove(const QRegExp &rx)
 402     { return replace(rx, QString()); }
 403 #endif
 404 #ifndef QT_NO_REGEXP
 405     QString &replace(const QRegularExpression &re, const QString  &after);
 406     inline QString &remove(const QRegularExpression &re)
 407     { return replace(re, QString()); }
 408 #endif
 409
 410     enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };
 411
 412     QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
 413                       Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT;
 414     QStringList split(QChar sep, SplitBehavior behavior = KeepEmptyParts,
 415                       Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT;
 416 #ifndef QT_NO_REGEXP
 417     QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const Q_REQUIRED_RESULT;
 418 #endif
 419 #ifndef QT_NO_REGEXP
 420     QStringList split(const QRegularExpression &sep, SplitBehavior behavior = KeepEmptyParts) const Q_REQUIRED_RESULT;
 421 #endif
 422     enum NormalizationForm {
 423         NormalizationForm_D,
 424         NormalizationForm_C,
 425         NormalizationForm_KD,
 426         NormalizationForm_KC
 427     };
 428     QString normalized(NormalizationForm mode) const Q_REQUIRED_RESULT;
 429     QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const Q_REQUIRED_RESULT;
 430
 431     QString repeated(int times) const;
 432
 433     const ushort *utf16() const;
 434
 435     QByteArray toAscii() const Q_REQUIRED_RESULT;
 436     QByteArray toLatin1() const Q_REQUIRED_RESULT;
 437     QByteArray toUtf8() const Q_REQUIRED_RESULT;
 438     QByteArray toLocal8Bit() const Q_REQUIRED_RESULT;
 439     QVector<uint> toUcs4() const Q_REQUIRED_RESULT;
 440
 441     // note - this are all inline so we can benefit from strlen() compile time optimizations
 442     static inline QString fromAscii(const char *str, int size = -1)
 443     {
 444         QStringDataPtr dataPtr = { fromAscii_helper(str, (str && size == -1) ? int(strlen(str)) : size) };
 445         return QString(dataPtr);
 446     }
 447     static inline QString fromLatin1(const char *str, int size = -1)
 448     {
 449         QStringDataPtr dataPtr = { fromLatin1_helper(str, (str && size == -1) ? int(strlen(str)) : size) };
 450         return QString(dataPtr);
 451     }
 452     static inline QString fromUtf8(const char *str, int size = -1)
 453     {
 454         return fromUtf8_helper(str, (str && size == -1) ? int(strlen(str)) : size);
 455     }
 456     static inline QString fromLocal8Bit(const char *str, int size = -1)
 457     {
 458         return fromLocal8Bit_helper(str, (str && size == -1) ? int(strlen(str)) : size);
 459     }
 460     static inline QString fromAscii(const QByteArray &str) { return fromAscii(str.data(), str.size()); }
 461     static inline QString fromLatin1(const QByteArray &str) { return fromLatin1(str.data(), str.size()); }
 462     static inline QString fromUtf8(const QByteArray &str) { return fromUtf8(str.data(), str.size()); }
 463     static inline QString fromLocal8Bit(const QByteArray &str) { return fromLocal8Bit(str.data(), str.size()); }
 464     static QString fromUtf16(const ushort *, int size = -1);
 465     static QString fromUcs4(const uint *, int size = -1);
 466     static QString fromRawData(const QChar *, int size);
 467
 468     inline int toWCharArray(wchar_t *array) const;
 469     static inline QString fromWCharArray(const wchar_t *string, int size = -1) Q_REQUIRED_RESULT;
 470
 471     QString &setRawData(const QChar *unicode, int size);
 472     QString &setUnicode(const QChar *unicode, int size);
 473     inline QString &setUtf16(const ushort *utf16, int size);
 474
 475     int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 476     int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 477
 478     static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
 479     { return s1.compare(s2, cs); }
 480
 481     static inline int compare(const QString& s1, const QLatin1String &s2,
 482                               Qt::CaseSensitivity cs = Qt::CaseSensitive)
 483     { return s1.compare(s2, cs); }
 484     static inline int compare(const QLatin1String& s1, const QString &s2,
 485                               Qt::CaseSensitivity cs = Qt::CaseSensitive)
 486     { return -s2.compare(s1, cs); }
 487
 488     int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 489     static int compare(const QString &s1, const QStringRef &s2,
 490                        Qt::CaseSensitivity = Qt::CaseSensitive);
 491
 492     int localeAwareCompare(const QString& s) const;
 493     static int localeAwareCompare(const QString& s1, const QString& s2)
 494     { return s1.localeAwareCompare(s2); }
 495
 496     int localeAwareCompare(const QStringRef &s) const;
 497     static int localeAwareCompare(const QString& s1, const QStringRef& s2);
 498
 499     short  toShort(bool *ok=0, int base=10) const;
 500     ushort toUShort(bool *ok=0, int base=10) const;
 501     int toInt(bool *ok=0, int base=10) const;
 502     uint toUInt(bool *ok=0, int base=10) const;
 503     long toLong(bool *ok=0, int base=10) const;
 504     ulong toULong(bool *ok=0, int base=10) const;
 505     qlonglong toLongLong(bool *ok=0, int base=10) const;
 506     qulonglong toULongLong(bool *ok=0, int base=10) const;
 507     float toFloat(bool *ok=0) const;
 508     double toDouble(bool *ok=0) const;
 509
 510     QString &setNum(short, int base=10);
 511     QString &setNum(ushort, int base=10);
 512     QString &setNum(int, int base=10);
 513     QString &setNum(uint, int base=10);
 514     QString &setNum(long, int base=10);
 515     QString &setNum(ulong, int base=10);
 516     QString &setNum(qlonglong, int base=10);
 517     QString &setNum(qulonglong, int base=10);
 518     QString &setNum(float, char f='g', int prec=6);
 519     QString &setNum(double, char f='g', int prec=6);
 520
 521     static QString number(int, int base=10);
 522     static QString number(uint, int base=10);
 523     static QString number(long, int base=10);
 524     static QString number(ulong, int base=10);
 525     static QString number(qlonglong, int base=10);
 526     static QString number(qulonglong, int base=10);
 527     static QString number(double, char f='g', int prec=6);
 528
 529     friend Q_CORE_EXPORT bool operator==(const QString &s1, const QString &s2);
 530     friend Q_CORE_EXPORT bool operator<(const QString &s1, const QString &s2);
 531     friend inline bool operator>(const QString &s1, const QString &s2) { return s2 < s1; }
 532     friend inline bool operator!=(const QString &s1, const QString &s2) { return !(s1 == s2); }
 533     friend inline bool operator<=(const QString &s1, const QString &s2) { return !(s1 > s2); }
 534     friend inline bool operator>=(const QString &s1, const QString &s2) { return !(s1 < s2); }
 535
 536     bool operator==(const QLatin1String &s) const;
 537     bool operator<(const QLatin1String &s) const;
 538     bool operator>(const QLatin1String &s) const;
 539     inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }
 540     inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }
 541     inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }
 542
 543     // ASCII compatibility
 544 #ifndef QT_NO_CAST_FROM_ASCII
 545     inline QT_ASCII_CAST_WARN QString(const char *ch)
 546         : d(fromAscii_helper(ch, ch ? int(strlen(ch)) : -1))
 547     {}
 548     inline QT_ASCII_CAST_WARN QString(const QByteArray &a)
 549         : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
 550     {}
 551     inline QT_ASCII_CAST_WARN QString &operator=(const char *ch)
 552     { return (*this = fromAscii(ch, ch ? int(strlen(ch)) : -1)); }
 553     inline QT_ASCII_CAST_WARN QString &operator=(const QByteArray &a)
 554     { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); }
 555     inline QT_ASCII_CAST_WARN QString &operator=(char c)
 556     { return (*this = QChar::fromAscii(c)); }
 557
 558     // these are needed, so it compiles with STL support enabled
 559     inline QT_ASCII_CAST_WARN QString &prepend(const char *s)
 560     { return prepend(QString::fromAscii(s, s ? int(strlen(s)) : -1)); }
 561     inline QT_ASCII_CAST_WARN QString &prepend(const QByteArray &s)
 562     { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
 563     inline QT_ASCII_CAST_WARN QString &append(const char *s)
 564     { return append(QString::fromAscii(s, s ? int(strlen(s)) : -1)); }
 565     inline QT_ASCII_CAST_WARN QString &append(const QByteArray &s)
 566     { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
 567     inline QT_ASCII_CAST_WARN QString &operator+=(const char *s)
 568     { return append(QString::fromAscii(s, s ? int(strlen(s)) : -1)); }
 569     inline QT_ASCII_CAST_WARN QString &operator+=(const QByteArray &s)
 570     { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
 571     inline QT_ASCII_CAST_WARN QString &operator+=(char c)
 572     { return append(QChar::fromAscii(c)); }
 573
 574     inline QT_ASCII_CAST_WARN bool operator==(const char *s) const;
 575     inline QT_ASCII_CAST_WARN bool operator!=(const char *s) const;
 576     inline QT_ASCII_CAST_WARN bool operator<(const char *s) const;
 577     inline QT_ASCII_CAST_WARN bool operator<=(const char *s2) const;
 578     inline QT_ASCII_CAST_WARN bool operator>(const char *s2) const;
 579     inline QT_ASCII_CAST_WARN bool operator>=(const char *s2) const;
 580
 581     inline QT_ASCII_CAST_WARN bool operator==(const QByteArray &s) const;
 582     inline QT_ASCII_CAST_WARN bool operator!=(const QByteArray &s) const;
 583     inline QT_ASCII_CAST_WARN bool operator<(const QByteArray &s) const
 584     { return *this < QString::fromAscii(s.constData(), s.size()); }
 585     inline QT_ASCII_CAST_WARN bool operator>(const QByteArray &s) const
 586     { return *this > QString::fromAscii(s.constData(), s.size()); }
 587     inline QT_ASCII_CAST_WARN bool operator<=(const QByteArray &s) const
 588     { return *this <= QString::fromAscii(s.constData(), s.size()); }
 589     inline QT_ASCII_CAST_WARN bool operator>=(const QByteArray &s) const
 590     { return *this >= QString::fromAscii(s.constData(), s.size()); }
 591 #endif
 592
 593     typedef QChar *iterator;
 594     typedef const QChar *const_iterator;
 595     typedef iterator Iterator;
 596     typedef const_iterator ConstIterator;
 597     iterator begin();
 598     const_iterator begin() const;
 599     const_iterator cbegin() const;
 600     const_iterator constBegin() const;
 601     iterator end();
 602     const_iterator end() const;
 603     const_iterator cend() const;
 604     const_iterator constEnd() const;
 605
 606     // STL compatibility
 607     typedef const QChar & const_reference;
 608     typedef QChar & reference;
 609     typedef QChar value_type;
 610     inline void push_back(QChar c) { append(c); }
 611     inline void push_back(const QString &s) { append(s); }
 612     inline void push_front(QChar c) { prepend(c); }
 613     inline void push_front(const QString &s) { prepend(s); }
 614
 615     static inline QString fromStdString(const std::string &s);
 616     inline std::string toStdString() const;
 617     static inline QString fromStdWString(const std::wstring &s);
 618     inline std::wstring toStdWString() const;
 619
 620     // compatibility
 621     struct Null { };
 622     static const Null null;
 623     inline QString(const Null &): d(shared_null.data_ptr()) {}
 624     inline QString &operator=(const Null &) { *this = QString(); return *this; }
 625     inline bool isNull() const { return d == &shared_null.str; }
 626
 627
 628     bool isSimpleText() const;
 629     bool isRightToLeft() const;
 630
 631     QString(int size, Qt::Initialization);
 632     Q_DECL_CONSTEXPR inline QString(QStringDataPtr dd) : d(dd.ptr) {}
 633
 634 private:
 635 #if defined(QT_NO_CAST_FROM_ASCII) && !defined(Q_NO_DECLARED_NOT_DEFINED)
 636     QString &operator+=(const char *s);
 637     QString &operator+=(const QByteArray &s);
 638     QString(const char *ch);
 639     QString(const QByteArray &a);
 640     QString &operator=(const char  *ch);
 641     QString &operator=(const QByteArray &a);
 642 #endif
 643
 644     static const QStaticStringData<1> shared_null;
 645     static const QStaticStringData<1> shared_empty;
 646     Data *d;
 647
 648     static void free(Data *);
 649     void reallocData(int alloc, bool grow = false);
 650     void expand(int i);
 651     void updateProperties() const;
 652     QString multiArg(int numArgs, const QString **args) const;
 653     static int compare_helper(const QChar *data1, int length1,
 654                               const QChar *data2, int length2,
 655                               Qt::CaseSensitivity cs = Qt::CaseSensitive);
 656     static int compare_helper(const QChar *data1, int length1,
 657                               QLatin1String s2,
 658                               Qt::CaseSensitivity cs = Qt::CaseSensitive);
 659     static int localeAwareCompare_helper(const QChar *data1, int length1,
 660                                          const QChar *data2, int length2);
 661     static Data *fromLatin1_helper(const char *str, int size = -1);
 662     static Data *fromAscii_helper(const char *str, int size = -1);
 663     static QString fromUtf8_helper(const char *str, int size);
 664     static QString fromLocal8Bit_helper(const char *, int size);
 665     static int toUcs4_helper(const ushort *uc, int length, uint *out);
 666     void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
 667     friend class QCharRef;
 668     friend class QTextCodec;
 669     friend class QStringRef;
 670     friend struct QAbstractConcatenable;
 671     friend inline bool qStringComparisonHelper(const QString &s1, const char *s2);
 672     friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2);
 673 public:
 674     typedef Data * DataPtr;
 675     inline DataPtr &data_ptr() { return d; }
 676 };
 677
 678
 679 class QLatin1String
 680 {
 681 public:
 682     Q_DECL_CONSTEXPR inline explicit QLatin1String(const char *s) : m_size(s ? int(strlen(s)) : 0), m_data(s) {}
 683     Q_DECL_CONSTEXPR inline explicit QLatin1String(const char *s, int sz) : m_size(sz), m_data(s) {}
 684     inline explicit QLatin1String(const QByteArray &s) : m_size(int(strlen(s.constData()))), m_data(s.constData()) {}
 685
 686     inline const char *latin1() const { return m_data; }
 687     inline int size() const { return m_size; }
 688     inline const char *data() const { return m_data; }
 689
 690     inline bool operator==(const QString &s) const
 691     { return s == *this; }
 692     inline bool operator!=(const QString &s) const
 693     { return s != *this; }
 694     inline bool operator>(const QString &s) const
 695     { return s < *this; }
 696     inline bool operator<(const QString &s) const
 697     { return s > *this; }
 698     inline bool operator>=(const QString &s) const
 699     { return s <= *this; }
 700     inline bool operator<=(const QString &s) const
 701     { return s >= *this; }
 702
 703     inline QT_ASCII_CAST_WARN bool operator==(const char *s) const
 704         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) == *this; }
 705     inline QT_ASCII_CAST_WARN bool operator!=(const char *s) const
 706         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) != *this; }
 707     inline QT_ASCII_CAST_WARN bool operator<(const char *s) const
 708         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) > *this; }
 709     inline QT_ASCII_CAST_WARN bool operator>(const char *s) const
 710         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) < *this; }
 711     inline QT_ASCII_CAST_WARN bool operator<=(const char *s) const
 712         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) >= *this; }
 713     inline QT_ASCII_CAST_WARN bool operator>=(const char *s) const
 714         { return QString::fromAscii(s, s ? int(strlen(s)) : -1) <= *this; }
 715 private:
 716     int m_size;
 717     const char *m_data;
 718 };
 719
 720 // Qt 4.x compatibility
 721 typedef QLatin1String QLatin1Literal;
 722
 723
 724 inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1(), aLatin1.size()))
 725 { }
 726 inline int QString::length() const
 727 { return d->size; }
 728 inline const QChar QString::at(int i) const
 729 { Q_ASSERT(uint(i) < uint(size())); return d->data()[i]; }
 730 inline const QChar QString::operator[](int i) const
 731 { Q_ASSERT(uint(i) < uint(size())); return d->data()[i]; }
 732 inline const QChar QString::operator[](uint i) const
 733 { Q_ASSERT(i < uint(size())); return d->data()[i]; }
 734 inline bool QString::isEmpty() const
 735 { return d->size == 0; }
 736 inline const QChar *QString::unicode() const
 737 { return reinterpret_cast<const QChar*>(d->data()); }
 738 inline const QChar *QString::data() const
 739 { return reinterpret_cast<const QChar*>(d->data()); }
 740 inline QChar *QString::data()
 741 { detach(); return reinterpret_cast<QChar*>(d->data()); }
 742 inline const QChar *QString::constData() const
 743 { return reinterpret_cast<const QChar*>(d->data()); }
 744 inline void QString::detach()
 745 { if (d->ref.isShared() || (d->offset != sizeof(QStringData))) reallocData(d->size); }
 746 inline bool QString::isDetached() const
 747 { return !d->ref.isShared(); }
 748 inline QString &QString::operator=(const QLatin1String &s)
 749 {
 750     *this = fromLatin1(s.latin1(), s.size());
 751     return *this;
 752 }
 753 inline void QString::clear()
 754 { if (!isNull()) *this = QString(); }
 755 inline QString::QString(const QString &other) : d(other.d)
 756 { Q_ASSERT(&other != this); d->ref.ref(); }
 757 inline int QString::capacity() const
 758 { return d->alloc; }
 759 inline QString &QString::setNum(short n, int base)
 760 { return setNum(qlonglong(n), base); }
 761 inline QString &QString::setNum(ushort n, int base)
 762 { return setNum(qulonglong(n), base); }
 763 inline QString &QString::setNum(int n, int base)
 764 { return setNum(qlonglong(n), base); }
 765 inline QString &QString::setNum(uint n, int base)
 766 { return setNum(qulonglong(n), base); }
 767 inline QString &QString::setNum(long n, int base)
 768 { return setNum(qlonglong(n), base); }
 769 inline QString &QString::setNum(ulong n, int base)
 770 { return setNum(qulonglong(n), base); }
 771 inline QString &QString::setNum(float n, char f, int prec)
 772 { return setNum(double(n),f,prec); }
 773 inline QString QString::arg(int a, int fieldWidth, int base, QChar fillChar) const
 774 { return arg(qlonglong(a), fieldWidth, base, fillChar); }
 775 inline QString QString::arg(uint a, int fieldWidth, int base, QChar fillChar) const
 776 { return arg(qulonglong(a), fieldWidth, base, fillChar); }
 777 inline QString QString::arg(long a, int fieldWidth, int base, QChar fillChar) const
 778 { return arg(qlonglong(a), fieldWidth, base, fillChar); }
 779 inline QString QString::arg(ulong a, int fieldWidth, int base, QChar fillChar) const
 780 { return arg(qulonglong(a), fieldWidth, base, fillChar); }
 781 inline QString QString::arg(short a, int fieldWidth, int base, QChar fillChar) const
 782 { return arg(qlonglong(a), fieldWidth, base, fillChar); }
 783 inline QString QString::arg(ushort a, int fieldWidth, int base, QChar fillChar) const
 784 { return arg(qulonglong(a), fieldWidth, base, fillChar); }
 785 inline QString QString::arg(const QString &a1, const QString &a2) const
 786 { const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); }
 787 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
 788 { const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); }
 789 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 790                             const QString &a4) const
 791 { const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); }
 792 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 793                             const QString &a4, const QString &a5) const
 794 { const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); }
 795 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 796                             const QString &a4, const QString &a5, const QString &a6) const
 797 { const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); }
 798 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 799                             const QString &a4, const QString &a5, const QString &a6,
 800                             const QString &a7) const
 801 { const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6,  &a7 }; return multiArg(7, args); }
 802 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 803                             const QString &a4, const QString &a5, const QString &a6,
 804                             const QString &a7, const QString &a8) const
 805 { const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6,  &a7, &a8 }; return multiArg(8, args); }
 806 inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
 807                             const QString &a4, const QString &a5, const QString &a6,
 808                             const QString &a7, const QString &a8, const QString &a9) const
 809 { const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6,  &a7, &a8, &a9 }; return multiArg(9, args); }
 810
 811 inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
 812 { return section(QString(asep), astart, aend, aflags); }
 813
 814 inline int QString::toWCharArray(wchar_t *array) const
 815 {
 816     if (sizeof(wchar_t) == sizeof(QChar)) {
 817         qMemCopy(array, d->data(), sizeof(QChar) * size());
 818         return size();
 819     }
 820     return toUcs4_helper(d->data(), size(), reinterpret_cast<uint *>(array));
 821 }
 822 inline QString QString::fromWCharArray(const wchar_t *string, int size)
 823 {
 824     return sizeof(wchar_t) == sizeof(QChar) ? fromUtf16(reinterpret_cast<const ushort *>(string), size)
 825                                             : fromUcs4(reinterpret_cast<const uint *>(string), size);
 826 }
 827
 828
 829 class Q_CORE_EXPORT QCharRef {
 830     QString &s;
 831     int i;
 832     inline QCharRef(QString &str, int idx)
 833         : s(str),i(idx) {}
 834     friend class QString;
 835 public:
 836
 837     // most QChar operations repeated here
 838
 839     // all this is not documented: We just say "like QChar" and let it be.
 840     inline operator QChar() const
 841     { return i < s.d->size ? s.d->data()[i] : 0; }
 842     inline QCharRef &operator=(QChar c)
 843     { if (i >= s.d->size) s.expand(i); else s.detach();
 844       s.d->data()[i] = c.unicode(); return *this; }
 845
 846     // An operator= for each QChar cast constructors
 847 #ifndef QT_NO_CAST_FROM_ASCII
 848     inline QT_ASCII_CAST_WARN QCharRef &operator=(char c)
 849     { return operator=(QChar::fromAscii(c)); }
 850     inline QT_ASCII_CAST_WARN QCharRef &operator=(uchar c)
 851     { return operator=(QChar::fromAscii(c)); }
 852 #endif
 853     inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
 854     inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
 855     inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
 856     inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
 857     inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }
 858
 859     // each function...
 860     inline bool isNull() const { return QChar(*this).isNull(); }
 861     inline bool isPrint() const { return QChar(*this).isPrint(); }
 862     inline bool isPunct() const { return QChar(*this).isPunct(); }
 863     inline bool isSpace() const { return QChar(*this).isSpace(); }
 864     inline bool isMark() const { return QChar(*this).isMark(); }
 865     inline bool isLetter() const { return QChar(*this).isLetter(); }
 866     inline bool isNumber() const { return QChar(*this).isNumber(); }
 867     inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
 868     inline bool isDigit() const { return QChar(*this).isDigit(); }
 869     inline bool isLower() const { return QChar(*this).isLower(); }
 870     inline bool isUpper() const { return QChar(*this).isUpper(); }
 871     inline bool isTitleCase() const { return QChar(*this).isTitleCase(); }
 872
 873     inline int digitValue() const { return QChar(*this).digitValue(); }
 874     QChar toLower() const { return QChar(*this).toLower(); }
 875     QChar toUpper() const { return QChar(*this).toUpper(); }
 876     QChar toTitleCase () const { return QChar(*this).toTitleCase(); }
 877
 878     QChar::Category category() const { return QChar(*this).category(); }
 879     QChar::Direction direction() const { return QChar(*this).direction(); }
 880     QChar::Joining joining() const { return QChar(*this).joining(); }
 881     bool hasMirrored() const { return QChar(*this).hasMirrored(); }
 882     QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
 883     QString decomposition() const { return QChar(*this).decomposition(); }
 884     QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
 885     uchar combiningClass() const { return QChar(*this).combiningClass(); }
 886
 887     QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }
 888
 889     inline uchar cell() const { return QChar(*this).cell(); }
 890     inline uchar row() const { return QChar(*this).row(); }
 891     inline void setCell(uchar cell);
 892     inline void setRow(uchar row);
 893
 894     char toAscii() const { return QChar(*this).toAscii(); }
 895     char toLatin1() const { return QChar(*this).toLatin1(); }
 896     ushort unicode() const { return QChar(*this).unicode(); }
 897     ushort& unicode() { return s.data()[i].unicode(); }
 898
 899 };
 900
 901 inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
 902 inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }
 903
 904
 905 inline QString::QString() : d(shared_null.data_ptr()) {}
 906 inline QString::~QString() { if (!d->ref.deref()) free(d); }
 907
 908 inline void QString::reserve(int asize)
 909 {
 910     if (d->ref.isShared() || asize > int(d->alloc))
 911         reallocData(asize);
 912
 913     if (!d->capacityReserved) {
 914         // cannot set unconditionally, since d could be the shared_null/shared_empty (which is const)
 915         d->capacityReserved = true;
 916     }
 917 }
 918
 919 inline void QString::squeeze()
 920 {
 921     if (d->ref.isShared() || d->size < int(d->alloc))
 922         reallocData(d->size);
 923
 924     if (d->capacityReserved) {
 925         // cannot set unconditionally, since d could be shared_null or
 926         // otherwise static.
 927         d->capacityReserved = false;
 928     }
 929 }
 930
 931 inline QString &QString::setUtf16(const ushort *autf16, int asize)
 932 { return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
 933 inline QCharRef QString::operator[](int i)
 934 { Q_ASSERT(i >= 0); return QCharRef(*this, i); }
 935 inline QCharRef QString::operator[](uint i)
 936 { return QCharRef(*this, i); }
 937 inline QString::iterator QString::begin()
 938 { detach(); return reinterpret_cast<QChar*>(d->data()); }
 939 inline QString::const_iterator QString::begin() const
 940 { return reinterpret_cast<const QChar*>(d->data()); }
 941 inline QString::const_iterator QString::cbegin() const
 942 { return reinterpret_cast<const QChar*>(d->data()); }
 943 inline QString::const_iterator QString::constBegin() const
 944 { return reinterpret_cast<const QChar*>(d->data()); }
 945 inline QString::iterator QString::end()
 946 { detach(); return reinterpret_cast<QChar*>(d->data() + d->size); }
 947 inline QString::const_iterator QString::end() const
 948 { return reinterpret_cast<const QChar*>(d->data() + d->size); }
 949 inline QString::const_iterator QString::cend() const
 950 { return reinterpret_cast<const QChar*>(d->data() + d->size); }
 951 inline QString::const_iterator QString::constEnd() const
 952 { return reinterpret_cast<const QChar*>(d->data() + d->size); }
 953 inline bool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
 954 { return indexOf(s, 0, cs) != -1; }
 955 inline bool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
 956 { return indexOf(s, 0, cs) != -1; }
 957 inline bool QString::contains(QChar c, Qt::CaseSensitivity cs) const
 958 { return indexOf(c, 0, cs) != -1; }
 959
 960
 961 inline bool operator==(QString::Null, QString::Null) { return true; }
 962 inline bool operator==(QString::Null, const QString &s) { return s.isNull(); }
 963 inline bool operator==(const QString &s, QString::Null) { return s.isNull(); }
 964 inline bool operator!=(QString::Null, QString::Null) { return false; }
 965 inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); }
 966 inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); }
 967
 968 #ifndef QT_NO_CAST_FROM_ASCII
 969 inline bool qStringComparisonHelper(const QString &s1, const char *s2)
 970 {
 971     return (s1 == QLatin1String(s2));
 972 }
 973 inline bool QString::operator==(const char *s) const
 974 { return qStringComparisonHelper(*this, s); }
 975 inline bool QString::operator!=(const char *s) const
 976 { return !qStringComparisonHelper(*this, s); }
 977 inline bool QString::operator<(const char *s) const
 978 { return *this < QString::fromAscii(s, s ? int(strlen(s)) : -1); }
 979 inline bool QString::operator>(const char *s) const
 980 { return *this > QString::fromAscii(s, s ? int(strlen(s)) : -1); }
 981 inline bool QString::operator<=(const char *s) const
 982 { return *this <= QString::fromAscii(s, s ? int(strlen(s)) : -1); }
 983 inline bool QString::operator>=(const char *s) const
 984 { return *this >= QString::fromAscii(s, s ? int(strlen(s)) : -1); }
 985
 986 inline QT_ASCII_CAST_WARN bool operator==(const char *s1, const QString &s2)
 987 { return qStringComparisonHelper(s2, s1); }
 988 inline QT_ASCII_CAST_WARN bool operator!=(const char *s1, const QString &s2)
 989 { return !qStringComparisonHelper(s2, s1); }
 990 inline QT_ASCII_CAST_WARN bool operator<(const char *s1, const QString &s2)
 991 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) < s2); }
 992 inline QT_ASCII_CAST_WARN bool operator>(const char *s1, const QString &s2)
 993 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) > s2); }
 994 inline QT_ASCII_CAST_WARN bool operator<=(const char *s1, const QString &s2)
 995 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) <= s2); }
 996 inline QT_ASCII_CAST_WARN bool operator>=(const char *s1, const QString &s2)
 997 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) >= s2); }
 998
 999 inline QT_ASCII_CAST_WARN bool operator==(const char *s1, const QLatin1String &s2)
1000 { return QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) == s2; }
1001 inline QT_ASCII_CAST_WARN bool operator!=(const char *s1, const QLatin1String &s2)
1002 { return QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) != s2; }
1003 inline QT_ASCII_CAST_WARN bool operator<(const char *s1, const QLatin1String &s2)
1004 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) < s2); }
1005 inline QT_ASCII_CAST_WARN bool operator>(const char *s1, const QLatin1String &s2)
1006 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) > s2); }
1007 inline QT_ASCII_CAST_WARN bool operator<=(const char *s1, const QLatin1String &s2)
1008 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) <= s2); }
1009 inline QT_ASCII_CAST_WARN bool operator>=(const char *s1, const QLatin1String &s2)
1010 { return (QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1) >= s2); }
1011
1012 inline bool operator==(const QLatin1String &s1, const QLatin1String &s2)
1013 { return (s1.size() == s2.size() && !memcmp(s1.latin1(), s2.latin1(), s1.size())); }
1014 inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2)
1015 { return (s1.size() != s2.size() || memcmp(s1.latin1(), s2.latin1(), s1.size())); }
1016 inline bool operator<(const QLatin1String &s1, const QLatin1String &s2)
1017 { int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
1018   return (r < 0) || (r == 0 && s1.size() < s2.size()); }
1019 inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2)
1020 { int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
1021   return (r < 0) || (r == 0 && s1.size() <= s2.size()); }
1022 inline bool operator>(const QLatin1String &s1, const QLatin1String &s2)
1023 { int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
1024   return (r > 0) || (r == 0 && s1.size() > s2.size()); }
1025 inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2)
1026 { int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
1027   return (r > 0) || (r == 0 && s1.size() >= s2.size()); }
1028
1029
1030 inline bool QString::operator==(const QByteArray &s) const
1031 { return qStringComparisonHelper(*this, s.constData()); }
1032 inline bool QString::operator!=(const QByteArray &s) const
1033 { return !qStringComparisonHelper(*this, s.constData()); }
1034
1035 inline bool QByteArray::operator==(const QString &s) const
1036 { return qStringComparisonHelper(s, constData()); }
1037 inline bool QByteArray::operator!=(const QString &s) const
1038 { return !qStringComparisonHelper(s, constData()); }
1039 inline bool QByteArray::operator<(const QString &s) const
1040 { return QString::fromAscii(constData(), size()) < s; }
1041 inline bool QByteArray::operator>(const QString &s) const
1042 { return QString::fromAscii(constData(), size()) > s; }
1043 inline bool QByteArray::operator<=(const QString &s) const
1044 { return QString::fromAscii(constData(), size()) <= s; }
1045 inline bool QByteArray::operator>=(const QString &s) const
1046 { return QString::fromAscii(constData(), size()) >= s; }
1047 #endif   // QT_NO_CAST_FROM_ASCII
1048
1049 #ifndef QT_NO_CAST_TO_ASCII
1050 inline QByteArray &QByteArray::append(const QString &s)
1051 { return append(s.toAscii()); }
1052 inline QByteArray &QByteArray::insert(int i, const QString &s)
1053 { return insert(i, s.toAscii()); }
1054 inline QByteArray &QByteArray::replace(char c, const QString &after)
1055 { return replace(c, after.toAscii()); }
1056 inline QByteArray &QByteArray::replace(const QString &before, const char *after)
1057 { return replace(before.toAscii(), after); }
1058 inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)
1059 { return replace(before.toAscii(), after); }
1060 inline QByteArray &QByteArray::operator+=(const QString &s)
1061 { return operator+=(s.toAscii()); }
1062 inline int QByteArray::indexOf(const QString &s, int from) const
1063 { return indexOf(s.toAscii(), from); }
1064 inline int QByteArray::lastIndexOf(const QString &s, int from) const
1065 { return lastIndexOf(s.toAscii(), from); }
1066 #endif // QT_NO_CAST_TO_ASCII
1067
1068 #if !defined(QT_USE_FAST_OPERATOR_PLUS) && !defined(QT_USE_QSTRINGBUILDER)
1069 inline const QString operator+(const QString &s1, const QString &s2)
1070 { QString t(s1); t += s2; return t; }
1071 inline const QString operator+(const QString &s1, QChar s2)
1072 { QString t(s1); t += s2; return t; }
1073 inline const QString operator+(QChar s1, const QString &s2)
1074 { QString t(s1); t += s2; return t; }
1075 #  ifndef QT_NO_CAST_FROM_ASCII
1076 inline QT_ASCII_CAST_WARN const QString operator+(const QString &s1, const char *s2)
1077 { QString t(s1); t += QString::fromAscii(s2, s2 ? int(strlen(s2)) : -1); return t; }
1078 inline QT_ASCII_CAST_WARN const QString operator+(const char *s1, const QString &s2)
1079 { QString t = QString::fromAscii(s1, s1 ? int(strlen(s1)) : -1); t += s2; return t; }
1080 inline QT_ASCII_CAST_WARN const QString operator+(char c, const QString &s)
1081 { QString t = s; t.prepend(QChar::fromAscii(c)); return t; }
1082 inline QT_ASCII_CAST_WARN const QString operator+(const QString &s, char c)
1083 { QString t = s; t += QChar::fromAscii(c); return t; }
1084 inline QT_ASCII_CAST_WARN const QString operator+(const QByteArray &ba, const QString &s)
1085 { QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; }
1086 inline QT_ASCII_CAST_WARN const QString operator+(const QString &s, const QByteArray &ba)
1087 { QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; }
1088 #  endif // QT_NO_CAST_FROM_ASCII
1089 #endif // QT_USE_QSTRINGBUILDER
1090
1091 inline std::string QString::toStdString() const
1092 { const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); }
1093
1094 inline QString QString::fromStdString(const std::string &s)
1095 { return fromAscii(s.data(), int(s.size())); }
1096
1097 inline std::wstring QString::toStdWString() const
1098 {
1099     std::wstring str;
1100     str.resize(length());
1101
1102 #if defined(_MSC_VER) && _MSC_VER >= 1400
1103     // VS2005 crashes if the string is empty
1104     if (!length())
1105         return str;
1106 #endif
1107
1108     str.resize(toWCharArray(&(*str.begin())));
1109     return str;
1110 }
1111
1112 inline QString QString::fromStdWString(const std::wstring &s)
1113 { return fromWCharArray(s.data(), int(s.size())); }
1114
1115 #if !defined(QT_NO_DATASTREAM) || (defined(QT_BOOTSTRAPPED) && !defined(QT_BUILD_QMAKE))
1116 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QString &);
1117 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QString &);
1118 #endif
1119
1120 Q_DECLARE_TYPEINFO(QString, Q_MOVABLE_TYPE);
1121 Q_DECLARE_SHARED(QString)
1122 Q_DECLARE_OPERATORS_FOR_FLAGS(QString::SectionFlags)
1123
1124
1125 class Q_CORE_EXPORT QStringRef {
1126     const QString *m_string;
1127     int m_position;
1128     int m_size;
1129 public:
1130     inline QStringRef():m_string(0), m_position(0), m_size(0){}
1131     inline QStringRef(const QString *string, int position, int size);
1132     inline QStringRef(const QString *string);
1133     inline QStringRef(const QStringRef &other)
1134         :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
1135         {}
1136
1137     inline ~QStringRef(){}
1138     inline const QString *string() const { return m_string; }
1139     inline int position() const { return m_position; }
1140     inline int size() const { return m_size; }
1141     inline int count() const { return m_size; }
1142     inline int length() const { return m_size; }
1143
1144     inline QStringRef &operator=(const QStringRef &other) {
1145         m_string = other.m_string; m_position = other.m_position;
1146         m_size = other.m_size; return *this;
1147     }
1148
1149     int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1150     int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1151     int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1152     int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1153     int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1154     int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1155     int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1156     int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1157
1158     inline bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1159     inline bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1160     inline bool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1161     inline bool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1162
1163     int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1164     int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1165     int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1166
1167     bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1168     bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1169     bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1170     bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1171
1172     bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1173     bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1174     bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1175     bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1176
1177     inline QStringRef &operator=(const QString *string);
1178
1179     inline const QChar *unicode() const {
1180         if (!m_string)
1181             return reinterpret_cast<const QChar *>(QString::shared_null.str.data());
1182         return m_string->unicode() + m_position;
1183     }
1184     inline const QChar *data() const { return unicode(); }
1185     inline const QChar *constData() const {  return unicode(); }
1186
1187     QByteArray toAscii() const Q_REQUIRED_RESULT;
1188     QByteArray toLatin1() const Q_REQUIRED_RESULT;
1189     QByteArray toUtf8() const Q_REQUIRED_RESULT;
1190     QByteArray toLocal8Bit() const Q_REQUIRED_RESULT;
1191     QVector<uint> toUcs4() const Q_REQUIRED_RESULT;
1192
1193     inline void clear() { m_string = 0; m_position = m_size = 0; }
1194     QString toString() const;
1195     inline bool isEmpty() const { return m_size == 0; }
1196     inline bool isNull() const { return m_string == 0 || m_string->isNull(); }
1197
1198     QStringRef appendTo(QString *string) const;
1199
1200     inline const QChar at(int i) const
1201         { Q_ASSERT(i >= 0 && i < size()); return m_string->at(i + m_position); }
1202
1203     int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1204     int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1205     int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
1206     static int compare(const QStringRef &s1, const QString &s2,
1207                        Qt::CaseSensitivity = Qt::CaseSensitive);
1208     static int compare(const QStringRef &s1, const QStringRef &s2,
1209                        Qt::CaseSensitivity = Qt::CaseSensitive);
1210     static int compare(const QStringRef &s1, QLatin1String s2,
1211                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
1212
1213     int localeAwareCompare(const QString &s) const;
1214     int localeAwareCompare(const QStringRef &s) const;
1215     static int localeAwareCompare(const QStringRef &s1, const QString &s2);
1216     static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2);
1217 };
1218
1219 inline QStringRef &QStringRef::operator=(const QString *aString)
1220 { m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; }
1221
1222 inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
1223         :m_string(aString), m_position(aPosition), m_size(aSize){}
1224
1225 inline QStringRef::QStringRef(const QString *aString)
1226     :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}
1227
1228 Q_CORE_EXPORT bool operator==(const QStringRef &s1,const QStringRef &s2);
1229 inline bool operator!=(const QStringRef &s1,const QStringRef &s2)
1230 { return !(s1 == s2); }
1231 Q_CORE_EXPORT bool operator==(const QString &s1,const QStringRef &s2);
1232 inline bool operator!=(const QString &s1,const QStringRef &s2)
1233 { return !(s1 == s2); }
1234 inline bool operator==(const QStringRef &s1,const QString &s2)
1235 { return s2 == s1; }
1236 inline bool operator!=(const QStringRef &s1,const QString &s2)
1237 { return s2 != s1; }
1238 Q_CORE_EXPORT bool operator==(const QLatin1String &s1, const QStringRef &s2);
1239 inline bool operator!=(const QLatin1String &s1,const QStringRef &s2)
1240 { return !(s1 == s2); }
1241 inline bool operator==(const QStringRef &s1,const QLatin1String &s2)
1242 { return s2 == s1; }
1243 inline bool operator!=(const QStringRef &s1,const QLatin1String &s2)
1244 { return s2 != s1; }
1245
1246 Q_CORE_EXPORT bool operator<(const QStringRef &s1,const QStringRef &s2);
1247 inline bool operator>(const QStringRef &s1, const QStringRef &s2)
1248 { return s2 < s1; }
1249 inline bool operator<=(const QStringRef &s1, const QStringRef &s2)
1250 { return !(s1 > s2); }
1251 inline bool operator>=(const QStringRef &s1, const QStringRef &s2)
1252 { return !(s1 < s2); }
1253
1254 inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2)
1255 {
1256     return (s1 == QLatin1String(s2));
1257 }
1258
1259 inline QT_ASCII_CAST_WARN bool operator==(const char *s1, const QStringRef &s2)
1260 { return qStringComparisonHelper(s2, s1); }
1261 inline QT_ASCII_CAST_WARN bool operator==(const QStringRef &s1, const char *s2)
1262 { return qStringComparisonHelper(s1, s2); }
1263 inline QT_ASCII_CAST_WARN bool operator!=(const char *s1, const QStringRef &s2)
1264 { return !qStringComparisonHelper(s2, s1); }
1265 inline QT_ASCII_CAST_WARN bool operator!=(const QStringRef &s1, const char *s2)
1266 { return !qStringComparisonHelper(s1, s2); }
1267
1268 inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
1269 { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
1270 inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
1271 { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
1272 inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const
1273 { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
1274 inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
1275 { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
1276 inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const
1277 { return QString::compare_helper(constData(), length(), s, cs); }
1278 inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs)
1279 { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
1280 inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
1281 { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
1282 inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs)
1283 { return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }
1284
1285 inline int QString::localeAwareCompare(const QStringRef &s) const
1286 { return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
1287 inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
1288 { return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
1289 inline int QStringRef::localeAwareCompare(const QString &s) const
1290 { return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
1291 inline int QStringRef::localeAwareCompare(const QStringRef &s) const
1292 { return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
1293 inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2)
1294 { return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
1295 inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
1296 { return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
1297
1298 inline bool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const
1299 { return indexOf(s, 0, cs) != -1; }
1300 inline bool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const
1301 { return indexOf(s, 0, cs) != -1; }
1302 inline bool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const
1303 { return indexOf(c, 0, cs) != -1; }
1304 inline bool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
1305 { return indexOf(s, 0, cs) != -1; }
1306
1307 namespace Qt {
1308 #if QT_DEPRECATED_SINCE(5, 0)
1309 QT_DEPRECATED inline QString escape(const QString &plain) {
1310     return plain.toHtmlEscaped();
1311 }
1312 #endif
1313 }
1314
1315 QT_END_NAMESPACE
1316
1317 QT_END_HEADER
1318
1319 #if defined(QT_USE_FAST_OPERATOR_PLUS) || defined(QT_USE_QSTRINGBUILDER)
1320 #include <QtCore/qstringbuilder.h>
1321 #endif
1322
1323 #endif // QSTRING_H