qlatin1stringmatcher.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qlatin1stringmatcher.h"
#include <limits.h>
 
QT_BEGIN_NAMESPACE
 
QLatin1StringMatcher::QLatin1StringMatcher() noexcept
    : m_pattern(),
      m_cs(Qt::CaseSensitive),
      m_caseSensitiveSearcher(m_pattern.data(), m_pattern.data())
{
}
 
QLatin1StringMatcher::QLatin1StringMatcher(QLatin1StringView pattern,
                                           Qt::CaseSensitivity cs) noexcept
    : m_pattern(pattern), m_cs(cs)
{
    setSearcher();
}
 
QLatin1StringMatcher::~QLatin1StringMatcher() noexcept
{
    freeSearcher();
}
 
void QLatin1StringMatcher::setSearcher() noexcept
{
    if (m_cs == Qt::CaseSensitive) {
        new (&m_caseSensitiveSearcher) CaseSensitiveSearcher(m_pattern.data(), m_pattern.end());
    } else {
        QtPrivate::QCaseInsensitiveLatin1Hash foldCase;
        qsizetype bufferSize = std::min(m_pattern.size(), qsizetype(sizeof m_foldBuffer));
        for (qsizetype i = 0; i < bufferSize; ++i)
            m_foldBuffer[i] = static_cast<char>(foldCase(m_pattern[i].toLatin1()));
 
        new (&m_caseInsensitiveSearcher)
                CaseInsensitiveSearcher(m_foldBuffer, &m_foldBuffer[bufferSize]);
    }
}
 
void QLatin1StringMatcher::freeSearcher() noexcept
{
    if (m_cs == Qt::CaseSensitive)
        m_caseSensitiveSearcher.~CaseSensitiveSearcher();
    else
        m_caseInsensitiveSearcher.~CaseInsensitiveSearcher();
}
 
void QLatin1StringMatcher::setPattern(QLatin1StringView pattern) noexcept
{
    if (m_pattern.latin1() == pattern.latin1() && m_pattern.size() == pattern.size())
        return; // Same address and size
 
    freeSearcher();
    m_pattern = pattern;
    setSearcher();
}
 
QLatin1StringView QLatin1StringMatcher::pattern() const noexcept
{
    return m_pattern;
}
 
void QLatin1StringMatcher::setCaseSensitivity(Qt::CaseSensitivity cs) noexcept
{
    if (m_cs == cs)
        return;
 
    freeSearcher();
    m_cs = cs;
    setSearcher();
}
 
Qt::CaseSensitivity QLatin1StringMatcher::caseSensitivity() const noexcept
{
    return m_cs;
}
 
qsizetype QLatin1StringMatcher::indexIn(QLatin1StringView haystack, qsizetype from) const noexcept
{
    return indexIn_helper(haystack, from);
}
 
qsizetype QLatin1StringMatcher::indexIn(QStringView haystack, qsizetype from) const noexcept
{
    return indexIn_helper(haystack, from);
}
 
template <typename String>
qsizetype QLatin1StringMatcher::indexIn_helper(String haystack, qsizetype from) const noexcept
{
    static_assert(QtPrivate::isLatin1OrUtf16View<String>);
 
    if (m_pattern.isEmpty() && from == haystack.size())
        return from;
    if (from < 0) // Historical behavior (see QString::indexOf and co.)
        from += haystack.size();
    if (from >= haystack.size())
        return -1;
 
    const auto start = [haystack] {
        if constexpr (std::is_same_v<String, QStringView>)
            return haystack.utf16();
        else
            return haystack.begin();
    }();
 
    auto begin = start + from;
    auto end = start + haystack.size();
    auto found = begin;
    if (m_cs == Qt::CaseSensitive) {
        found = m_caseSensitiveSearcher(begin, end, m_pattern.begin(), m_pattern.end()).begin;
        if (found == end)
            return -1;
    } else {
        const qsizetype bufferSize = std::min(m_pattern.size(), qsizetype(sizeof m_foldBuffer));
        const QLatin1StringView restNeedle = m_pattern.sliced(bufferSize);
        const bool needleLongerThanBuffer = restNeedle.size() > 0;
        String restHaystack = haystack;
        do {
            found = m_caseInsensitiveSearcher(found, end, m_foldBuffer, &m_foldBuffer[bufferSize])
                            .begin;
            if (found == end) {
                return -1;
            } else if (!needleLongerThanBuffer) {
                break;
            }
            restHaystack = haystack.sliced(
                    qMin(haystack.size(),
                         bufferSize + qsizetype(std::distance(start, found))));
            if (restHaystack.startsWith(restNeedle, Qt::CaseInsensitive))
                break;
            ++found;
        } while (true);
    }
    return std::distance(start, found);
}
 
QT_END_NAMESPACE