/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QSTRING_H

#define QSTRING_H

#include <QtCore/qchar.h>

#include <QtCore/qbytearray.h>

#include <QtCore/qatomic.h>

#include <QtCore/qnamespace.h>

#ifdef QT_INCLUDE_COMPAT

#include <Qt3Support/q3cstring.h>

#endif

#ifndef QT_NO_STL

#  if defined (Q_CC_MSVC_NET) && _MSC_VER < 1310 // Avoids nasty warning for xlocale, line 450

#    pragma warning (push)

#    pragma warning (disable : 4189)

#    include <string>

#    pragma warning (pop)

#  else

#    include <string>

#  endif

#  ifndef QT_NO_STL_WCHAR

// workaround for some headers not typedef'ing std::wstring

typedef std::basic_string<wchar_t> QStdWString;

#  endif // QT_NO_STL_WCHAR

#endif // QT_NO_STL

#include <stdarg.h>

#ifdef truncate

#error qstring.h must be included before any header file that defines truncate

#endif

#if defined(Q_CC_GNU) && (__GNUC__ == 4 && __GNUC_MINOR__ == 0)

//There is a bug in GCC 4.0 that tries to instantiate template of annonymous enum

#  ifdef QT_USE_FAST_OPERATOR_PLUS

#    undef QT_USE_FAST_OPERATOR_PLUS

#  endif

#  ifdef QT_USE_FAST_CONCATENATION

#    undef QT_USE_FAST_CONCATENATION

#  endif

#endif

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(Core)

class QCharRef;

class QRegExp;

class QStringList;

class QTextCodec;

class QLatin1String;

class QStringRef;

template <typename T> class QVector;

class Q_CORE_EXPORT QString

{

public:

    inline QString();

    QString(const QChar *unicode, int size); // Qt5: don't cap size < 0

#ifdef QT_QCHAR_CONSTRUCTOR

    explicit QString(const QChar *unicode); // Qt5: merge with the above

#endif

    QString(QChar c);

    QString(int size, QChar c);

    inline QString(const QLatin1String &latin1);

    inline QString(const QString &);

    inline ~QString();

    QString &operator=(QChar c);

    QString &operator=(const QString &);

    inline QString &operator=(const QLatin1String &);

    inline int size() const { return d->size; }

    inline int count() const { return d->size; }

    inline int length() const;

    inline bool isEmpty() const;

    void resize(int size);

    QString &fill(QChar c, int size = -1);

    void truncate(int pos);

    void chop(int n);

    int capacity() const;

    inline void reserve(int size);

    inline void squeeze() { if (d->size < d->alloc || d->ref != 1) realloc(); d->capacity = 0;}

    inline const QChar *unicode() const;

    inline QChar *data();

    inline const QChar *data() const;

    inline const QChar *constData() const;

    inline void detach();

    inline bool isDetached() const;

    inline bool isSharedWith(const QString &other) const { return d == other.d; }

    void clear();

    inline const QChar at(int i) const;

    const QChar operator[](int i) const;

    QCharRef operator[](int i);

    const QChar operator[](uint i) const;

    QCharRef operator[](uint i);

