DataStructures.h

#ifndef LIBTPC_QUERY_H
#define LIBTPC_QUERY_H

#include <vector>
#include <string>
#include <lucene++/LuceneHeaders.h>
#include <cfloat>

namespace tpc {

    namespace index {

        static const std::vector<std::string> LUCENE_SPECIAL_CHARS = {"!", "(", ")", "{", "}", "[", "]", "^",
                                                                      "~", ":"};

        enum class QueryType {
            document = 1, sentence = 2
        };

        enum class DocumentType {
            main = 1, external = 2
        };

        struct SentenceSummary {
            int sentence_id{-1};
            int lucene_internal_id{-1};
            double score{0};
        };

        struct SentenceDetails : public SentenceSummary {
            int doc_position_begin{-1};
            int doc_position_end{-1};
            std::string sentence_text;
            std::string categories_string;
        };

        struct Document {
            std::string identifier;
            double score{0};
            std::string year;
            int lucene_internal_id{-1};
            DocumentType documentType{DocumentType::main};
        };

        struct DocumentSummary : public Document {
            std::vector <SentenceSummary> matching_sentences;
        };

        struct DocumentDetails : public Document {
            std::string filepath;
            std::string fulltext;
            std::string categories_string;
            std::string abstract;
            std::vector <std::string> corpora;
            std::string accession;
            std::string title;
            std::string author;
            std::string journal;
            std::string type;
            std::vector <SentenceDetails> sentences_details;
        };

        class Query {
        public:
            QueryType type{QueryType::document};
            std::string keyword{""};
            std::string exclude_keyword{""};
            std::string year{""};
            std::string author{""};
            std::string accession{""};
            std::string journal{""};
            std::string paper_type{""};
            bool case_sensitive{false};
            bool sort_by_year{false};
            bool exact_match_author{false};
            bool exact_match_journal{false};
            bool categories_and_ed{true};
            std::vector<std::string> literatures{};
            std::vector<std::string> categories{};

            std::string get_query_text() const;
        private:
            void add_field_to_text_if_not_empty(const std::string& field_value, const std::string& lucene_field_name,
                                                bool exact_match_field, std::string& query_text) const;
            void add_categories_to_text(std::string& query_text) const;
        };

        struct SearchResults {
            Query query;
            std::vector <DocumentSummary> hit_documents{};
            size_t total_num_sentences{0};
            double max_score{0};
            double min_score{DBL_MAX};
            Lucene::Collection <Lucene::ScoreDocPtr> partialIndexMatches{};
            Lucene::Collection <Lucene::ScoreDocPtr> partialExternalMatches{};

            void update(const SearchResults &other);
        };
    }
}


#endif //LIBTPC_QUERY_H