match_doc

std::tuple<std::vector<std::string_view>, DocumentStatus> SearchServer::MatchDocument(std::string_view raw_query, int document_id) const {

    ThrowSpecialSymbolInText(raw_query);

    if (IsNegativeDocumentId(document_id)) {
        throw std::invalid_argument("Negative document id"s);
    }

    if (IsNonexistentDocumentId(document_id)) {
        throw std::invalid_argument("Nonexistent document id"s);
    }

    SearchServer::PlusMinusWords prepared_query = ParseQuery(raw_query);

    for (std::string_view minus_word : prepared_query.minus_words) {
        if (TF_by_term_.count(minus_word) > 0) {
            if (TF_by_term_.at(minus_word).count(document_id) > 0) {
                return {std::vector<std::string_view>{}, document_info_.at(document_id).status};
            }
        }
    }

    std::set<std::string_view> plus_words_in_document;

    for (std::string_view plus_word : prepared_query.plus_words) {
        if (TF_by_term_.count(plus_word) == 1) {
            if (TF_by_term_.at(plus_word).count(document_id) == 1) {
                plus_words_in_document.insert(plus_word);
            }
        }
    }

    std::vector<std::string_view> result_intersection; // интересно, если + слов как и - слов в документе не оказалось, пихать неинициализированный result_intersection это нормально?
    for (std::string_view word : plus_words_in_document) {
        result_intersection.push_back(word);
    }

    return {result_intersection, document_info_.at(document_id).status};
}

std::tuple<std::vector<std::string_view>, DocumentStatus> SearchServer::MatchDocument(std::execution::sequenced_policy, std::string_view raw_query, int document_id) const {
    return MatchDocument(raw_query, document_id);
}

std::tuple<std::vector<std::string_view>, DocumentStatus> SearchServer::MatchDocument(std::execution::parallel_policy, std::string_view raw_query, int document_id) const {

    if (IsNegativeDocumentId(document_id)) {
        throw std::invalid_argument("Negative document id"s);
    }

    if (IsNonexistentDocumentId(document_id)) {
        throw std::invalid_argument("Nonexistent document id"s);
    }

    // тут два вектора с возможно повторяющимися + и - словами
    SearchServer::PlusMinusWords prepared_query = ParseQuery(std::execution::par, raw_query);

    // вытягиваю слова документа из сервера, других вариантов кроме как по map пройтись у меня нет
    std::vector<std::string_view> words(TF_by_id_.at(document_id).size());
    std::transform(std::execution::par,
                   TF_by_id_.at(document_id).begin(), TF_by_id_.at(document_id).end(),
                   words.begin(),
                   [](auto& item) { return item.first; });

    bool is_minus_words_in_document = any_of(std::execution::par, words.begin(), words.end(),
                                             [&prepared_query](std::string_view word) {

                                                return count(std::execution::par, // у меня же теперь вектор! запускаю параллельный ЛИНЕЙНЫЙ поиск (а был set, где поиск шел за log); ПОЧЕМУ БЫСТРЕЕ-ТО ВЫХОДИТ?!
                                                             prepared_query.minus_words.begin(),
                                                             prepared_query.minus_words.end(),
                                                             word);
                                             }
                                            );

    if (is_minus_words_in_document) {
        return {std::vector<std::string_view>{}, document_info_.at(document_id).status};
    }

    std::vector<std::string_view> result_intersection(std::min(prepared_query.plus_words.size(), words.size()));
    std::copy_if(std::execution::par, words.begin(), words.end(),
                 result_intersection.begin(),
                 [&prepared_query](std::string_view word) {

                    return count(std::execution::par,
                                 prepared_query.plus_words.begin(),
                                 prepared_query.plus_words.end(),
                                 word);
                 }
                );

    std::sort(std::execution::par,
              result_intersection.begin(), result_intersection.end());

    // найдем первое не пустое слово
    auto start = std::upper_bound(result_intersection.begin(), result_intersection.end(), ""sv);

    // // вариант 1: seq=1494, par=998
    // std::vector<std::string> result;
    // std::move(start, result_intersection.end(), std::back_inserter(result));
    // return {result, document_info_.at(document_id).status};

    // вариант 2: seq=1503, par=992
    return {{start, result_intersection.end()}, document_info_.at(document_id).status};

    // // вариант 3: seq=1444, par=998

    // auto last = std::unique(result_intersection.begin(), result_intersection.end());
    // result_intersection.erase(last, result_intersection.end());
    // if (result_intersection.front() == ""sv) {
    //     result_intersection.erase(result_intersection.begin()); // стереть пустую строку из начала
    // }
    // return {result_intersection, document_info_.at(document_id).status};
}