QString: add append, op+=, prepend, insert taking QStringView

[ChangeLog][QtCore][QString] Now supports appending, prepending
and inserting QStringViews.

Change-Id: I7538c050c67590f27d91443eda0b94a4b80b62f2
Reviewed-by: Anton Kudryavtsev <antkudr@mail.ru>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

src/corelib/text/qstring.cpp

@@ -2500,6 +2500,19 @@ QString &QString::operator=(QChar ch)
 */
 
 
+/*!
+    \fn QString& QString::insert(int position, QStringView str)
+    \since 6.0
+    \overload insert()
+
+    Inserts the string view \a str at the given index \a position and
+    returns a reference to this string.
+
+    If the given \a position is greater than size(), the array is
+    first extended using resize().
+*/
+
+
 /*!
     \fn QString& QString::insert(int position, const char *str)
     \since 5.5
@@ -2765,6 +2778,14 @@ QString &QString::append(QChar ch)
     returns a reference to this string.
 */
 
+/*! \fn QString &QString::prepend(QStringView str)
+    \since 6.0
+    \overload prepend()
+
+    Prepends the string view \a str to the beginning of this string and
+    returns a reference to this string.
+*/
+
 /*! \fn QString &QString::prepend(const QByteArray &ba)
 
     \overload prepend()
@@ -5914,6 +5935,13 @@ QString& QString::fill(QChar ch, int size)
     Appends the string section referenced by \a str to this string.
 */
 
+/*! \fn QString &QString::operator+=(QStringView str)
+    \since 6.0
+    \overload operator+=()
+
+    Appends the string view \a str to this string.
+*/
+
 /*! \fn QString &QString::operator+=(char ch)
 
     \overload operator+=()
@@ -11037,6 +11065,13 @@ QStringRef QStringRef::appendTo(QString *string) const
     lists of strings to the user.
 */
 
