search.hpp File Reference

#include <vector>
#include <string>
#include "sqlite.hpp"

Go to the source code of this file.

Functions
const vector< vector< string > >	remwharead::parse_expression (string expression)
	Split expression in subexpressions. More...
const string	remwharead::to_lowercase (const string &str)
	Convert str to lowercase. Works with unicode. More...
const vector< DB::entry >	remwharead::search_tags (const vector< Database::entry > &entries, string expression, const bool is_re)
	Search in tags of database entries. More...
const vector< DB::entry >	remwharead::search_all (const vector< Database::entry > &entries, string expression, const bool is_re)
	Search in full text of database entries. More...

Function Documentation

parse_expression()

const vector< vector< string > > remwharead::parse_expression

(

string

expression

)

Split expression in subexpressions.

First it splits at OR or ||, then it splits the subexpressions at AND or &&. The first vector contains all tags before the first OR.

Returns

Vector of OR-vectors of AND-tags.

    {
        vector<vector<string>> searchlist;
        const regex re_or("(.+?) (OR|\\|\\|) ");
        const regex re_and("(.+?) (AND|&&) ");
        smatch match;

        vector<string> subexpressions;
        {                           // Split expression at OR.
            while (regex_search(expression, match, re_or))
            {
                subexpressions.push_back(match[1].str());
                expression = match.suffix().str();
            }
            subexpressions.push_back(expression);
        }

        {
            for (string sub : subexpressions)
            {                       // Split each OR-slice at AND.
                vector<string> terms;
                while (regex_search(sub, match, re_and))
                {
                    terms.push_back(to_lowercase(match[1].str()));
                    sub = match.suffix().str();
                }
                terms.push_back(to_lowercase(sub));
                searchlist.push_back(terms);
            }
        }

        return searchlist;
    }

search_all()

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

Search in full text of database entries.

Searches in tags, title, description and full text.

Parameters

entries	Vector of Database::entry to search.
expression	Search expression.
is_re	Is it a regular expression?

Returns

Vector of matching Database::entry.

    {
        vector<vector<string>> searchlist = parse_expression(expression);
        vector<DB::entry> result = search_tags(entries, 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_tags()

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

Search in tags of database entries.

Only matches whole tags, Pill does not match Pillow.

Parameters

entries	Vector of Database::entry to search.
expression	Search expression.
is_re	Is it a regular expression?

Returns

Vector of matching Database::entry.

    {
        vector<vector<string>> searchlist = parse_expression(expression);
        vector<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(),
                        [&tag, 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;
    }

to_lowercase()

const string remwharead::to_lowercase

(

const string &

str

)

Convert str to lowercase. Works with unicode.

    {
        icu::UnicodeString uni(str.c_str());
        string out;
        uni.toLower().toUTF8String(out);
        return out;
    }