qstringlist.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <qstringlist.h>
#include <qset.h>
#if QT_CONFIG(regularexpression)
#  include <qregularexpression.h>
#endif
#include <private/qduplicatetracker_p.h>
 
#include <algorithm>
QT_BEGIN_NAMESPACE
 
 
 
void QtPrivate::QStringList_sort(QStringList *that, Qt::CaseSensitivity cs)
{
    if (cs == Qt::CaseSensitive) {
        std::sort(that->begin(), that->end());
    } else {
        auto CISCompare = [](const auto &s1, const auto &s2) {
            return s1.compare(s2, Qt::CaseInsensitive) < 0;
        };
        std::sort(that->begin(), that->end(), CISCompare);
    }
}
 
 
template <typename String>
static QStringList filter_helper(const QStringList &that, const String &needle, Qt::CaseSensitivity cs)
{
    QStringList res;
    for (const auto &s : that) {
        if (s.contains(needle, cs))
            res.append(s);
    }
    return res;
}
 
QStringList QtPrivate::QStringList_filter(const QStringList *that, QStringView str,
                                          Qt::CaseSensitivity cs)
{
    return filter_helper(*that, str, cs);
}
 
QStringList QtPrivate::QStringList_filter(const QStringList &that, const QStringMatcher &matcher)
{
    QStringList res;
    for (const auto &s : that) {
        if (matcher.indexIn(s) != -1)
            res.append(s);
    }
    return res;
}
 
QStringList QtPrivate::QStringList_filter(const QStringList &that, QLatin1StringView needle,
                                          Qt::CaseSensitivity cs)
{
    return filter_helper(that, needle, cs);
}
 
template<typename T>
static bool stringList_contains(const QStringList &stringList, const T &str, Qt::CaseSensitivity cs)
{
    for (const auto &string : stringList) {
        if (string.size() == str.size() && string.compare(str, cs) == 0)
            return true;
    }
    return false;
}
 
 
bool QtPrivate::QStringList_contains(const QStringList *that, QStringView str,
                                     Qt::CaseSensitivity cs)
{
    return stringList_contains(*that, str, cs);
}
 
bool QtPrivate::QStringList_contains(const QStringList *that, QLatin1StringView str,
                                     Qt::CaseSensitivity cs)
{
    return stringList_contains(*that, str, cs);
}
 
 
#if QT_CONFIG(regularexpression)
QStringList QtPrivate::QStringList_filter(const QStringList *that, const QRegularExpression &re)
{
    QStringList res;
    for (const auto &str : *that) {
        if (str.contains(re))
            res.append(str);
    }
    return res;
}
#endif // QT_CONFIG(regularexpression)
 
void QtPrivate::QStringList_replaceInStrings(QStringList *that, QStringView before,
                                             QStringView after, Qt::CaseSensitivity cs)
{
    // Before potentially detaching "that" list, check if any string contains "before"
    qsizetype i = -1;
    for (qsizetype j = 0; j < that->size(); ++j) {
        if (that->at(j).contains(before, cs)) {
            i = j;
            break;
        }
    }
    if (i == -1)
        return;
 
    for (; i < that->size(); ++i)
        (*that)[i].replace(before.data(), before.size(), after.data(), after.size(), cs);
}
 
#if QT_CONFIG(regularexpression)
void QtPrivate::QStringList_replaceInStrings(QStringList *that, const QRegularExpression &re,
                                             const QString &after)
{
    // Before potentially detaching "that" list, check if any string contains "before"
    qsizetype i = -1;
    for (qsizetype j = 0; j < that->size(); ++j) {
        if (that->at(j).contains(re)) {
            i = j;
            break;
        }
    }
    if (i == -1)
        return;
 
    for (; i < that->size(); ++i)
        (*that)[i].replace(re, after);
}
#endif // QT_CONFIG(regularexpression)
 
static qsizetype accumulatedSize(const QStringList &list, qsizetype seplen)
{
    qsizetype result = 0;
    if (!list.isEmpty()) {
        for (const auto &e : list)
            result += e.size() + seplen;
        result -= seplen;
    }
    return result;
}
 
