remwharead::Search Class Reference

Search in database entries. More...

#include <remwharead/search.hpp>

Public Member Functions
	Search (list< Database::entry > entries)
	Defines the entries to search. More...
list< Database::entry >	search_tags (const string &expression, bool is_re) const
	Search in tags of database entries. More...
list< Database::entry >	search_all (const string &expression, bool is_re) const
	Search in full text of database entries. More...
list< Database::entry >	search_all_threaded (const string &expression, bool is_re) const
	Spawn threads of search_all(), if it seems sensible. More...

Detailed Description

Search in database entries.

Since

0.7.0

Constructor & Destructor Documentation

Search()

remwharead::Search::Search ( list< Database::entry >  entries )

explicit

Defines the entries to search.

Since

0.7.0

    :_entries(move(entries))
{}

Member Function Documentation

search_all()

list< Database::entry > remwharead::Search::search_all	(	const string &	expression,
		bool	is_re
	)		const

Search in full text of database entries.

Searches in tags, title, description and full text.

Parameters

expression	Search expression.
is_re	Is it a regular expression?

Returns

List of matching Database::entry.

Since

0.7.0

{
    vector<vector<string>> searchlist = parse_expression(expression);
    list<Database::entry> result = search_tags(expression, is_re);

    for (const vector<string> &terms_or : searchlist)
    {
        for (const Database::entry &entry : _entries)
        {
            // Add entry to result if all terms in an OR-slice match title,
            // description or full text.
            bool matched_title = true;
            bool matched_description = true;
            bool matched_fulltext = true;

            const auto it = find(result.begin(), result.end(), entry);
            if (it != result.end())
            {                   // Skip if already in result list.
                continue;
            }

            for (const string &term : terms_or)
            {
                const string title = to_lowercase(entry.title);
                const string description = to_lowercase(entry.description);
                const string fulltext = to_lowercase(entry.fulltext);

                // Set matched_* to false if term is not found.
                if (is_re)
                {
                    const RegEx re(term);

                    if (!(re == title))
                    {
                        matched_title = false;
                    }

                    if (!(re == description))
                    {
                        matched_description = false;
                    }

                    if (!(re == fulltext))
                    {
                        matched_fulltext = false;
                    }
                }
                else
                {
                    if (title.find(term) == string::npos)
                    {
                        matched_title = false;
                    }

                    if (description.find(term) == string::npos)
                    {
                        matched_description = false;
                    }

                    if (fulltext.find(term) == string::npos)
                    {
                        matched_fulltext = false;
                    }
                }
            }
            if (matched_title || matched_description || matched_fulltext)
            {
                result.push_back(entry);
            }
        }
    }

    return result;
}

search_all_threaded()

list< Database::entry > remwharead::Search::search_all_threaded	(	const string &	expression,
		bool	is_re
	)		const

Spawn threads of search_all(), if it seems sensible.

Figure out if threads could be useful and spawn a sensible amount of them.

Parameters

expression	Search expression.
is_re	Is it a regular expression?

Returns

List of matching Database::entry.

Since

0.7.2

{
    list<Database::entry> entries = _entries;

    const size_t len = entries.size();
    constexpr size_t min_len = 100;
    constexpr size_t min_per_thread = 50;
    const size_t n_threads = thread::hardware_concurrency() / 3 + 1;
    size_t cut_at = len;
    if (len > min_len)
    {   // If there are over `min_len` entries, use `n_threads` threads.
        cut_at = len / n_threads;

        // But don't use less than `min_per_thread` entries per thread.
        if (cut_at < min_per_thread)
        {
            cut_at = min_per_thread;
        }
    }

    list<list<Database::entry>> segments;

    // Use threads if list is big.
    while (entries.size() > cut_at)
    {
        list<Database::entry> segment;

        auto it = entries.begin();
        std::advance(it, cut_at);

        // Move the first `cut_at` entries into `segments`.
        segment.splice(segment.begin(), entries, entries.begin(), it);
        segments.push_back(move(segment));
    }
    // Move rest of `entries` into `segments`.
    list<Database::entry> rest;
    rest.splice(rest.begin(), entries);
    segments.push_back(move(rest));

    list<thread> threads;
    for (auto &segment : segments)
    {
        thread t(
            [&]
            {
                Search search(segment);
                // Replace `segment` with `result`.
                segment = search.search_all(expression, is_re);
            });
        threads.push_back(move(t));
    }

    for (thread &t : threads)
    {
        t.join();
        // Move each of `segments` into `entries`.
        entries.splice(entries.end(), segments.front());
        segments.pop_front();
    }

    return entries;

}

search_tags()

list< Database::entry > remwharead::Search::search_tags	(	const string &	expression,
		bool	is_re
	)		const

Search in tags of database entries.

Only matches whole tags, Pill does not match Pillow.

Parameters

expression	Search expression.
is_re	Is it a regular expression?

Returns

List of matching Database::entry.

Since

0.7.0

{
    vector<vector<string>> searchlist = parse_expression(expression);
    list<Database::entry> result;

    for (const vector<string> &tags_or : searchlist)
    {
        for (const Database::entry &entry : _entries)
        {               // Add entry to result if all tags in an OR-slice match.
            bool matched = true;

            for (const string &tag : tags_or)
            {
                const auto it = find_if(
                    entry.tags.begin(), entry.tags.end(),
                    [&, is_re](string s)
                    {
                        s = to_lowercase(s);
                        if (is_re)
                        {
                            const RegEx re("^" + tag + "$");
                            return (re == s);
                        }

                        return (s == tag);
                    });
                if (it == entry.tags.end())
                {
                    matched = false;
                }
            }
            if (matched)
            {
                result.push_back(entry);
            }
        }
    }

    return result;
}

---

The documentation for this class was generated from the following files:

• include/search.hpp
• src/lib/search.cpp