remwharead::Search Class Reference

Search in database entries. More...

#include <remwharead/search.hpp>

Public Member Functions
	Search (const list< Database::entry > &entries)
	Defines the entries to search. More...
const list< Database::entry >	search_tags (string expression, const bool is_re) const
	Search in tags of database entries. More...
const list< Database::entry >	search_all (string expression, const bool is_re) const
	Search in full text of database entries. More...
const list< Database::entry >	search_all_threaded (string expression, const 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 ( const list< Database::entry > &  entries )

explicit

Defines the entries to search.

Since

0.7.0

        :_entries(entries)
    {}

Member Function Documentation

search_all()

const list< DB::entry > remwharead::Search::search_all	(	string	expression,
		const 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<DB::entry> result = search_tags(expression, is_re);

        for (const vector<string> &terms_or : searchlist)
        {
            for (const DB::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(!regex_search(title, re))
                        {
                            matched_title = false;
                        }

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

                        if(!regex_search(fulltext, re))
                        {
                            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 == true
                    || matched_description == true
                    || matched_fulltext == true)
                {
                    result.push_back(entry);
                }
            }
        }

        return result;
    }

search_all_threaded()

const list< Database::entry > remwharead::Search::search_all_threaded	(	string	expression,
		const 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`.
        segments.push_back(move(entries));

        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()

const list< DB::entry > remwharead::Search::search_tags	(	string	expression,
		const 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<DB::entry> result;

        for (const vector<string> &tags_or : searchlist)
        {
            for (const DB::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 regex_search(s, re);
                            }
                            else
                            {
                                return (s == tag);
                            }
                        });
                    if (it == entry.tags.end())
                    {
                        matched = false;
                    }
                }
                if (matched == true)
                {
                    result.push_back(entry);
                }
            }
        }

        return result;
    }

---

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

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