par_match_document

std::tuple<std::vector<std::string>, DocumentStatus> SearchServer::MatchDocument(std::execution::parallel_policy, const std::string& 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);

    std::vector<const std::string*> 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(words.begin(), words.end(),
                                             [&prepared_query](const std::string* word) {
                                                return prepared_query.minus_words.count(*word);
                                            });

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

    std::vector<const std::string*> result_intersection_ptrs(prepared_query.plus_words.size());
    std::copy_if(std::execution::par,
                 words.begin(), words.end(),
                 result_intersection_ptrs.begin(),
                 [&prepared_query](const std::string* word) { return prepared_query.plus_words.count(*word) != 0; });

    std::vector<std::string> result_intersection(result_intersection_ptrs.size());
    std::transform(std::execution::par,
                   result_intersection_ptrs.begin(), result_intersection_ptrs.end(),
                   result_intersection.begin(),
                   [](const std::string* word) { return *word; });

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