parallel DBS query

#pragma once

#include <cstddef>
#include <vector>
#include <functional>
#include <atomic>

template<typename row_t>
using predicate_t = std::function<bool(const row_t&)>;


template<typename row_t>
bool is_satisfied_for_all(std::vector<predicate_t<row_t>> predicates, std::vector<row_t> data_table);

template<typename row_t>
bool is_satisfied_for_any(std::vector<predicate_t<row_t>> predicates, std::vector<row_t> data_table);


template<typename row_t>
bool is_satisfied_for_all(std::vector<predicate_t<row_t>> predicates, std::vector<row_t> data_table) {
    // Doimplementujte telo funkce, ktera rozhodne, zda pro VSECHNY dilci dotazy (obsazene ve
    // vektoru 'predicates') existuje alespon jeden zaznam v tabulce (reprezentovane vektorem
    // 'data_table'), pro ktery je dany predikat splneny.

    bool gg = false;
    #pragma omp parallel for
    for (int i = 0; i < predicates.size(); ++i) {
        #pragma omp cancellation point for
        bool go_on= false;
        for (size_t j = 0; j < data_table.size(); j++) {
            auto row = data_table[j];                // i-ty radek tabulky ...
            bool is_satisfied = predicates[i](row);  // ... splnuje prvni predikat, pokud funkce first_predicate vrati true
            if (is_satisfied) {
                go_on = true;
                break;
            }
        }
        if (!go_on) {
            gg = true;
            #pragma omp cancel for
        }
    }
    if (gg) {
        return false;
    }
    return true;
}

template<typename row_t>
bool is_satisfied_for_any(std::vector<predicate_t<row_t>> predicates, std::vector<row_t> data_table) {
    // Doimplementujte telo funkce, ktera rozhodne, zda je ALESPON JEDEN dilci dotaz pravdivy.
    // To znamena, ze mate zjistit, zda existuje alespon jeden predikat 'p' a jeden zaznam
    // v tabulce 'r' takovy, ze p(r) vraci true.

    // Zamyslete se nad tim, pro ktery druh dotazu je vhodny jaky druh paralelizace. Vas
    // kod optimalizujte na situaci, kdy si myslite, ze navratova hodnota funkce bude true.
    // Je pro Vas dulezitejsi rychle najit splnujici radek pro jeden vybrany predikat, nebo
    // je dulezitejsi zkouset najit takovy radek pro vice predikatu paralelne?

    bool gg = false;
    for (int i = 0; i < predicates.size(); ++i) {
        bool go_on = true;
        #pragma omp parallel for
        for (size_t j = 0; j < data_table.size(); j++) {
            #pragma omp cancellation point for
            auto row = data_table[j];                // i-ty radek tabulky ...
            bool is_satisfied = predicates[i](row);  // ... splnuje prvni predikat, pokud funkce first_predicate vrati true
            if (is_satisfied) {
                go_on = false;
                #pragma omp cancel for
//                break;
            }
        }
        if (!go_on) {
            gg = true;
            break;
        }
    }
    if (gg) {
        return true;
    }
    return false;
}