+/*!
+    \fn QString &QString::append(QStringView str)
+    \since 6.0
+
+    Appends the given string view \a str to this string and returns the result.
+*/
+
 /*!
     \fn QString &QString::append(const QStringRef &reference)
     \since 4.4

src/corelib/text/qstring.h

@@ -537,18 +537,29 @@ public:
 
     QString &insert(int i, QChar c);
     QString &insert(int i, const QChar *uc, int len);
+#if QT_STRINGVIEW_LEVEL < 2
     inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
     inline QString &insert(int i, const QStringRef &s);
+#endif
+    inline QString &insert(int i, QStringView v) { return insert(i, v.data(), v.length()); }
     QString &insert(int i, QLatin1String s);
+
     QString &append(QChar c);
     QString &append(const QChar *uc, int len);
+#if QT_STRINGVIEW_LEVEL < 2
     QString &append(const QString &s);
     QString &append(const QStringRef &s);
+#endif
+    inline QString &append(QStringView v) { return append(v.data(), v.length()); }
     QString &append(QLatin1String s);
+
     inline QString &prepend(QChar c) { return insert(0, c); }
     inline QString &prepend(const QChar *uc, int len) { return insert(0, uc, len); }
+#if QT_STRINGVIEW_LEVEL < 2
     inline QString &prepend(const QString &s) { return insert(0, s); }
     inline QString &prepend(const QStringRef &s) { return insert(0, s); }
+#endif
+    inline QString &prepend(QStringView v) { return prepend(v.data(), v.length()); }
     inline QString &prepend(QLatin1String s) { return insert(0, s); }
 
     inline QString &operator+=(QChar c) {
@@ -560,8 +571,11 @@ public:
     }
 
     inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
+#if QT_STRINGVIEW_LEVEL < 2
     inline QString &operator+=(const QString &s) { return append(s); }
     inline QString &operator+=(const QStringRef &s) { return append(s); }
+#endif
+    inline QString &operator+=(QStringView v) { return append(v); }
     inline QString &operator+=(QLatin1String s) { return append(s); }
 
     QString &remove(int i, int len);

tests/auto/corelib/text/qstring/tst_qstring.cpp

@@ -137,6 +137,23 @@ public:
     { (s.*mf)(a1, ref()); }
 };
 
+template <>
+class Arg<QStringView> : ArgBase
+{
+    QStringView view() const
+    { return this->pinned.isNull() ? QStringView() : QStringView(this->pinned) ; }
+public:
+    explicit Arg(const char *str) : ArgBase(str) {}
+
+    template <typename MemFun>
+    void apply0(QString &s, MemFun mf) const
+    { (s.*mf)(view()); }
+
+    template <typename MemFun, typename A1>
+    void apply1(QString &s, MemFun mf, A1 a1) const
+    { (s.*mf)(a1, view()); }
+};
+
 template <>
 class Arg<QPair<const QChar *, int> > : ArgBase
 {
@@ -379,6 +396,8 @@ private slots:
     void prepend_qstring_data()       { prepend_data(true); }
     void prepend_qstringref()         { prepend_impl<QStringRef>(); }
     void prepend_qstringref_data()    { prepend_data(true); }
+    void prepend_qstringview()        { prepend_impl<QStringView, QString &(QString::*)(QStringView)>(); }
+    void prepend_qstringview_data()   { prepend_data(true); }
     void prepend_qlatin1string()      { prepend_impl<QLatin1String, QString &(QString::*)(QLatin1String)>(); }
     void prepend_qlatin1string_data() { prepend_data(true); }
     void prepend_qcharstar_int()      { prepend_impl<QPair<const QChar *, int>, QString &(QString::*)(const QChar *, int)>(); }
@@ -398,6 +417,8 @@ private slots:
     void append_qstring_data()       { append_data(); }
     void append_qstringref()         { append_impl<QStringRef>(); }
     void append_qstringref_data()    { append_data(); }
+    void append_qstringview()        { append_impl<QStringView,  QString &(QString::*)(QStringView)>(); }
+    void append_qstringview_data()   { append_data(true); }
     void append_qlatin1string()      { append_impl<QLatin1String, QString &(QString::*)(QLatin1String)>(); }
     void append_qlatin1string_data() { append_data(); }
     void append_qcharstar_int()      { append_impl<QPair<const QChar *, int>, QString&(QString::*)(const QChar *, int)>(); }
@@ -418,6 +439,8 @@ private slots:
     void operator_pluseq_qstring_data()       { operator_pluseq_data(); }
     void operator_pluseq_qstringref()         { operator_pluseq_impl<QStringRef>(); }
     void operator_pluseq_qstringref_data()    { operator_pluseq_data(); }
+    void operator_pluseq_qstringview()        { operator_pluseq_impl<QStringView, QString &(QString::*)(QStringView)>(); }
+    void operator_pluseq_qstringview_data()   { operator_pluseq_data(true); }
     void operator_pluseq_qlatin1string()      { operator_pluseq_impl<QLatin1String, QString &(QString::*)(QLatin1String)>(); }
     void operator_pluseq_qlatin1string_data() { operator_pluseq_data(); }
     void operator_pluseq_qchar()              { operator_pluseq_impl<QChar, QString &(QString::*)(QChar)>(); }
@@ -440,6 +463,8 @@ private slots:
     void insert_qstring_data()       { insert_data(true); }
     void insert_qstringref()         { insert_impl<QStringRef>(); }
     void insert_qstringref_data()    { insert_data(true); }
+    void insert_qstringview()        { insert_impl<QStringView, QString &(QString::*)(int, QStringView)>(); }
+    void insert_qstringview_data()   { insert_data(true); }
     void insert_qlatin1string()      { insert_impl<QLatin1String, QString &(QString::*)(int, QLatin1String)>(); }
     void insert_qlatin1string_data() { insert_data(true); }
     void insert_qcharstar_int()      { insert_impl<QPair<const QChar *, int>, QString &(QString::*)(int, const QChar*, int) >(); }