Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "hunspellwordlist_p.h"
#include <QtAlgorithms>
#include <hunspell/hunspell.h>
QT_BEGIN_NAMESPACE
namespace QtVirtualKeyboard {
/*!
\class QtVirtualKeyboard::HunspellWordList
\internal
*/
HunspellWordList::HunspellWordList(int limit) :
_index(0),
_limit(limit)
{
}
HunspellWordList::HunspellWordList(HunspellWordList &other)
{
*this = other;
}
HunspellWordList &HunspellWordList::operator=(HunspellWordList &other)
{
if (this != &other) {
QMutexLocker guard(&_lock);
QMutexLocker otherGuard(&other._lock);
_list = other._list;
_flags = other._flags;
_index = other._index;
_limit = other._limit;
_searchIndex = other._searchIndex;
}
return *this;
}
int HunspellWordList::index() const
{
return _index < _list.size() ? _index : -1;
}
void HunspellWordList::setIndex(int index)
{
QMutexLocker guard(&_lock);
_index = index;
}
bool HunspellWordList::clear()
{
QMutexLocker guard(&_lock);
bool result = !_list.isEmpty();
_list.clear();
_flags.clear();
_index = 0;
_searchIndex.clear();
return result;
}
bool HunspellWordList::clearSuggestions()
{
QMutexLocker guard(&_lock);
if (_list.isEmpty())
return false;
_searchIndex.clear();
if (_list.size() > 1) {
QString word = _list.at(0);
Flags flags = _flags.at(0);
_list.clear();
_flags.clear();
if (!word.isEmpty()) {
_index = 0;
_list.append(word);
_flags.append(flags);
}
return true;
} else if (_list.at(0).isEmpty()) {
_list.clear();
_flags.clear();
_index = 0;
return true;
}
return false;
}
bool HunspellWordList::hasSuggestions() const
{
return _list.size() > 1;
}
int HunspellWordList::size() const
{
return _list.size();
}
int HunspellWordList::isEmpty() const
{
return _list.isEmpty() || _list.at(0).isEmpty();
}
bool HunspellWordList::contains(const QString &word)
{
QMutexLocker guard(&_lock);
// Use index search when the search index is available.
// This provides a lot faster search than QList::contains().
// Search index is available when it has been rebuilt using
// rebuildSearchIndex() method. Search index is automatically
// cleared when the word list is modified.
if (!_searchIndex.isEmpty()) {
Q_ASSERT(_searchIndex.size() == _list.size());
SearchContext searchContext(word, _list);
return std::binary_search(_searchIndex.begin(), _searchIndex.end(), -1, [searchContext](const int &a, const int &b) {
const QString &wordA = (a == -1) ? searchContext.word : searchContext.list[a];
const QString &wordB = (b == -1) ? searchContext.word : searchContext.list[b];
return wordA.compare(wordB, Qt::CaseInsensitive) < 0;
});
}
return _list.contains(word, Qt::CaseInsensitive);
}
QString HunspellWordList::findWordCompletion(const QString &word)
{
QMutexLocker guard(&_lock);
if (!_searchIndex.isEmpty()) {
Q_ASSERT(_searchIndex.size() == _list.size());
SearchContext searchContext(word, _list);
auto match = std::lower_bound(_searchIndex.begin(), _searchIndex.end(), -1, [searchContext](const int &a, const int &b) {
const QString &wordA = (a == -1) ? searchContext.word : searchContext.list[a];
const QString &wordB = (b == -1) ? searchContext.word : searchContext.list[b];
return wordA.compare(wordB, Qt::CaseInsensitive) < 0;
});
if (match == _searchIndex.end())
return QString();
if (!word.compare(_list[*match], Qt::CaseInsensitive)) {
match++;
if (match == _searchIndex.end())
return QString();
}
return _list[*match].startsWith(word, Qt::CaseInsensitive) ? _list[*match] : QString();
}
QString bestMatch;
for (int i = 0, count = _list.size(); i < count; ++i) {
const QString &wordB(_list[i]);
if (wordB.size() > bestMatch.size() &&
word.size() < wordB.size() &&
wordB.startsWith(word, Qt::CaseInsensitive))
bestMatch = wordB;
}
return bestMatch;
}
int HunspellWordList::indexOfWord(const QString &word)
{
QMutexLocker guard(&_lock);
if (!_searchIndex.isEmpty()) {
Q_ASSERT(_searchIndex.size() == _list.size());
SearchContext searchContext(word, _list);
auto match = std::lower_bound(_searchIndex.begin(), _searchIndex.end(), -1, [searchContext](int a, int b) {
const QString &wordA = (a == -1) ? searchContext.word : searchContext.list[a];
const QString &wordB = (b == -1) ? searchContext.word : searchContext.list[b];
return wordA.compare(wordB, Qt::CaseInsensitive) < 0;
});
return (match != _searchIndex.end()) ? *match : -1;
}
return _list.indexOf(word);
}
QString HunspellWordList::wordAt(int index)
{
QMutexLocker guard(&_lock);
return index >= 0 && index < _list.size() ? _list.at(index) : QString();
}
void HunspellWordList::wordAt(int index, QString &word, Flags &flags)
{
QMutexLocker guard(&_lock);
Q_ASSERT(index >= 0 && index < _list.size());
word = _list.at(index);
flags = _flags.at(index);
}
const HunspellWordList::Flags &HunspellWordList::wordFlagsAt(int index)
{
QMutexLocker guard(&_lock);
return _flags[index];
}
void HunspellWordList::appendWord(const QString &word, const Flags &flags)
{
QMutexLocker guard(&_lock);
_searchIndex.clear();
if (_limit > 0) {
while (_list.size() >= _limit) {
_list.removeAt(0);
_flags.removeAt(0);
}
}
_list.append(word);
_flags.append(flags);
}
void HunspellWordList::insertWord(int index, const QString &word, const Flags &flags)
{
QMutexLocker guard(&_lock);
Q_ASSERT(_limit == 0);
_searchIndex.clear();
_list.insert(index, word);
_flags.insert(index, flags);
}
void HunspellWordList::updateWord(int index, const QString &word, const Flags &flags)
{
Q_ASSERT(index >= 0);
QMutexLocker guard(&_lock);
if (index < _list.size()) {
if (word != _list[index])
_searchIndex.clear();
_list[index] = word;
_flags[index] = flags;
} else {
_searchIndex.clear();
_list.append(word);
_flags.append(flags);
}
}
void HunspellWordList::moveWord(int from, int to)
{
QMutexLocker guard(&_lock);
if (from < 0 || from >= _list.size())
return;
if (to < 0 || to >= _list.size())
return;
if (from == to)
return;
_searchIndex.clear();
_list.move(from, to);
_flags.move(from, to);
}
int HunspellWordList::removeWord(const QString &word)
{
QMutexLocker guard(&_lock);
int removeCount = 0;
for (int i = 0, count = _list.size(); i < count;) {
if (!_list[i].compare(word, Qt::CaseInsensitive)) {
_list.removeAt(i);
_flags.removeAt(i);
--count;
++removeCount;
} else {
++i;
}
}
if (removeCount > 0)
_searchIndex.clear();
return removeCount;
}
void HunspellWordList::removeWordAt(int index)
{
QMutexLocker guard(&_lock);
_list.removeAt(index);
}
void HunspellWordList::rebuildSearchIndex()
{
QMutexLocker guard(&_lock);
_searchIndex.clear();
if (_list.isEmpty())
return;
_searchIndex.resize(_list.size());
std::iota(_searchIndex.begin(), _searchIndex.end(), 0);
const QStringList list(_list);
std::sort(_searchIndex.begin(), _searchIndex.end(), [list](int a, int b) { return list[a].compare(list[b], Qt::CaseInsensitive) < 0; });
}
} // namespace QtVirtualKeyboard
QT_END_NAMESPACE