chromium/components/query_parser/query_parser.cc

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/query_parser/query_parser.h"

#include <algorithm>
#include <memory>
#include <ostream>

#include "base/check.h"
#include "base/compiler_specific.h"
#include "base/i18n/break_iterator.h"
#include "base/i18n/case_conversion.h"
#include "base/notreached.h"
#include "base/ranges/algorithm.h"
#include "base/strings/utf_string_conversions.h"

namespace query_parser {
namespace {

// Returns true if |mp1.first| is less than |mp2.first|. This is used to
// sort match positions.
int CompareMatchPosition(const Snippet::MatchPosition& mp1,
                         const Snippet::MatchPosition& mp2) { … }

// Returns true if |mp2| intersects |mp1|. This is intended for use by
// CoalesceMatchesFrom and isn't meant as a general intersection comparison
// function.
bool SnippetIntersects(const Snippet::MatchPosition& mp1,
                       const Snippet::MatchPosition& mp2) { … }

// Coalesces match positions in |matches| after index that intersect the match
// position at |index|.
void CoalesceMatchesFrom(size_t index, Snippet::MatchPositions* matches) { … }

// Returns true if the character is considered a quote.
bool IsQueryQuote(wchar_t ch) { … }

}  // namespace

// Inheritance structure:
// Queries are represented as trees of QueryNodes.
// QueryNodes are either a collection of subnodes (a QueryNodeList)
// or a single word (a QueryNodeWord).

// A QueryNodeWord is a single word in the query.
class QueryNodeWord : public QueryNode { … };

QueryNodeWord::QueryNodeWord(const std::u16string& word,
                             MatchingAlgorithm matching_algorithm)
    : … { … }

QueryNodeWord::~QueryNodeWord() { … }

int QueryNodeWord::AppendToSQLiteQuery(std::u16string* query) const { … }

bool QueryNodeWord::IsWord() const { … }

bool QueryNodeWord::Matches(const std::u16string& word, bool exact) const { … }

bool QueryNodeWord::HasMatchIn(const QueryWordVector& words,
                               Snippet::MatchPositions* match_positions) const { … }

bool QueryNodeWord::HasMatchIn(const QueryWordVector& words, bool exact) const { … }

void QueryNodeWord::AppendWords(std::vector<std::u16string>* words) const { … }

// A QueryNodeList has a collection of QueryNodes which are deleted in the end.
class QueryNodeList : public QueryNode { … };

QueryNodeList::QueryNodeList() { … }

QueryNodeList::~QueryNodeList() { … }

void QueryNodeList::AddChild(std::unique_ptr<QueryNode> node) { … }

void QueryNodeList::RemoveEmptySubnodes() { … }

int QueryNodeList::AppendToSQLiteQuery(std::u16string* query) const { … }

bool QueryNodeList::IsWord() const { … }

bool QueryNodeList::Matches(const std::u16string& word, bool exact) const { … }

bool QueryNodeList::HasMatchIn(const QueryWordVector& words,
                               Snippet::MatchPositions* match_positions) const { … }

bool QueryNodeList::HasMatchIn(const QueryWordVector& words, bool exact) const { … }

void QueryNodeList::AppendWords(std::vector<std::u16string>* words) const { … }

int QueryNodeList::AppendChildrenToString(std::u16string* query) const { … }

// A QueryNodePhrase is a phrase query ("quoted").
class QueryNodePhrase : public QueryNodeList { … };

QueryNodePhrase::QueryNodePhrase() { … }

QueryNodePhrase::~QueryNodePhrase() { … }

int QueryNodePhrase::AppendToSQLiteQuery(std::u16string* query) const { … }

bool QueryNodePhrase::MatchesAll(const QueryWordVector& words,
                                 const QueryWord** first_word,
                                 const QueryWord** last_word) const { … }

bool QueryNodePhrase::HasMatchIn(
    const QueryWordVector& words,
    Snippet::MatchPositions* match_positions) const { … }

bool QueryNodePhrase::HasMatchIn(const QueryWordVector& words,
                                 bool exact) const { … }

// static
bool QueryParser::IsWordLongEnoughForPrefixSearch(
    const std::u16string& word,
    MatchingAlgorithm matching_algorithm) { … }

// static
int QueryParser::ParseQuery(const std::u16string& query,
                            MatchingAlgorithm matching_algorithm,
                            std::u16string* sqlite_query) { … }

// static
void QueryParser::ParseQueryWords(const std::u16string& query,
                                  MatchingAlgorithm matching_algorithm,
                                  std::vector<std::u16string>* words) { … }

// static
void QueryParser::ParseQueryNodes(const std::u16string& query,
                                  MatchingAlgorithm matching_algorithm,
                                  QueryNodeVector* nodes) { … }

// static
bool QueryParser::DoesQueryMatch(const std::u16string& find_in_text,
                                 const QueryNodeVector& find_nodes,
                                 Snippet::MatchPositions* match_positions) { … }

// static
bool QueryParser::DoesQueryMatch(const QueryWordVector& find_in_words,
                                 const QueryNodeVector& find_nodes,
                                 bool exact) { … }

// static
bool QueryParser::ParseQueryImpl(const std::u16string& query,
                                 MatchingAlgorithm matching_algorithm,
                                 QueryNodeList* root) { … }

// static
void QueryParser::ExtractQueryWords(const std::u16string& text,
                                    QueryWordVector* words) { … }

// static
void QueryParser::SortAndCoalesceMatchPositions(
    Snippet::MatchPositions* matches) { … }

}  // namespace query_parser