QString QtPrivate::QStringList_join(const QStringList *that, const QChar *sep, qsizetype seplen)
{
    const qsizetype totalLength = accumulatedSize(*that, seplen);
    const qsizetype size = that->size();
 
    QString res;
    if (totalLength == 0)
        return res;
    res.reserve(totalLength);
    for (qsizetype i = 0; i < size; ++i) {
        if (i)
            res.append(sep, seplen);
        res += that->at(i);
    }
    return res;
}
 
QString QtPrivate::QStringList_join(const QStringList &list, QLatin1StringView sep)
{
    QString result;
    if (!list.isEmpty()) {
        result.reserve(accumulatedSize(list, sep.size()));
        const auto end = list.end();
        auto it = list.begin();
        result += *it;
        while (++it != end) {
            result += sep;
            result += *it;
        }
    }
    return result;
}
 
QString QtPrivate::QStringList_join(const QStringList *that, QStringView sep)
{
    return QStringList_join(that, sep.data(), sep.size());
}
 
 
 
template <typename String>
qsizetype indexOf_helper(const QStringList &that, String needle, qsizetype from,
                         Qt::CaseSensitivity cs)
{
    if (from < 0) // Historical behavior
        from = qMax(from + that.size(), 0);
 
    if (from >= that.size())
        return -1;
 
    for (qsizetype i = from; i < that.size(); ++i) {
        if (needle.compare(that.at(i), cs) == 0)
            return i;
    }
    return -1;
}
 
qsizetype QtPrivate::QStringList_indexOf(const QStringList &that, QStringView needle,
                                         qsizetype from, Qt::CaseSensitivity cs)
{
    return indexOf_helper(that, needle, from, cs);
}
 
qsizetype QtPrivate::QStringList_indexOf(const QStringList &that, QLatin1StringView needle,
                                         qsizetype from, Qt::CaseSensitivity cs)
{
    return indexOf_helper(that, needle, from, cs);
}
 
template <typename String>
qsizetype lastIndexof_helper(const QStringList &that, String needle, qsizetype from,
                             Qt::CaseSensitivity cs)
{
    if (from < 0)
        from += that.size();
    else if (from >= that.size())
        from = that.size() - 1;
 
     for (qsizetype i = from; i >= 0; --i) {
        if (needle.compare(that.at(i), cs) == 0)
            return i;
    }
 
    return -1;
}
 
qsizetype QtPrivate::QStringList_lastIndexOf(const QStringList &that, QLatin1StringView needle,
                                            qsizetype from, Qt::CaseSensitivity cs)
{
    return lastIndexof_helper(that, needle, from, cs);
}
 
qsizetype QtPrivate::QStringList_lastIndexOf(const QStringList &that, QStringView needle,
                                             qsizetype from, Qt::CaseSensitivity cs)
{
    return lastIndexof_helper(that, needle, from, cs);
}
 
#if QT_CONFIG(regularexpression)
qsizetype QtPrivate::QStringList_indexOf(const QStringList *that, const QRegularExpression &re, qsizetype from)
{
    if (from < 0)
        from = qMax(from + that->size(), qsizetype(0));
 
    QString exactPattern = QRegularExpression::anchoredPattern(re.pattern());
    QRegularExpression exactRe(exactPattern, re.patternOptions());
 
    for (qsizetype i = from; i < that->size(); ++i) {
        QRegularExpressionMatch m = exactRe.match(that->at(i));
        if (m.hasMatch())
            return i;
    }
    return -1;
}
 
qsizetype QtPrivate::QStringList_lastIndexOf(const QStringList *that, const QRegularExpression &re, qsizetype from)
{
    if (from < 0)
        from += that->size();
    else if (from >= that->size())
        from = that->size() - 1;
 
    QString exactPattern = QRegularExpression::anchoredPattern(re.pattern());
    QRegularExpression exactRe(exactPattern, re.patternOptions());
 
    for (qsizetype i = from; i >= 0; --i) {
        QRegularExpressionMatch m = exactRe.match(that->at(i));
        if (m.hasMatch())
            return i;
    }
    return -1;
}
#endif // QT_CONFIG(regularexpression)
 
qsizetype QtPrivate::QStringList_removeDuplicates(QStringList *that)
{
    QDuplicateTracker<QString> seen(that->size());
    return that->removeIf([&](const QString &s) { return seen.hasSeen(s); });
}
 
QT_END_NAMESPACE