Long live QStringView!

QStringView is a simple container for (const QChar*, int) and (const
char16_t*, size_t). It acts as a replacement interface type for const
QString and const QStringRef, and enables passing all kinds of
string-like types to functions otherwise expecting const QString& -
without the need to convert to QString first.

The use of this new class is guarded by a macro that enables three
levels of QStringView support:

 1. offer QStringView, overload some functions taking QString with
    QStringView

 2. like 1, but remove all overloads of functions taking QStringRef,
    leaving only the function taking QStringView.  Do this only where
    QStringRef overloads tradionally existed.

 3. like 2, but replace functions taking QString, too.

This is done in order to measure the impact of QStringView on code
size and execution speed, and to help guide the decision of which
level to choose for Qt 6.

This first patch adds QStringView with most of its planned
constructors, but not much more than iterators and isNull()/isEmpty().

Further patches will add support for QStringView to QStringBuilder,
add QStringView overloads of functions taking QString, and add the
complete API of const QString to QStringView.

[ChangeLog][QtCore][QStringView] New class, superseding const QString
and QStringRef as function parameters, accepting a wide variety of
UTF-16 string data sources, e.g. u"string", std::u16string{,_view},
and, on Windows, L"string", std::wstring{,_view} without converting to
QString first.

Change-Id: Iac273e46b2c61ec2c31b3dacebb29500599d6898
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>

4 files changed, 454 insertions, 0 deletions

