UnaryAlgorithm.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 "Partitioner.hpp"
 
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
#include "CeresEngine/Foundation/Traits/is_indirectly_unary_invocable.hpp"
#include "CeresEngine/Foundation/Traits/is_input_range.hpp"
 
namespace CeresEngine {
 
    template<class Derived> class UnaryAlgorithmFunctor {
    public:
        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
            ) constexpr decltype(auto)
            operator()(const E& executor, P p, I first, S last, Fun f) const {
            if(std::is_constant_evaluated()) {
                return Derived().run(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
            } else {
                return Derived().run(executor, p, first, last, std::move(f));
            }
        }
 
        template<class E, class P, class R, class Fun>
        requires(
            // clang-format off
                traits::is_executor_v<E> &&
                traits::is_range_partitioner_v<P, R> &&
                traits::is_input_range_v<R> &&
                traits::is_indirectly_unary_invocable_v<Fun, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<Fun>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, P p, R&& r, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return operator()(executor, p, std::begin(r), std::end(r), std::move(f));
            }
        }
 
        template<class P, class I, class S, class Fun>
        requires(
            // clang-format off
                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 off
            )
        constexpr decltype(auto)
        operator()(P p, I first, S last, Fun f) const {
            if (std::is_constant_evaluated()) {
                return Derived().run(
                    make_inline_executor(),
                    HalvePartitioner(1),
                    first,
                    last,
                    std::move(f));
            } else {
                return Derived().run(
                    make_default_executor(),
                    p,
                    first,
                    last,
                    std::move(f));
            }
        }
 
        template <
            class P,
            class R,
            class Fun> requires(
                // clang-format off
                traits::is_range_partitioner_v<P,R> &&
                traits::is_input_range_v<R> &&
                traits::is_indirectly_unary_invocable_v<Fun, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<Fun>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(P p, R&& r, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return operator()(make_default_executor(), p, std::begin(r), std::end(r), std::move(f));
            }
        }
 
        template<class E, class I, class S, class Fun>
        requires(
            // clang-format off
                    traits::is_executor_v<E> &&
                    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
            ) constexpr decltype(auto)
            operator()(const E& executor, I first, S last, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
            } else {
                return operator()(executor, make_default_partitioner(executor, first, last), first, last, std::move(f));
            }
        }
 
        template<class E, class R, class Fun>
        requires(
            // clang-format off
                traits::is_executor_v<E> &&
                traits::is_input_range_v<R> &&
                traits::is_indirectly_unary_invocable_v<Fun, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<Fun>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, R&& r, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return operator()(executor, make_default_partitioner(executor, std::forward<R>(r)), std::begin(r), std::end(r), std::move(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
            ) constexpr decltype(auto)
            operator()(I first, S last, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
            } else {
                return operator()(make_default_executor(), make_default_partitioner(first, last), first, last, std::move(f));
            }
        }
 
        template<class R, class Fun>
        requires(
            // clang-format off
                traits::is_input_range_v<R> &&
                traits::is_indirectly_unary_invocable_v<Fun, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<Fun>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(R&& r, Fun f) const {
            if(std::is_constant_evaluated()) {
                return operator()(make_inline_executor(), HalvePartitioner(make_grain_size(r.size())), std::begin(r), std::end(r), std::move(f));
            } else {
                return operator()(make_default_executor(), make_default_partitioner(r), std::begin(r), std::end(r), std::move(f));
            }
        }
    };
 
} // namespace CeresEngine