    QString arg(qlonglong a, int fieldwidth=0, int base=10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(qulonglong a, int fieldwidth=0, int base=10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

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

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(ulong a, int fieldwidth=0, int base=10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(int a, int fieldWidth = 0, int base = 10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(uint a, int fieldWidth = 0, int base = 10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(short a, int fieldWidth = 0, int base = 10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(ushort a, int fieldWidth = 0, int base = 10,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(char a, int fieldWidth = 0,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(QChar a, int fieldWidth = 0,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(const QString &a, int fieldWidth = 0,

                const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4, const QString &a5) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4, const QString &a5, const QString &a6) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4, const QString &a5, const QString &a6,

                const QString &a7) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4, const QString &a5, const QString &a6,

                const QString &a7, const QString &a8) const Q_REQUIRED_RESULT;

    QString arg(const QString &a1, const QString &a2, const QString &a3,

                const QString &a4, const QString &a5, const QString &a6,

                const QString &a7, const QString &a8, const QString &a9) const Q_REQUIRED_RESULT;

    QString    &vsprintf(const char *format, va_list ap)

#if defined(Q_CC_GNU) && !defined(__INSURE__)

        __attribute__ ((format (printf, 2, 0)))

#endif

        ;

    QString    &sprintf(const char *format, ...)

#if defined(Q_CC_GNU) && !defined(__INSURE__)

        __attribute__ ((format (printf, 2, 3)))

#endif

        ;

    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

#ifndef QT_NO_REGEXP

    int indexOf(const QRegExp &, int from = 0) const;

    int lastIndexOf(const QRegExp &, int from = -1) const;

    inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); }

    int count(const QRegExp &) const;

    int indexOf(QRegExp &, int from = 0) const;

    int lastIndexOf(QRegExp &, int from = -1) const;

    inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); }

#endif

    enum SectionFlag {

        SectionDefault             = 0x00,

        SectionSkipEmpty           = 0x01,

        SectionIncludeLeadingSep   = 0x02,

        SectionIncludeTrailingSep  = 0x04,

        SectionCaseInsensitiveSeps = 0x08

    };

    Q_DECLARE_FLAGS(SectionFlags, SectionFlag)

    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;

    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;

#ifndef QT_NO_REGEXP

    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;

#endif

    QString left(int n) const Q_REQUIRED_RESULT;

    QString right(int n) const Q_REQUIRED_RESULT;

    QString mid(int position, int n = -1) const Q_REQUIRED_RESULT;

    QStringRef leftRef(int n) const Q_REQUIRED_RESULT;

    QStringRef rightRef(int n) const Q_REQUIRED_RESULT;

    QStringRef midRef(int position, int n = -1) const Q_REQUIRED_RESULT;

    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT;

    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT;

    QString toLower() const Q_REQUIRED_RESULT;

    QString toUpper() const Q_REQUIRED_RESULT;

    QString toCaseFolded() const Q_REQUIRED_RESULT;

    QString trimmed() const Q_REQUIRED_RESULT;

    QString simplified() const Q_REQUIRED_RESULT;

    QString &insert(int i, QChar c);

    QString &insert(int i, const QChar *uc, int len);

    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }

    QString &insert(int i, const QLatin1String &s);

    QString &append(QChar c);

    QString &append(const QString &s);

    QString &append(const QStringRef &s);

    QString &append(const QLatin1String &s);

    inline QString &prepend(QChar c) { return insert(0, c); }

    inline QString &prepend(const QString &s) { return insert(0, s); }

    inline QString &prepend(const QLatin1String &s) { return insert(0, s); }

    inline QString &operator+=(QChar c) {

        if (d->ref != 1 || d->size + 1 > d->alloc)

            realloc(grow(d->size + 1));

        d->data[d->size++] = c.unicode();

        d->data[d->size] = '\0';

        return *this;

    }

    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }

    inline QString &operator+=(const QString &s) { return append(s); }

    inline QString &operator+=(const QStringRef &s) { return append(s); }

    inline QString &operator+=(const QLatin1String &s) { return append(s); }

    QString &remove(int i, int len);

    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(int i, int len, QChar after);

    QString &replace(int i, int len, const QChar *s, int slen);

    QString &replace(int i, int len, const QString &after);

    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QString &before, const QString &after,

                     Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

#ifndef QT_NO_REGEXP

    QString &replace(const QRegExp &rx, const QString &after);

    inline QString &remove(const QRegExp &rx)

    { return replace(rx, QString()); }

#endif

    enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };

    QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,

                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT;

    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,

                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT;

#ifndef QT_NO_REGEXP

    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const Q_REQUIRED_RESULT;

