whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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>
bb10
Marc Mutz 2015-10-22 15:51:14 +02:00
parent 83038a7acf
commit 00a8be85d1
8 changed files with 1225 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/corelib/tools/qstring.h
View File

@ -73,6 +73,10 @@ Q_FORWARD_DECLARE_CF_TYPE(CFString);
Q_FORWARD_DECLARE_OBJC_CLASS(NSString);
#endif
#ifndef QT_STRINGVIEW_LEVEL
# define QT_STRINGVIEW_LEVEL 1
#endif
QT_BEGIN_NAMESPACE
class QCharRef;
@ -83,6 +87,7 @@ class QString;
class QStringList;
class QTextCodec;
class QStringRef;
class QStringView;
template <typename T> class QVector;
class QLatin1String
@ -875,6 +880,7 @@ private:
friend class QCharRef;
friend class QTextCodec;
friend class QStringRef;
friend class QStringView;
friend class QByteArray;
friend class QCollator;
friend struct QAbstractConcatenable;
@ -1574,6 +1580,10 @@ inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
inline QStringRef::QStringRef(const QString *aString)
:m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}
QT_BEGIN_INCLUDE_NAMESPACE
#include <QtCore/qstringview.h>
QT_END_INCLUDE_NAMESPACE
// QStringRef <> QStringRef
Q_CORE_EXPORT bool operator==(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW;
inline bool operator!=(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW

533
src/corelib/tools/qstringview.cpp Normal file
View File

@ -0,0 +1,533 @@
/****************************************************************************
**
** 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:LGPL$
** 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 https://www.qt.io/terms-conditions. For further
** information use the contact form at https://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 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qstringview.h"
QT_BEGIN_NAMESPACE
/*!
\class QStringView
\inmodule QtCore
\since 5.10
\brief The QStringView class provides a unified view on UTF-16 strings
\reentrant
\ingroup tools
\ingroup string-processing
QStringView provides a read-only subset of the QString API.
A string view explicitly stores a portion of a UTF-16 string it does
not own. It acts as an interface type to all kinds of UTF-16 string,
without the need to construct a QString first.
The UTF-16 string may be represented as an array (or an array-compatible
data-structure such as QString,
std::basic_string, etc.) of \c QChar, \c ushort, \c char16_t (on compilers that
support C++11 Unicode strings) or (on platforms, such as Windows,
where it is a 16-bit type) \c wchar_t.
QStringView is designed as an interface type; its main use-case is
as a function parameter type. When QStringViews are used as automatic
variables or data members, care must be taken to ensure that the referenced
string data (for example, owned by a QString) outlives the QStringView on all code paths,
lest the string view ends up referencing deleted data.
When used as an interface type, QStringView allows a single function to accept
a wide variety of UTF-16 string data sources. One function accepting QStringView
thus replaces three function overloads (taking QString, QStringRef, and
\c{(const QChar*, int)}), while at the same time enabling even more string data
sources to be passed to the function, such as \c{u"Hello World"}, a \c char16_t
string literal.
QStringViews should be passed by value, not by reference-to-const:
\code
void myfun1(QStringView sv); // preferred
void myfun2(const QStringView &sv); // compiles and works, but slower
\endcode
If you want to give your users maximum freedom in what strings they can pass
to your function, accompany the QStringView overload with overloads for
\list
\li \e QChar: this overload can delegate to the QStringView version:
\code
void fun(QChar ch) { fun(QStringView(&ch, 1)); }
\endcode
even though, for technical reasons, QStringView cannot provide a
QChar constructor by itself.
\li \e QString: if you store an unmodified copy of the string and thus would
like to take advantage of QString's implicit sharing.
\li QLatin1String: if you can implement the function without converting the
QLatin1String to UTF-16 first; users expect a function overloaded on
QLatin1String to perform strictly less memory allocations than the
semantically equivalent call of the QStringView version, involving
construction of a QString from the QLatin1String.
\endlist
QStringView can also be used as the return value of a function. If you call a
function returning QStringView, take extra care to not keep the QStringView
around longer than the function promises to keep the referenced string data alive.
If in doubt, obtain a strong reference to the data by calling toString() to convert
the QStringView into a QString.
QStringView is a \e{Literal Type}.
\note We strongly discourage the use of QList<QStringView>,
because QList is a very inefficient container for QStringViews (it would heap-allocate
every element). Use QVector (or std::vector) to hold QStringViews instead.
\sa QString, QStringRef
*/
/*!
\typedef QStringView::value_type
Alias for \c{const QChar}. Provided for compatibility with the STL.
*/
/*!
\typedef QStringView::difference_type
Alias for \c{std::ptrdiff_t}. Provided for compatibility with the STL.
*/
/*!
\typedef QStringView::size_type
Alias for \c{std::ptrdiff_t}. Provided for compatibility with the STL.
Unlike other Qt classes, QStringView uses \c ptrdiff_t as its \c size_type, to allow
accepting data from \c{std::basic_string} without truncation. The Qt API functions,
for example length(), return \c int, while the STL-compatible functions, for example
size(), return \c size_type.
*/
/*!
\typedef QStringView::reference
Alias for \c{value_type &}. Provided for compatibility with the STL.
QStringView does not support mutable references, so this is the same
as const_reference.
*/
/*!
\typedef QStringView::const_reference
Alias for \c{value_type &}. Provided for compatibility with the STL.
*/
/*!
\typedef QStringView::pointer
Alias for \c{value_type *}. Provided for compatibility with the STL.
QStringView does not support mutable pointers, so this is the same
as const_pointer.
*/
/*!
\typedef QStringView::const_pointer
Alias for \c{value_type *}. Provided for compatibility with the STL.
*/
/*!
\typedef QStringView::iterator
This typedef provides an STL-style const iterator for QStringView.
QStringView does not support mutable iterators, so this is the same
as const_iterator.
\sa const_iterator, reverse_iterator
*/
/*!
\typedef QStringView::const_iterator
This typedef provides an STL-style const iterator for QStringView.
\sa iterator, const_reverse_iterator
*/
/*!
\typedef QStringView::reverse_iterator
This typedef provides an STL-style const reverse iterator for QStringView.
QStringView does not support mutable reverse iterators, so this is the
same as const_reverse_iterator.
\sa const_reverse_iterator, iterator
*/
/*!
\typedef QStringView::const_reverse_iterator
This typedef provides an STL-style const reverse iterator for QStringView.
\sa reverse_iterator, const_iterator
*/
/*!
\fn QStringView::QStringView()
Constructs a null string view.
\sa isNull()
*/
/*!
\fn QStringView::QStringView(std::nullptr_t)
Constructs a null string view.
\sa isNull()
*/
/*!
\fn QStringView::QStringView(QString::Null)
\internal
Constructs a null string view.
\sa isNull()
*/
/*!
\fn QStringView::QStringView(const Char *str, size_type len)
Constructs a string view on \a str with length \a len.
The range \c{[str,len)} must remain valid for the lifetime of this string view object.
Passing \c nullptr as \a str is safe if \a len is 0, too, and results in a null string view.
The behavior is undefined if \a len is negative or, when positive, if \a str is \c nullptr.
This constructor only participates in overload resolution if \c Char is a compatible
character type. The compatible character types are: \c QChar, \c ushort, \c char16_t and
(on platforms, such as Windows, where it is a 16-bit type) \c wchar_t.
*/
/*!
\fn QStringView::QStringView(const Char *str)
Constructs a string view on \a str. The length is determined
by scanning for the first \c{char16_t(0)}.
\a str must remain valid for the lifetime of this string view object.
Passing \c nullptr as \a str is safe and results in a null string view.
This constructor only participates in overload resolution if \c Char is a compatible
character type. The compatible character types are: \c QChar, \c ushort, \c char16_t and
(on platforms, such as Windows, where it is a 16-bit type) \c wchar_t.
*/
/*!
\fn QStringView::QStringView(const QString &str)
Constructs a string view on \a str.
\c{str.data()} must remain valid for the lifetime of this string view object.
The string view will be null if and only if \c{str.isNull()}.
*/
/*!
\fn QStringView::QStringView(const QStringRef &str)
Constructs a string view on \a str.
\c{str.data()} must remain valid for the lifetime of this string view object.
The string view will be null if and only if \c{str.isNull()}.
*/
/*!
\fn QStringView::QStringView(const StdBasicString &str)
Constructs a string view on \a str. The length is taken from \c{str.size()}.
\c{str.data()} must remain valid for the lifetime of this string view object.
This constructor only participates in overload resolution if \c StdBasicString is an
instantiation of \c std::basic_string with a compatible character type. The
compatible character types are: \c QChar, \c ushort, \c char16_t and
(on platforms, such as Windows, where it is a 16-bit type) \c wchar_t.
The string view will be empty if and only if \c{str.empty()}. It is unspecified
whether this constructor can result in a null string view (\c{str.data()} would
have to return \c nullptr for this).
\sa isNull(), isEmpty()
*/
/*!
\fn QString QStringView::toString() const
Returns a deep copy of this string view's data as a QString.
The return value will be the null QString if and only if this string view is null.
\warning QStringView can store strings with more than 2\sup{30} characters
while QString cannot. Calling this function on a string view for which size()
returns a value greater than \c{INT_MAX / 2} constitutes undefined behavior.
*/
/*!
\fn const QChar *QStringView::data() const
Returns a const pointer to the first character in the string.
\sa begin(), end()
*/
/*!
\fn QStringView::const_iterator QStringView::begin() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first character in
the string.
This function is provided for STL compatibility.
\sa end(), cbegin(), rbegin(), data()
*/
/*!
\fn QStringView::const_iterator QStringView::cbegin() const
Same as begin().
This function is provided for STL compatibility.
\sa cend(), begin(), crbegin(), data()
*/
/*!
\fn QStringView::const_iterator QStringView::end() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
character after the last character in the list.
This function is provided for STL compatibility.
\sa begin(), cend(), rend()
*/
/*! \fn QStringView::const_iterator QStringView::cend() const
Same as end().
This function is provided for STL compatibility.
\sa cbegin(), end(), crend()
*/
/*!
\fn QStringView::const_reverse_iterator QStringView::rbegin() const
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
character in the string, in reverse order.
This function is provided for STL compatibility.
\sa rend(), crbegin(), begin()
*/
/*!
\fn QStringView::const_reverse_iterator QStringView::crbegin() const
Same as rbegin().
This function is provided for STL compatibility.
\sa crend(), rbegin(), cbegin()
*/
/*!
\fn QStringView::const_reverse_iterator QStringView::rend() const
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to one past
the last character in the string, in reverse order.
This function is provided for STL compatibility.
\sa rbegin(), crend(), end()
*/
/*!
\fn QStringView::const_reverse_iterator QStringView::crend() const
Same as rend().
This function is provided for STL compatibility.
\sa crbegin(), rend(), cend()
*/
/*!
\fn bool QStringView::empty() const
Returns whether this string view is empty - that is, whether \c{size() == 0}.
This function is provided for STL compatibility.
\sa isEmpty(), isNull(), size(), length()
*/
/*!
\fn bool QStringView::isEmpty() const
Returns whether this string view is empty - that is, whether \c{size() == 0}.
This function is provided for compatibility with other Qt containers.
\sa empty(), isNull(), size(), length()
*/
/*!
\fn bool QStringView::isNull() const
Returns whether this string view is null - that is, whether \c{data() == nullptr}.
This functions is provided for compatibility with other Qt containers.
\sa empty(), isEmpty(), size(), length()
*/
/*!
\fn QStringView::size_type QStringView::size() const
Returns the size of this string view, in UTF-16 code points (that is,
surrogate pairs count as two for the purposes of this function, the same
as in QString and QStringRef).
\sa empty(), isEmpty(), isNull(), length()
*/
/*!
\fn int QStringView::length() const
Same as size(), except returns the result as an \c int.
This function is provided for compatibility with other Qt containers.
\warning QStringView can represent strings with more than 2\sup{31} characters.
Calling this function on a string view for which size() returns a value greater
than \c{INT_MAX} constitutes undefined behavior.
\sa empty(), isEmpty(), isNull(), size()
*/
/*!
\fn QChar QStringView::operator[](size_type n) const
Returns the character at position \a n in this string view.
The behavior is undefined if \a n is negative or not less than size().
\sa at(), front(), back()
*/
/*!
\fn QChar QStringView::at(size_type n) const
Returns the character at position \a n in this string view.
The behavior is undefined if \a n is negative or not less than size().
\sa operator[](), front(), back()
*/
/*!
\fn QChar QStringView::front() const
Returns the first character in the string. Same as first().
This function is provided for STL compatibility.
\warning Calling this function on an empty string view constitutes
undefined behavior.
\sa back(), first(), last()
*/
/*!
\fn QChar QStringView::back() const
Returns the last character in the string. Same as last().
This function is provided for STL compatibility.
\warning Calling this function on an empty string view constitutes
undefined behavior.
\sa front(), first(), last()
*/
/*!
\fn QChar QStringView::first() const
Returns the first character in the string. Same as front().
This function is provided for compatibility with other Qt containers.
\warning Calling this function on an empty string view constitutes
undefined behavior.
\sa front(), back(), last()
*/
/*!
\fn QChar QStringView::last() const
Returns the last character in the string. Same as back().
This function is provided for compatibility with other Qt containers.
\warning Calling this function on an empty string view constitutes
undefined behavior.
\sa back(), front(), first()
*/
QT_END_NAMESPACE

226
src/corelib/tools/qstringview.h Normal file
View File

@ -0,0 +1,226 @@
/****************************************************************************
**
** 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:LGPL$
** 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 https://www.qt.io/terms-conditions. For further
** information use the contact form at https://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 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QSTRING_H
# include <QtCore/qstring.h>
#endif
#ifndef QSTRINGVIEW_H
#define QSTRINGVIEW_H
#include <string>
QT_BEGIN_NAMESPACE
#ifndef QT_NO_UNICODE_LITERAL
# ifndef QT_UNICODE_LITERAL
# error "If you change QStringLiteral, please change QStringViewLiteral, too"
# endif
# define QStringViewLiteral(str) QStringView(QT_UNICODE_LITERAL(str), sizeof(str) - 1)
#endif
namespace QtPrivate {
template <typename Char>
struct IsCompatibleCharTypeHelper
: std::integral_constant<bool,
std::is_same<Char, QChar>::value ||
std::is_same<Char, ushort>::value ||
#if !defined(Q_OS_WIN) || defined(Q_COMPILER_UNICODE_STRINGS)
std::is_same<Char, char16_t>::value ||
#endif
(std::is_same<Char, wchar_t>::value && sizeof(wchar_t) == sizeof(QChar))> {};
template <typename Char>
struct IsCompatibleCharType
: IsCompatibleCharTypeHelper<typename std::remove_cv<typename std::remove_reference<Char>::type>::type> {};
template <typename T>
struct IsCompatibleStdBasicStringHelper : std::false_type {};
template <typename Char, typename...Args>
struct IsCompatibleStdBasicStringHelper<std::basic_string<Char, Args...> >
: IsCompatibleCharType<Char> {};
template <typename T>
struct IsCompatibleStdBasicString
: IsCompatibleStdBasicStringHelper<
typename std::remove_cv<typename std::remove_reference<T>::type>::type
> {};
} // namespace QtPrivate
class QStringView
{
#if defined(Q_OS_WIN) && !defined(Q_COMPILER_UNICODE_STRINGS)
typedef wchar_t storage_type;
#else
typedef char16_t storage_type;
#endif
public:
typedef const QChar value_type;
typedef std::ptrdiff_t difference_type;
typedef QIntegerForSizeof<size_t>::Signed size_type;
typedef value_type &reference;
typedef value_type &const_reference;
typedef value_type *pointer;
typedef value_type *const_pointer;
typedef pointer iterator;
typedef const_pointer const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
private:
template <typename Char>
using if_compatible_char = typename std::enable_if<QtPrivate::IsCompatibleCharType<Char>::value, bool>::type;
template <typename T>
using if_compatible_string = typename std::enable_if<QtPrivate::IsCompatibleStdBasicString<T>::value, bool>::type;
template <typename Char>
static Q_DECL_RELAXED_CONSTEXPR size_type lengthHelper(const Char *str) Q_DECL_NOTHROW
{
size_type result = 0;
while (*str++)
++result;
return result;
}
static Q_DECL_RELAXED_CONSTEXPR size_type lengthHelper(const QChar *str) Q_DECL_NOTHROW
{
size_type result = 0;
while (!str++->isNull())
++result;
return result;
}
template <typename Char>
static const storage_type *castHelper(const Char *str) Q_DECL_NOTHROW
{ return reinterpret_cast<const storage_type*>(str); }
static Q_DECL_CONSTEXPR const storage_type *castHelper(const storage_type *str) Q_DECL_NOTHROW
{ return str; }
// prevent
// T t; QStringView sv(t), T \in {QChar, QLatin1String, QByteArray, const char*}
// from compiling as QStringView sv(QString(t)):
QStringView(QChar) = delete;
QStringView(QLatin1String) = delete;
QStringView(const QByteArray &) = delete;
QStringView(const char *) = delete;
#ifdef Q_OS_WIN
// prevent QStringView(Char), Char compatible, from compiling due to:
// https://connect.microsoft.com/VisualStudio/feedback/details/2256407/c-two-user-defined-conversions-incorrectly-accepted-in-implicit-conversion-sequence
template <typename Char, if_compatible_char<Char> = true>
QStringView(Char) = delete;
#endif
public:
Q_DECL_CONSTEXPR QStringView() Q_DECL_NOTHROW
: m_size(0), m_data(nullptr) {}
Q_DECL_CONSTEXPR QStringView(std::nullptr_t) Q_DECL_NOTHROW
: QStringView() {}
#if QT_DEPRECATED_SINCE(5, 9)
Q_DECL_CONSTEXPR QStringView(QString::Null) Q_DECL_NOTHROW
: QStringView() {}
#endif
template <typename Char, if_compatible_char<Char> = true>
Q_DECL_CONSTEXPR QStringView(const Char *str, size_type len)
: m_size((Q_ASSERT(len >= 0), Q_ASSERT(str || !len), len)),
m_data(castHelper(str)) {}
template <typename Char, if_compatible_char<Char> = true>
Q_DECL_CONSTEXPR QStringView(const Char *str)
: QStringView(str, str ? lengthHelper(str) : 0) {}
QStringView(const QString &str) Q_DECL_NOTHROW
: QStringView(str.isNull() ? nullptr : str.data(), size_type(str.size())) {}
QStringView(const QStringRef &str) Q_DECL_NOTHROW
: QStringView(str.isNull() ? nullptr : str.data(), size_type(str.size())) {}
template <typename StdBasicString, if_compatible_string<StdBasicString> = true>
QStringView(const StdBasicString &str) Q_DECL_NOTHROW
: QStringView(str.data(), size_type(str.size())) {}
QString toString() const { return Q_ASSERT(size() == length()), QString(data(), length()); }
Q_DECL_CONSTEXPR size_type size() const Q_DECL_NOTHROW { return m_size; }
const_pointer data() const Q_DECL_NOTHROW { return reinterpret_cast<const_pointer>(m_data); }
Q_DECL_CONSTEXPR const storage_type *utf16() const Q_DECL_NOTHROW { return m_data; }
Q_DECL_CONSTEXPR QChar operator[](size_type n) const
{ return Q_ASSERT(n >= 0), Q_ASSERT(n < size()), QChar(m_data[n]); }
//
// QString API
//
Q_DECL_CONSTEXPR QChar at(size_type n) const { return (*this)[n]; }
//
// STL compatibility API:
//
const_iterator begin() const Q_DECL_NOTHROW { return data(); }
const_iterator end() const Q_DECL_NOTHROW { return data() + size(); }
const_iterator cbegin() const Q_DECL_NOTHROW { return begin(); }
const_iterator cend() const Q_DECL_NOTHROW { return end(); }
const_reverse_iterator rbegin() const Q_DECL_NOTHROW { return const_reverse_iterator(end()); }
const_reverse_iterator rend() const Q_DECL_NOTHROW { return const_reverse_iterator(begin()); }
const_reverse_iterator crbegin() const Q_DECL_NOTHROW { return rbegin(); }
const_reverse_iterator crend() const Q_DECL_NOTHROW { return rend(); }
Q_DECL_CONSTEXPR bool empty() const Q_DECL_NOTHROW { return size() == 0; }
Q_DECL_CONSTEXPR QChar front() const { return Q_ASSERT(!empty()), QChar(m_data[0]); }
Q_DECL_CONSTEXPR QChar back() const { return Q_ASSERT(!empty()), QChar(m_data[m_size - 1]); }
//
// Qt compatibility API:
//
Q_DECL_CONSTEXPR bool isNull() const Q_DECL_NOTHROW { return !m_data; }
Q_DECL_CONSTEXPR bool isEmpty() const Q_DECL_NOTHROW { return empty(); }
Q_DECL_CONSTEXPR int length() const /* not nothrow! */
{ return Q_ASSERT(int(size()) == size()), int(size()); }
Q_DECL_CONSTEXPR QChar first() const { return front(); }
Q_DECL_CONSTEXPR QChar last() const { return back(); }
private:
size_type m_size;
const storage_type *m_data;
};
Q_DECLARE_TYPEINFO(QStringView, Q_MOVABLE_TYPE);
QT_END_NAMESPACE
#endif /* QSTRINGVIEW_H */

2
src/corelib/tools/tools.pri
View File

@ -62,6 +62,7 @@ HEADERS += \
tools/qstringiterator_p.h \
tools/qstringlist.h \
tools/qstringmatcher.h \
tools/qstringview.h \
tools/qtextboundaryfinder.h \
tools/qtimeline.h \
tools/qtools_p.h \
@ -106,6 +107,7 @@ SOURCES += \
tools/qstring.cpp \
tools/qstringbuilder.cpp \
tools/qstringlist.cpp \
tools/qstringview.cpp \
tools/qtextboundaryfinder.cpp \
tools/qtimeline.cpp \
tools/qunicodetools.cpp \

1
tests/auto/corelib/tools/qstringview/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
tst_qstringview

6
tests/auto/corelib/tools/qstringview/qstringview.pro Normal file
View File

@ -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

446
tests/auto/corelib/tools/qstringview/tst_qstringview.cpp Normal file
View File

@ -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"

1
tests/auto/corelib/tools/tools.pro
View File

@ -56,6 +56,7 @@ SUBDIRS=\
qstringlist \
qstringmatcher \
qstringref \
qstringview \
qtextboundaryfinder \
qtime \
qtimezone \