ValueCompareAlgorithm.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/Traits/is_indirectly_binary_invocable.hpp"
 
namespace CeresEngine {
 
    template<class Derived> class ValueCompareAlgorithmFunctor {
    public:
        template<class E, class P, class I, class S, class T>
        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_binary_invocable_v<std::equal_to<>, T *, I>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, P p, I first, S last, T 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 T>
        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_binary_invocable_v<std::equal_to<>, T *, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<T>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, P p, R&& r, T f) const {
            if(std::is_constant_evaluated()) {
                return Derived().run(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return Derived().run(executor, p, std::begin(r), std::end(r), std::move(f));
            }
        }
 
        template<class P, class I, class S, class T>
        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_binary_invocable_v<std::equal_to<>, T *, I> &&
                std::is_copy_constructible_v<T>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(P p, I first, S last, T 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 T>
        requires(
            // clang-format off
                traits::is_range_partitioner_v<P, R> &&
                traits::is_input_range_v<R> &&
                traits::is_indirectly_binary_invocable_v<std::equal_to<>, T *, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<T>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(P p, R&& r, T f) const {
            if(std::is_constant_evaluated()) {
                return Derived().run(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return Derived().run(make_default_executor(), p, std::begin(r), std::end(r), std::move(f));
            }
        }
 
        template<class E, class I, class S, class T>
        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_binary_invocable_v<std::equal_to<>, T *, I>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, I first, S last, T 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 T>
        requires(
            // clang-format off
                traits::is_executor_v<E> &&
                traits::is_input_range_v<R> &&
                traits::is_indirectly_binary_invocable_v<std::equal_to<>, T *, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<T>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(const E& executor, R&& r, T 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 T>
        requires(
            // clang-format off
                traits::is_input_iterator_v<I> &&
                traits::is_sentinel_for_v<S, I> &&
                traits::is_indirectly_binary_invocable_v<std::equal_to<>, T *, I>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(I first, S last, T 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(), make_default_partitioner(first, last), first, last, std::move(f));
            }
        }
 
        template<class R, class T>
        requires(
            // clang-format off
                traits::is_input_range_v<R> &&
                traits::is_indirectly_binary_invocable_v<std::equal_to<>, T *, traits::iterator_t<R>> &&
                std::is_copy_constructible_v<T>
            // clang-format on
            ) constexpr decltype(auto)
            operator()(R&& r, T f) const {
            if(std::is_constant_evaluated()) {
                return Derived().run(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
            } else {
                return Derived().run(make_default_executor(), make_default_partitioner(r), std::begin(r), std::end(r), std::move(f));
            }
        }
    };
 
} // namespace CeresEngine