#endif

    enum NormalizationForm {

        NormalizationForm_D,

        NormalizationForm_C,

        NormalizationForm_KD,

        NormalizationForm_KC

    };

    QString normalized(NormalizationForm mode) const Q_REQUIRED_RESULT;

    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const Q_REQUIRED_RESULT;

    QString repeated(int times) const;

    const ushort *utf16() const;

    QByteArray toAscii() const Q_REQUIRED_RESULT;

    QByteArray toLatin1() const Q_REQUIRED_RESULT;

    QByteArray toUtf8() const Q_REQUIRED_RESULT;

    QByteArray toLocal8Bit() const Q_REQUIRED_RESULT;

    QVector<uint> toUcs4() const Q_REQUIRED_RESULT;

    static QString fromAscii(const char *, int size = -1);

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

    static QString fromUtf8(const char *, int size = -1);

    static QString fromLocal8Bit(const char *, int size = -1);

    static QString fromUtf16(const ushort *, int size = -1);

    static QString fromUcs4(const uint *, int size = -1);

    static QString fromRawData(const QChar *, int size);

    int toWCharArray(wchar_t *array) const;

    static QString fromWCharArray(const wchar_t *, int size = -1);

    QString &setRawData(const QChar *unicode, int size);

    QString &setUnicode(const QChar *unicode, int size);

    inline QString &setUtf16(const ushort *utf16, int size);

    // ### Qt 5: merge these two functions

    int compare(const QString &s) const;

    int compare(const QString &s, Qt::CaseSensitivity cs) const;

    int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    // ### Qt 5: merge these two functions

    static inline int compare(const QString &s1, const QString &s2)

    { return s1.compare(s2); }

    static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs)

    { return s1.compare(s2, cs); }

    static inline int compare(const QString& s1, const QLatin1String &s2,

                              Qt::CaseSensitivity cs = Qt::CaseSensitive)

    { return s1.compare(s2, cs); }

    static inline int compare(const QLatin1String& s1, const QString &s2,

                              Qt::CaseSensitivity cs = Qt::CaseSensitive)

    { return -s2.compare(s1, cs); }

    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    static int compare(const QString &s1, const QStringRef &s2,

                       Qt::CaseSensitivity = Qt::CaseSensitive);

    int localeAwareCompare(const QString& s) const;

    static int localeAwareCompare(const QString& s1, const QString& s2)

    { return s1.localeAwareCompare(s2); }

    int localeAwareCompare(const QStringRef &s) const;

    static int localeAwareCompare(const QString& s1, const QStringRef& s2);

    short  toShort(bool *ok=0, int base=10) const;

    ushort toUShort(bool *ok=0, int base=10) const;

    int toInt(bool *ok=0, int base=10) const;

    uint toUInt(bool *ok=0, int base=10) const;

    long toLong(bool *ok=0, int base=10) const;

    ulong toULong(bool *ok=0, int base=10) const;

    qlonglong toLongLong(bool *ok=0, int base=10) const;

    qulonglong toULongLong(bool *ok=0, int base=10) const;

    float toFloat(bool *ok=0) const;

    double toDouble(bool *ok=0) const;

    QString &setNum(short, int base=10);

    QString &setNum(ushort, int base=10);

    QString &setNum(int, int base=10);

    QString &setNum(uint, int base=10);

    QString &setNum(long, int base=10);

    QString &setNum(ulong, int base=10);

    QString &setNum(qlonglong, int base=10);

    QString &setNum(qulonglong, int base=10);

    QString &setNum(float, char f='g', int prec=6);

    QString &setNum(double, char f='g', int prec=6);

    static QString number(int, int base=10);

    static QString number(uint, int base=10);

    static QString number(long, int base=10);

    static QString number(ulong, int base=10);

    static QString number(qlonglong, int base=10);

    static QString number(qulonglong, int base=10);

    static QString number(double, char f='g', int prec=6);

    bool operator==(const QString &s) const;

    bool operator<(const QString &s) const;

    inline bool operator>(const QString &s) const { return s < *this; }

    inline bool operator!=(const QString &s) const { return !operator==(s); }

    inline bool operator<=(const QString &s) const { return !operator>(s); }

    inline bool operator>=(const QString &s) const { return !operator<(s); }

    bool operator==(const QLatin1String &s) const;

    bool operator<(const QLatin1String &s) const;

    bool operator>(const QLatin1String &s) const;

    inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }

    inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }

    inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }

    // ASCII compatibility