diff --git a/tests/auto/corelib/tools/qstringview/.gitignore b/tests/auto/corelib/tools/qstringview/.gitignore
new file mode 100644
index 0000000000..5f757d448a
--- /dev/null
+++ b/tests/auto/corelib/tools/qstringview/.gitignore
@@ -0,0 +1 @@
+tst_qstringview
diff --git a/tests/auto/corelib/tools/qstringview/qstringview.pro b/tests/auto/corelib/tools/qstringview/qstringview.pro
new file mode 100644
index 0000000000..e0e9973c91
--- /dev/null
+++ b/tests/auto/corelib/tools/qstringview/qstringview.pro
@@ -0,0 +1,6 @@
+CONFIG += testcase
+TARGET = tst_qstringview
+QT = core testlib
+contains(QT_CONFIG, c++14):CONFIG *= c++14
+contains(QT_CONFIG, c++1z):CONFIG *= c++1z
+SOURCES += tst_qstringview.cpp
diff --git a/tests/auto/corelib/tools/qstringview/tst_qstringview.cpp b/tests/auto/corelib/tools/qstringview/tst_qstringview.cpp
new file mode 100644
index 0000000000..2e671040dc
--- /dev/null
+++ b/tests/auto/corelib/tools/qstringview/tst_qstringview.cpp
@@ -0,0 +1,446 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** 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 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QStringView>
+#include <QString>
+#include <QChar>
+#include <QStringRef>
+
+#include <QTest>
+
+#include <string>
+
+template <typename T>
+using CanConvert = std::is_convertible<T, QStringView>;
+
+//
+// QChar
+//
+
+Q_STATIC_ASSERT(CanConvert<      QString >::value);
+Q_STATIC_ASSERT(CanConvert<const QString >::value);
+Q_STATIC_ASSERT(CanConvert<      QString&>::value);
+Q_STATIC_ASSERT(CanConvert<const QString&>::value);
+
+Q_STATIC_ASSERT(CanConvert<      QStringRef >::value);
+Q_STATIC_ASSERT(CanConvert<const QStringRef >::value);
+Q_STATIC_ASSERT(CanConvert<      QStringRef&>::value);
+Q_STATIC_ASSERT(CanConvert<const QStringRef&>::value);
+
+
+//
+// ushort
+//
+
+Q_STATIC_ASSERT(CanConvert<      ushort*>::value);
+Q_STATIC_ASSERT(CanConvert<const ushort*>::value);
+
+
+//
+// char16_t
+//
+
+#if !defined(Q_OS_WIN) || defined(Q_COMPILER_UNICODE_STRINGS)
+
+Q_STATIC_ASSERT(CanConvert<      char16_t*>::value);
+Q_STATIC_ASSERT(CanConvert<const char16_t*>::value);
+
+#endif
+
+#ifdef Q_COMPILER_UNICODE_STRINGS
+
+Q_STATIC_ASSERT(CanConvert<      std::u16string >::value);
+Q_STATIC_ASSERT(CanConvert<const std::u16string >::value);
+Q_STATIC_ASSERT(CanConvert<      std::u16string&>::value);
+Q_STATIC_ASSERT(CanConvert<const std::u16string&>::value);
+
+#endif
+
+
+//
+// wchar_t
+//
+
+Q_CONSTEXPR bool CanConvertFromWCharT =
+#ifdef Q_OS_WIN
+        true
+#else
+        false
+#endif
+        ;
+
+Q_STATIC_ASSERT(CanConvert<      wchar_t*>::value == CanConvertFromWCharT);
+Q_STATIC_ASSERT(CanConvert<const wchar_t*>::value == CanConvertFromWCharT);
+
+Q_STATIC_ASSERT(CanConvert<      std::wstring >::value == CanConvertFromWCharT);
+Q_STATIC_ASSERT(CanConvert<const std::wstring >::value == CanConvertFromWCharT);
+Q_STATIC_ASSERT(CanConvert<      std::wstring&>::value == CanConvertFromWCharT);
+Q_STATIC_ASSERT(CanConvert<const std::wstring&>::value == CanConvertFromWCharT);
+
+
+class tst_QStringView : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void constExpr() const;
+    void basics() const;
+    void at() const;
+
+    void fromQString() const;
+    void fromQStringRef() const;
+
+    void fromQCharStar() const
+    {
+        const QChar str[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', 0 };
+        fromLiteral(str);
+    }
+
+    void fromUShortStar() const
+    {
+        const ushort str[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', 0 };
+        fromLiteral(str);
+    }
+
+    void fromChar16TStar() const
+    {
+#if !defined(Q_OS_WIN) || defined(Q_COMPILER_UNICODE_STRINGS)
+        fromLiteral(u"Hello, World!");
+#else
+        QSKIP("This test requires C++11 char16_t support enabled in the compiler");
+#endif
+    }
+
+    void fromWCharTStar() const
+    {
+#ifdef Q_OS_WIN
+        fromLiteral(L"Hello, World!");
+#else
+        QSKIP("This is a Windows-only test");
+#endif
+    }
+
+    // std::basic_string
+    void fromStdStringWCharT() const
+    {
+#ifdef Q_OS_WIN
+        fromStdString<wchar_t>();
+#else
+        QSKIP("This is a Windows-only test");
+#endif
+    }
+    void fromStdStringChar16T() const
+    {
+#ifdef Q_COMPILER_UNICODE_STRINGS
+        fromStdString<char16_t>();
+#else
+        QSKIP("This test requires C++11 char16_t support enabled in compiler & stdlib");
+#endif
+    }
+
+private:
+    template <typename String>
+    void conversion_tests(String arg) const;
+    template <typename Char>
+    void fromLiteral(const Char *arg) const;
+    template <typename Char, typename Container>
+    void fromContainer() const;
+    template <typename Char>
+    void fromStdString() const { fromContainer<Char, std::basic_string<Char> >(); }
+};
+
+void tst_QStringView::constExpr() const
+{
+    // compile-time checks
+#ifdef Q_COMPILER_CONSTEXPR
+    {
+        constexpr QStringView sv;
+        Q_STATIC_ASSERT(sv.size() == 0);
+        Q_STATIC_ASSERT(sv.isNull());
+        Q_STATIC_ASSERT(sv.empty());
+        Q_STATIC_ASSERT(sv.isEmpty());
+        Q_STATIC_ASSERT(sv.utf16() == nullptr);
+    }
+    {
+        constexpr QStringView sv = QStringViewLiteral("");
+        Q_STATIC_ASSERT(sv.size() == 0);
+        Q_STATIC_ASSERT(!sv.isNull());
+        Q_STATIC_ASSERT(sv.empty());
+        Q_STATIC_ASSERT(sv.isEmpty());
+        Q_STATIC_ASSERT(sv.utf16() != nullptr);
+    }
+    {
+        constexpr QStringView sv = QStringViewLiteral("Hello");
+        Q_STATIC_ASSERT(sv.size() == 5);
+        Q_STATIC_ASSERT(!sv.empty());
+        Q_STATIC_ASSERT(!sv.isEmpty());
+        Q_STATIC_ASSERT(!sv.isNull());
+        Q_STATIC_ASSERT(*sv.utf16() == 'H');
+        Q_STATIC_ASSERT(sv[0]      == QLatin1Char('H'));
+        Q_STATIC_ASSERT(sv.at(0)   == QLatin1Char('H'));
+        Q_STATIC_ASSERT(sv.front() == QLatin1Char('H'));
+        Q_STATIC_ASSERT(sv.first() == QLatin1Char('H'));
+        Q_STATIC_ASSERT(sv[4]      == QLatin1Char('o'));
+        Q_STATIC_ASSERT(sv.at(4)   == QLatin1Char('o'));
+        Q_STATIC_ASSERT(sv.back()  == QLatin1Char('o'));
+        Q_STATIC_ASSERT(sv.last()  == QLatin1Char('o'));
+    }
+#endif
+}
+
+void tst_QStringView::basics() const
+{
+    QStringView sv1;
+
+    // a default-constructed QStringView is null:
+    QVERIFY(sv1.isNull());
+    // which implies it's empty();
+    QVERIFY(sv1.isEmpty());
+}
+
+void tst_QStringView::at() const
+{
+    QString hello("Hello");
+    QStringView sv(hello);
+    QCOMPARE(sv.at(0), QChar('H')); QCOMPARE(sv[0], QChar('H'));
+    QCOMPARE(sv.at(1), QChar('e')); QCOMPARE(sv[1], QChar('e'));
+    QCOMPARE(sv.at(2), QChar('l')); QCOMPARE(sv[2], QChar('l'));
+    QCOMPARE(sv.at(3), QChar('l')); QCOMPARE(sv[3], QChar('l'));
+    QCOMPARE(sv.at(4), QChar('o')); QCOMPARE(sv[4], QChar('o'));
+}
+
+void tst_QStringView::fromQString() const
+{
+    QString null;
+    QString empty = "";
+
+    QVERIFY( QStringView(null).isNull());
+    QVERIFY( QStringView(null).isEmpty());
+    QVERIFY( QStringView(empty).isEmpty());
+    QVERIFY(!QStringView(empty).isNull());
+
+    conversion_tests(QString("Hello World!"));
+}
+
+void tst_QStringView::fromQStringRef() const
+{
+    QStringRef null;
+    QString emptyS = "";
+    QStringRef empty(&emptyS);
+
+    QVERIFY( QStringView(null).isNull());
+    QVERIFY( QStringView(null).isEmpty());
+    QVERIFY( QStringView(empty).isEmpty());
+    QVERIFY(!QStringView(empty).isNull());
+
+    conversion_tests(QString("Hello World!").midRef(6));
+}
+
+template <typename Char>
+void tst_QStringView::fromLiteral(const Char *arg) const
+{
+    const Char *null = nullptr;
+    const Char empty[] = { 0 };
+
+    QCOMPARE(QStringView(null).size(), QStringView::size_type(0));
+    QCOMPARE(QStringView(null).data(), nullptr);
+    QCOMPARE(QStringView(empty).size(), QStringView::size_type(0));
+    QCOMPARE(static_cast<const void*>(QStringView(empty).data()),
+             static_cast<const void*>(empty));
+
+    QVERIFY( QStringView(null).isNull());
+    QVERIFY( QStringView(null).isEmpty());
+    QVERIFY( QStringView(empty).isEmpty());
+    QVERIFY(!QStringView(empty).isNull());
+
+    conversion_tests(arg);
+}
+
+template <typename Char, typename Container>
+void tst_QStringView::fromContainer() const
+{
+    const QString s = "Hello World!";
+
+    Container c;
+    // unspecified whether empty containers make null QStringViews
+    QVERIFY(QStringView(c).isEmpty());
+
+    QCOMPARE(sizeof(Char), sizeof(QChar));
+
+    const auto *data = reinterpret_cast<const Char *>(s.utf16());
+    std::copy(data, data + s.size(), std::back_inserter(c));
+    conversion_tests(std::move(c));
+}
+
+namespace help {
+template <typename T>
+size_t size(const T &t) { return size_t(t.size()); }
+template <typename T>
+size_t size(const T *t)
+{
+    size_t result = 0;
+    if (t) {
+        while (*t++)
+            ++result;
+    }
+    return result;
+}
+size_t size(const QChar *t)
+{
+    size_t result = 0;
+    if (t) {
+        while (!t++->isNull())
+            ++result;
+    }
+    return result;
+}
+
+template <typename T>
+typename T::const_iterator cbegin(const T &t) { return t.cbegin(); }
+template <typename T>
+const T *                  cbegin(const T *t) { return t; }
+
+template <typename T>
+typename T::const_iterator cend(const T &t) { return t.cend(); }
+template <typename T>
+const T *                  cend(const T *t) { return t + size(t); }
+
+template <typename T>
+typename T::const_reverse_iterator crbegin(const T &t) { return t.crbegin(); }
+template <typename T>
+std::reverse_iterator<const T*>    crbegin(const T *t) { return std::reverse_iterator<const T*>(cend(t)); }
+
+template <typename T>
+typename T::const_reverse_iterator crend(const T &t) { return t.crend(); }
+template <typename T>
+std::reverse_iterator<const T*>    crend(const T *t) { return std::reverse_iterator<const T*>(cbegin(t)); }
+
+} // namespace help
+
+template <typename String>
+void tst_QStringView::conversion_tests(String string) const
+{
+    // copy-construct:
+    {
+        QStringView sv = string;
+
+        QCOMPARE(help::size(sv), help::size(string));
+
+        // check iterators:
+
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv.cbegin(), sv.size())));
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv.begin(), sv.size())));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv.crbegin()));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv.rbegin()));
+    }
+
+    QStringView sv;
+
+    // copy-assign:
+    {
+        sv = string;
+
+        QCOMPARE(help::size(sv), help::size(string));
+
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv.cbegin(), sv.size())));
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv.begin(), sv.size())));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv.crbegin()));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv.rbegin()));
+    }
+
+    // copy-construct from rvalue (QStringView never assumes ownership):
+    {
+        QStringView sv2 = std::move(string);
+
+        QCOMPARE(help::size(sv2), help::size(string));
+
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.cbegin(), sv2.size())));
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.begin(), sv2.size())));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv2.crbegin()));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv2.rbegin()));
+
+        QCOMPARE(help::size(sv2), help::size(sv));
+
+        QVERIFY(std::equal(help::cbegin(sv), help::cend(sv),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.cbegin(), sv2.size())));
+        QVERIFY(std::equal(help::cbegin(sv), help::cend(sv),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.begin(), sv2.size())));
+        QVERIFY(std::equal(help::crbegin(sv), help::crend(sv),
+                           sv2.crbegin()));
+        QVERIFY(std::equal(help::crbegin(sv), help::crend(sv),
+                           sv2.rbegin()));
+    }
+
+    // copy-assign from rvalue (QStringView never assumes ownership):
+    {
+        QStringView sv2;
+        sv2 = std::move(string);
+
+        QCOMPARE(help::size(sv2), help::size(string));
+
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.cbegin(), sv2.size())));
+        QVERIFY(std::equal(help::cbegin(string), help::cend(string),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.begin(), sv2.size())));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv2.crbegin()));
+        QVERIFY(std::equal(help::crbegin(string), help::crend(string),
+                           sv2.rbegin()));
+
+        QCOMPARE(help::size(sv2), help::size(sv));
+
+        QVERIFY(std::equal(help::cbegin(sv), help::cend(sv),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.cbegin(), sv2.size())));
+        QVERIFY(std::equal(help::cbegin(sv), help::cend(sv),
+                           QT_MAKE_CHECKED_ARRAY_ITERATOR(sv2.begin(), sv2.size())));
+        QVERIFY(std::equal(help::crbegin(sv), help::crend(sv),
+                           sv2.crbegin()));
+        QVERIFY(std::equal(help::crbegin(sv), help::crend(sv),
+                           sv2.rbegin()));
+    }
+}
+
+QTEST_APPLESS_MAIN(tst_QStringView)
+#include "tst_qstringview.moc"
diff --git a/tests/auto/corelib/tools/tools.pro b/tests/auto/corelib/tools/tools.pro
index e45771a704..e16648c15f 100644
--- a/tests/auto/corelib/tools/tools.pro
+++ b/tests/auto/corelib/tools/tools.pro
@@ -56,6 +56,7 @@ SUBDIRS=\
     qstringlist \
     qstringmatcher \
     qstringref \
+    qstringview \
     qtextboundaryfinder \
     qtime \
     qtimezone \