callable.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <concepts>
#include <type_traits>
#include <functional>
#include <string>
#include <future>
#include <memory>
#include <chrono>
 
#include "../patterns/result/core.h"
 
namespace kcenon::common {
 
// Forward declarations
namespace interfaces {
class IJob;
}
 
namespace concepts {
 
template<typename F, typename... Args>
concept Invocable = std::invocable<F, Args...>;
 
template<typename F, typename... Args>
concept VoidCallable = Invocable<F, Args...> &&
    std::is_void_v<std::invoke_result_t<F, Args...>>;
 
template<typename F, typename R, typename... Args>
concept ReturnsResult = Invocable<F, Args...> &&
    std::convertible_to<std::invoke_result_t<F, Args...>, R>;
 
template<typename F, typename... Args>
concept NoexceptCallable = Invocable<F, Args...> &&
    std::is_nothrow_invocable_v<F, Args...>;
 
template<typename F, typename... Args>
concept Predicate = Invocable<F, Args...> &&
    std::convertible_to<std::invoke_result_t<F, Args...>, bool>;
 
template<typename F, typename Arg>
concept UnaryFunction = Invocable<F, Arg>;
 
template<typename F, typename Arg1, typename Arg2>
concept BinaryFunction = Invocable<F, Arg1, Arg2>;
 
template<typename T>
concept JobLike = requires(T t) {
    { t.execute() };
    { t.get_name() } -> std::convertible_to<std::string>;
    { t.get_priority() } -> std::convertible_to<int>;
};
 
template<typename T>
concept ExecutorLike = requires(T t, std::unique_ptr<interfaces::IJob> job, bool wait) {
    { t.worker_count() } -> std::convertible_to<size_t>;
    { t.is_running() } -> std::convertible_to<bool>;
    { t.pending_tasks() } -> std::convertible_to<size_t>;
    { t.shutdown(wait) } -> std::same_as<void>;
};
 
template<typename F, typename T>
concept TaskFactory = Invocable<F> &&
    std::convertible_to<std::invoke_result_t<F>, std::unique_ptr<T>>;
 
template<typename F, typename R>
concept AsyncCallable = Invocable<F> &&
    std::same_as<std::invoke_result_t<F>, R>;
 
template<typename F>
concept DelayedCallable = VoidCallable<F> &&
    std::move_constructible<std::decay_t<F>>;
 
} // namespace concepts
} // namespace kcenon::common