CountIf.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "UnaryAlgorithm.hpp"
 
#include "CeresEngine/Foundation/Algorithm/Partitioner.hpp"
#include "CeresEngine/Foundation/Traits/is_forward_iterator.hpp"
#include "CeresEngine/Foundation/Traits/iter_difference.hpp"
 
namespace CeresEngine {
 
    class CountAlgorithmFunctor;
 
    class CountIfAlgorithmFunctor : public UnaryAlgorithmFunctor<CountIfAlgorithmFunctor> {
        friend UnaryAlgorithmFunctor<CountIfAlgorithmFunctor>;
        friend CountAlgorithmFunctor;
 
        template<class Executor, class I> class Graph {
        private:
            const Executor& mExecutor;
 
        public:
            explicit Graph(const Executor& executor) : mExecutor(executor) {}
 
            template<class P, class S, class Fun> Async<traits::iter_difference_t<I>> launch(P p, I first, S last, Fun f) {
                auto middle = p(first, last);
                const traits::iter_difference_t<I> isTooSmall = middle == last;
                constexpr traits::iter_difference_t<I> isNotParallelize = traits::is_forward_iterator_v<I>;
                if(isTooSmall || isNotParallelize) {
                    return with(mExecutor, [first, last, f]() { return run(first, last, f); });
                }
 
                return when_all(
                    // Create task that launches tasks for rhs: [middle, last]
                    launch(p, middle, last, f),
 
                    // Launch tasks for lhs: [first, middle]
                    launch(p, first, middle, f))
                    .then(std::plus{});
            }
        };
 
        template<class I, class S, class Fun>
        requires(
            // clang-format off
                    traits::is_input_iterator_v<I> &&
                    traits::is_sentinel_for_v<S, I> &&
                    traits::is_indirectly_unary_invocable_v<Fun, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static constexpr traits::iter_difference_t<I> run(I first, S last, Fun p) {
            return std::count_if(first, last, std::move(p));
        }
 
        template<class E, class P, class I, class S, class Fun>
        requires(
            // clang-format off
                    traits::is_executor_v<E> &&
                    traits::is_partitioner_v<P, I, S> &&
                    traits::is_input_iterator_v<I> &&
                    traits::is_sentinel_for_v<S, I> &&
                    traits::is_indirectly_unary_invocable_v<Fun, I> &&
                    std::is_copy_constructible_v<Fun>
            // clang-format on
            ) static Async<traits::iter_difference_t<I>> run(const E& executor, P p, I first, S last, Fun f) {
            if constexpr(traits::is_inline_executor_v<E>) {
                co_return run(first, last, std::move(f));
            } else {
                co_return co_await Graph<E, I>(executor).launch(p, first, last, f);
            }
        }
    };
 
    inline constexpr CountIfAlgorithmFunctor count_if;
 
} // namespace CeresEngine