FindIf.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"
 
namespace CeresEngine {
 
    class FindAlgorithmFunctor;
    class FindIfNotAlgorithmFunctor;
 
    class FindIfAlgorithmFunctor : public UnaryAlgorithmFunctor<FindIfAlgorithmFunctor> {
        friend UnaryAlgorithmFunctor<FindIfAlgorithmFunctor>;
        friend FindAlgorithmFunctor;
        friend FindIfNotAlgorithmFunctor;
 
        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<I> launch(P p, I first, S last, S overallLast, Fun f) {
                const I 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, overallLast]() {
                        const I found = std::find_if(first, last, f);
                        if(found == last) {
                            return overallLast;
                        }
                        return found;
                    });
                }
 
                return when_all(
                    // Create task that launches tasks for rhs: [middle, last]
                    launch(p, middle, last, overallLast, f),
 
                    // Launch tasks for lhs: [first, middle]
                    launch(p, first, middle, overallLast, f))
                    .then([overallLast](const I& lhs, const I& rhs) {
                        if(lhs != overallLast) {
                            return lhs;
                        }
                        return rhs;
                    });
            }
 
            template<class P, class S, class Fun> Async<I> launch(P p, I first, S last, Fun f) { return launch(p, first, last, last, f); }
        };
 
        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 I run(I first, S last, Fun p) {
            for(; first != last; ++first) {
                if(p(*first)) {
                    return first;
                }
            }
            return last;
        }
 
        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<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, f);
            } else {
                co_return co_await Graph<E, I>(executor).launch(p, first, last, f);
            }
        }
    };
 
    inline constexpr FindIfAlgorithmFunctor find_if;
 
} // namespace CeresEngine