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

De-inline Qt::SplitBehavior splitters of QString and QStringRef 

Convert the QString::SplitBehavior variants to call them, rather than
the other way round and convert the internal infrastructure to use
Qt::SplitBehavior, ready to deprecate the QString::SplitBehavior
versions without generating intenal warnings.

Task-number: QTBUG-81853
Change-Id: Ia6b78881c3d0e30a7bbd4dfd00cc15a407f448a2
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
bb10
Edward Welbourne 2020-02-26 16:47:31 +01:00
parent 305ddbeb5b
commit b47cf3fe2d
4 changed files with 143 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
src/corelib/text/qstring.cpp
View File

@ -1,6 +1,6 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2020 The Qt Company Ltd.
** Copyright (C) 2018 Intel Corporation.
** Copyright (C) 2019 Mail.ru Group.
** Contact: https://www.qt.io/licensing/
@ -7725,23 +7725,28 @@ QString QString::number(double n, char f, int prec)
namespace {
template<class ResultList, class StringSource>
static ResultList splitString(const StringSource &source, const QChar *sep,
QString::SplitBehavior behavior, Qt::CaseSensitivity cs, const int separatorSize)
Qt::SplitBehavior behavior, Qt::CaseSensitivity cs, const int separatorSize)
{
ResultList list;
typename StringSource::size_type start = 0;
typename StringSource::size_type end;
typename StringSource::size_type extra = 0;
while ((end = QtPrivate::findString(QStringView(source.constData(), source.size()), start + extra, QStringView(sep, separatorSize), cs)) != -1) {
if (start != end || behavior == QString::KeepEmptyParts)
if (start != end || behavior == Qt::KeepEmptyParts)
list.append(source.mid(start, end - start));
start = end + separatorSize;
extra = (separatorSize == 0 ? 1 : 0);
}
if (start != source.size() || behavior == QString::KeepEmptyParts)
if (start != source.size() || behavior == Qt::KeepEmptyParts)
list.append(source.mid(start, -1));
return list;
}
Qt::SplitBehavior mapSplitBehavior(QString::SplitBehavior sb)
{
return sb & QString::SkipEmptyParts ? Qt::SkipEmptyParts : Qt::KeepEmptyParts;
}
} // namespace
/*!
@ -7771,10 +7776,20 @@ static ResultList splitString(const StringSource &source, const QChar *sep,
\snippet qstring/main.cpp 62-slashes
\sa QStringList::join(), section()
\since 5.14
*/
QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QStringList>(*this, sep.constData(), behavior, cs, sep.size());
}
/*!
\overload
*/
QStringList QString::split(const QString &sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QStringList>(*this, sep.constData(), behavior, cs, sep.size());
return split(sep, mapSplitBehavior(behavior), cs);
}
/*!
@ -7787,19 +7802,50 @@ QStringList QString::split(const QString &sep, SplitBehavior behavior, Qt::CaseS
\note All references are valid as long this string is alive. Destroying this
string will cause all references to be dangling pointers.
\since 5.4
\since 5.14
\sa QStringRef split()
*/
QVector<QStringRef> QString::splitRef(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef>>(QStringRef(this), sep.constData(), behavior,
cs, sep.size());
}
/*!
\overload
\since 5.4
*/
QVector<QStringRef> QString::splitRef(const QString &sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef> >(QStringRef(this), sep.constData(), behavior, cs, sep.size());
return splitRef(sep, mapSplitBehavior(behavior), cs);
}
/*!
\overload
\since 5.14
*/
QStringList QString::split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QStringList>(*this, &sep, behavior, cs, 1);
}
/*!
\overload
*/
QStringList QString::split(QChar sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QStringList>(*this, &sep, behavior, cs, 1);
return split(sep, mapSplitBehavior(behavior), cs);
}
/*!
\overload
\since 5.14
*/
QVector<QStringRef> QString::splitRef(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef> >(QStringRef(this), &sep, behavior, cs, 1);
}
/*!
@ -7808,7 +7854,7 @@ QStringList QString::split(QChar sep, SplitBehavior behavior, Qt::CaseSensitivit
*/
QVector<QStringRef> QString::splitRef(QChar sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef> >(QStringRef(this), &sep, behavior, cs, 1);
return splitRef(sep, mapSplitBehavior(behavior), cs);
}
/*!
@ -7821,9 +7867,9 @@ QVector<QStringRef> QString::splitRef(QChar sep, SplitBehavior behavior, Qt::Cas
\note All references are valid as long this string is alive. Destroying this
string will cause all references to be dangling pointers.
\since 5.4
\since 5.14
*/
QVector<QStringRef> QStringRef::split(const QString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const
QVector<QStringRef> QStringRef::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef> >(*this, sep.constData(), behavior, cs, sep.size());
}
@ -7832,15 +7878,33 @@ QVector<QStringRef> QStringRef::split(const QString &sep, QString::SplitBehavior
\overload
\since 5.4
*/
QVector<QStringRef> QStringRef::split(QChar sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const
QVector<QStringRef> QStringRef::split(const QString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return split(sep, mapSplitBehavior(behavior), cs);
}
/*!
\overload
\since 5.14
*/
QVector<QStringRef> QStringRef::split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return splitString<QVector<QStringRef> >(*this, &sep, behavior, cs, 1);
}
/*!
\overload
\since 5.4
*/
QVector<QStringRef> QStringRef::split(QChar sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
return split(sep, mapSplitBehavior(behavior), cs);
}
#ifndef QT_NO_REGEXP
namespace {
template<class ResultList, typename MidMethod>
static ResultList splitString(const QString &source, MidMethod mid, const QRegExp &rx, QString::SplitBehavior behavior)
static ResultList splitString(const QString &source, MidMethod mid, const QRegExp &rx, Qt::SplitBehavior behavior)
{
QRegExp rx2(rx);
ResultList list;
@ -7849,12 +7913,12 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegEx
int end;
while ((end = rx2.indexIn(source, start + extra)) != -1) {
int matchedLen = rx2.matchedLength();
if (start != end || behavior == QString::KeepEmptyParts)
if (start != end || behavior == Qt::KeepEmptyParts)
list.append((source.*mid)(start, end - start));
start = end + matchedLen;
extra = (matchedLen == 0) ? 1 : 0;
}
if (start != source.size() || behavior == QString::KeepEmptyParts)
if (start != source.size() || behavior == Qt::KeepEmptyParts)
list.append((source.*mid)(start, -1));
return list;
}
@ -7862,6 +7926,7 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegEx
/*!
\overload
\since 5.14
Splits the string into substrings wherever the regular expression
\a rx matches, and returns the list of those strings. If \a rx
@ -7886,14 +7951,22 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegEx
\sa QStringList::join(), section()
*/
QStringList QString::split(const QRegExp &rx, SplitBehavior behavior) const
QStringList QString::split(const QRegExp &rx, Qt::SplitBehavior behavior) const
{
return splitString<QStringList>(*this, &QString::mid, rx, behavior);
}
/*!
\overload
\since 5.4
*/
QStringList QString::split(const QRegExp &rx, SplitBehavior behavior) const
{
return split(rx, mapSplitBehavior(behavior));
}
/*!
\overload
\since 5.14
Splits the string into substring references wherever the regular expression
\a rx matches, and returns the list of those strings. If \a rx
@ -7905,17 +7978,26 @@ QStringList QString::split(const QRegExp &rx, SplitBehavior behavior) const
\sa QStringRef split()
*/
QVector<QStringRef> QString::splitRef(const QRegExp &rx, SplitBehavior behavior) const
QVector<QStringRef> QString::splitRef(const QRegExp &rx, Qt::SplitBehavior behavior) const
{
return splitString<QVector<QStringRef> >(*this, &QString::midRef, rx, behavior);
}
#endif
/*!
\overload
\since 5.4
*/
QVector<QStringRef> QString::splitRef(const QRegExp &rx, SplitBehavior behavior) const
{
return splitRef(rx, mapSplitBehavior(behavior));
}
#endif // QT_NO_REGEXP
#if QT_CONFIG(regularexpression)
namespace {
template<class ResultList, typename MidMethod>
static ResultList splitString(const QString &source, MidMethod mid, const QRegularExpression &re,
QString::SplitBehavior behavior)
Qt::SplitBehavior behavior)
{
ResultList list;
if (!re.isValid()) {
@ -7929,12 +8011,12 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegul
while (iterator.hasNext()) {
QRegularExpressionMatch match = iterator.next();
end = match.capturedStart();
if (start != end || behavior == QString::KeepEmptyParts)
if (start != end || behavior == Qt::KeepEmptyParts)
list.append((source.*mid)(start, end - start));
start = match.capturedEnd();
}
if (start != source.size() || behavior == QString::KeepEmptyParts)
if (start != source.size() || behavior == Qt::KeepEmptyParts)
list.append((source.*mid)(start, -1));
return list;
@ -7943,7 +8025,7 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegul
/*!
\overload
\since 5.0
\since 5.14
Splits the string into substrings wherever the regular expression
\a re matches, and returns the list of those strings. If \a re
@ -7968,14 +8050,23 @@ static ResultList splitString(const QString &source, MidMethod mid, const QRegul
\sa QStringList::join(), section()
*/
QStringList QString::split(const QRegularExpression &re, SplitBehavior behavior) const
QStringList QString::split(const QRegularExpression &re, Qt::SplitBehavior behavior) const
{
return splitString<QStringList>(*this, &QString::mid, re, behavior);
}
/*!
\overload
\since 5.4
\since 5.0
*/
QStringList QString::split(const QRegularExpression &re, SplitBehavior behavior) const
{
return split(re, mapSplitBehavior(behavior));
}
/*!
\overload
\since 5.14
Splits the string into substring references wherever the regular expression
\a re matches, and returns the list of those strings. If \a re
@ -7987,10 +8078,19 @@ QStringList QString::split(const QRegularExpression &re, SplitBehavior behavior)
\sa split() QStringRef
*/
QVector<QStringRef> QString::splitRef(const QRegularExpression &re, SplitBehavior behavior) const
QVector<QStringRef> QString::splitRef(const QRegularExpression &re, Qt::SplitBehavior behavior) const
{
return splitString<QVector<QStringRef> >(*this, &QString::midRef, re, behavior);
}
/*!
\overload
\since 5.4
*/
QVector<QStringRef> QString::splitRef(const QRegularExpression &re, SplitBehavior behavior) const
{
return splitRef(re, mapSplitBehavior(behavior));
}
#endif // QT_CONFIG(regularexpression)
/*!

38
src/corelib/text/qstring.h
View File

@ -582,7 +582,7 @@ public:
{ return replace(re, QString()); }
#endif
enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };
enum SplitBehavior { KeepEmptyParts, SkipEmptyParts }; // ### Qt 6: replace with Qt:: version
Q_REQUIRED_RESULT QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
@ -601,26 +601,22 @@ public:
Q_REQUIRED_RESULT QVector<QStringRef> splitRef(const QRegularExpression &sep, SplitBehavior behavior = KeepEmptyParts) const;
#endif
private:
static Q_DECL_CONSTEXPR SplitBehavior _sb(Qt::SplitBehavior sb) Q_DECL_NOTHROW
{ return sb & Qt::SkipEmptyParts ? SkipEmptyParts : KeepEmptyParts; }
public:
Q_REQUIRED_RESULT inline QStringList split(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> splitRef(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT inline QStringList split(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> splitRef(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QStringList split(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QVector<QStringRef> splitRef(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QStringList split(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QVector<QStringRef> splitRef(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#ifndef QT_NO_REGEXP
Q_REQUIRED_RESULT inline QStringList split(const QRegExp &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> splitRef(const QRegExp &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT QStringList split(const QRegExp &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT QVector<QStringRef> splitRef(const QRegExp &sep, Qt::SplitBehavior behavior) const;
#endif
#ifndef QT_NO_REGULAREXPRESSION
Q_REQUIRED_RESULT inline QStringList split(const QRegularExpression &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> splitRef(const QRegularExpression &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT QStringList split(const QRegularExpression &sep, Qt::SplitBehavior behavior) const;
Q_REQUIRED_RESULT QVector<QStringRef> splitRef(const QRegularExpression &sep, Qt::SplitBehavior behavior) const;
#endif
@ -1624,10 +1620,10 @@ public:
Q_REQUIRED_RESULT QVector<QStringRef> split(QChar sep, QString::SplitBehavior behavior = QString::KeepEmptyParts,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> split(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT inline QVector<QStringRef> split(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QVector<QStringRef> split(const QString &sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QVector<QStringRef> split(QChar sep, Qt::SplitBehavior behavior,
Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
Q_REQUIRED_RESULT QStringRef left(int n) const;
Q_REQUIRED_RESULT QStringRef right(int n) const;

17
src/corelib/text/qstringlist.h
View File

@ -384,23 +384,6 @@ inline int QStringList::lastIndexOf(const QRegularExpression &rx, int from) cons
#endif // QT_CONFIG(regularexpression)
#endif // Q_QDOC
//
// QString inline functions:
//
QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return split(sep, _sb(behavior), cs); }
QStringList QString::split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return split(sep, _sb(behavior), cs); }
#ifndef QT_NO_REGEXP
QStringList QString::split(const QRegExp &sep, Qt::SplitBehavior behavior) const
{ return split(sep, _sb(behavior)); }
#endif
#if QT_CONFIG(regularexpression)
QStringList QString::split(const QRegularExpression &sep, Qt::SplitBehavior behavior) const
{ return split(sep, _sb(behavior)); }
#endif
QT_END_NAMESPACE
#endif // QSTRINGLIST_H

18
src/corelib/tools/qvector.h
View File

@ -1133,24 +1133,6 @@ extern template class Q_CORE_EXPORT QVector<QPoint>;
QVector<uint> QStringView::toUcs4() const { return QtPrivate::convertToUcs4(*this); }
QVector<QStringRef> QString::splitRef(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return splitRef(sep, _sb(behavior), cs); }
QVector<QStringRef> QString::splitRef(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return splitRef(sep, _sb(behavior), cs); }
#ifndef QT_NO_REGEXP
QVector<QStringRef> QString::splitRef(const QRegExp &sep, Qt::SplitBehavior behavior) const
{ return splitRef(sep, _sb(behavior)); }
#endif
#if QT_CONFIG(regularexpression)
QVector<QStringRef> QString::splitRef(const QRegularExpression &sep, Qt::SplitBehavior behavior) const
{ return splitRef(sep, _sb(behavior)); }
#endif
QVector<QStringRef> QStringRef::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return split(sep, QString::_sb(behavior), cs); }
QVector<QStringRef> QStringRef::split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{ return split(sep, QString::_sb(behavior), cs); }
QT_END_NAMESPACE
#endif // QVECTOR_H