#ifndef QT_NO_CAST_FROM_ASCII

    inline QT_ASCII_CAST_WARN_CONSTRUCTOR QString(const char *ch) : d(fromAscii_helper(ch))

    {}

    inline QT_ASCII_CAST_WARN_CONSTRUCTOR QString(const QByteArray &a)

        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))

    {}

    inline QT_ASCII_CAST_WARN QString &operator=(const char *ch)

    { return (*this = fromAscii(ch)); }

    inline QT_ASCII_CAST_WARN QString &operator=(const QByteArray &a)

    { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); }

    inline QT_ASCII_CAST_WARN QString &operator=(char c)

    { return (*this = QChar::fromAscii(c)); }

    // these are needed, so it compiles with STL support enabled

    inline QT_ASCII_CAST_WARN QString &prepend(const char *s)

    { return prepend(QString::fromAscii(s)); }

    inline QT_ASCII_CAST_WARN QString &prepend(const QByteArray &s)

    { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }

    inline QT_ASCII_CAST_WARN QString &append(const char *s)

    { return append(QString::fromAscii(s)); }

    inline QT_ASCII_CAST_WARN QString &append(const QByteArray &s)

    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }

    inline QT_ASCII_CAST_WARN QString &operator+=(const char *s)

    { return append(QString::fromAscii(s)); }

    inline QT_ASCII_CAST_WARN QString &operator+=(const QByteArray &s)

    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }

    inline QT_ASCII_CAST_WARN QString &operator+=(char c)

    { return append(QChar::fromAscii(c)); }

    inline QT_ASCII_CAST_WARN bool operator==(const char *s) const;

    inline QT_ASCII_CAST_WARN bool operator!=(const char *s) const;

    inline QT_ASCII_CAST_WARN bool operator<(const char *s) const;

    inline QT_ASCII_CAST_WARN bool operator<=(const char *s2) const;

    inline QT_ASCII_CAST_WARN bool operator>(const char *s2) const;

    inline QT_ASCII_CAST_WARN bool operator>=(const char *s2) const;

    inline QT_ASCII_CAST_WARN bool operator==(const QByteArray &s) const;

    inline QT_ASCII_CAST_WARN bool operator!=(const QByteArray &s) const;

    inline QT_ASCII_CAST_WARN bool operator<(const QByteArray &s) const

    { return *this < QString::fromAscii(s.constData(), s.size()); }

    inline QT_ASCII_CAST_WARN bool operator>(const QByteArray &s) const

    { return *this > QString::fromAscii(s.constData(), s.size()); }

    inline QT_ASCII_CAST_WARN bool operator<=(const QByteArray &s) const

    { return *this <= QString::fromAscii(s.constData(), s.size()); }

    inline QT_ASCII_CAST_WARN bool operator>=(const QByteArray &s) const

    { return *this >= QString::fromAscii(s.constData(), s.size()); }

#endif

    typedef QChar *iterator;

    typedef const QChar *const_iterator;

    typedef iterator Iterator;

    typedef const_iterator ConstIterator;

    iterator begin();

    const_iterator begin() const;

    const_iterator constBegin() const;

    iterator end();

    const_iterator end() const;

    const_iterator constEnd() const;

    // STL compatibility

    inline void push_back(QChar c) { append(c); }

    inline void push_back(const QString &s) { append(s); }

    inline void push_front(QChar c) { prepend(c); }

    inline void push_front(const QString &s) { prepend(s); }

#ifndef QT_NO_STL

    static inline QString fromStdString(const std::string &s);

    inline std::string toStdString() const;

# ifdef qdoc

    static inline QString fromStdWString(const std::wstring &s);

    inline std::wstring toStdWString() const;

# else

#  ifndef QT_NO_STL_WCHAR

    static inline QString fromStdWString(const QStdWString &s);

    inline QStdWString toStdWString() const;

#  endif // QT_NO_STL_WCHAR

# endif // qdoc

#endif

    // compatibility

    struct Null { };

    static const Null null;

    inline QString(const Null &): d(&shared_null) { d->ref.ref(); }

    inline QString &operator=(const Null &) { *this = QString(); return *this; }

    inline bool isNull() const { return d == &shared_null; }

#ifdef QT3_SUPPORT

    inline QT3_SUPPORT const char *ascii() const { return ascii_helper(); }

    inline QT3_SUPPORT const char *latin1() const { return latin1_helper(); }

    inline QT3_SUPPORT QByteArray utf8() const { return toUtf8(); }

    inline QT3_SUPPORT QByteArray local8Bit() const{ return toLocal8Bit(); }

    inline QT3_SUPPORT void setLength(int nl) { resize(nl); }

    inline QT3_SUPPORT QString copy() const { return *this; }

    inline QT3_SUPPORT QString &remove(QChar c, bool cs)

    { return remove(c, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline QT3_SUPPORT QString &remove(const QString  &s, bool cs)

    { return remove(s, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline QT3_SUPPORT QString &replace(QChar c, const QString  &after, bool cs)

    { return replace(c, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); }

    inline QT3_SUPPORT QString &replace(const QString &before, const QString &after, bool cs)