thread_concepts.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <type_traits>
#include <functional>
#include <chrono>
#include <string>
 
#ifdef USE_STD_CONCEPTS
#include <concepts>
#endif
 
namespace kcenon::thread::concepts {
 
// ============================================================================
// Type Traits (always available)
// ============================================================================
 
template<typename T>
struct is_duration : std::false_type {};
 
template<typename Rep, typename Period>
struct is_duration<std::chrono::duration<Rep, Period>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_duration_v = is_duration<T>::value;
 
template<typename T, typename = void>
struct has_get_method : std::false_type {};
 
template<typename T>
struct has_get_method<T, std::void_t<decltype(std::declval<T>().get())>>
    : std::true_type {};
 
template<typename T>
inline constexpr bool has_get_method_v = has_get_method<T>::value;
 
template<typename T, typename = void>
struct has_wait_method : std::false_type {};
 
template<typename T>
struct has_wait_method<T, std::void_t<decltype(std::declval<T>().wait())>>
    : std::true_type {};
 
template<typename T>
inline constexpr bool has_wait_method_v = has_wait_method<T>::value;
 
template<typename T>
struct is_future_like : std::bool_constant<has_get_method_v<T> && has_wait_method_v<T>> {};
 
template<typename T>
inline constexpr bool is_future_like_v = is_future_like<T>::value;
 
template<typename F, typename = void>
struct callable_return_type {
    using type = void;
};
 
template<typename F>
struct callable_return_type<F, std::enable_if_t<std::is_invocable_v<F>>> {
    using type = std::invoke_result_t<F>;
};
 
template<typename F>
using callable_return_type_t = typename callable_return_type<F>::type;
 
// ============================================================================
// C++20 Concepts (when USE_STD_CONCEPTS is defined)
// ============================================================================
 
#ifdef USE_STD_CONCEPTS
 
template<typename F>
concept Callable = std::is_invocable_v<F>;
 
template<typename F>
concept VoidCallable = Callable<F> && std::is_void_v<std::invoke_result_t<F>>;
 
template<typename F>
concept ReturningCallable = Callable<F> && !std::is_void_v<std::invoke_result_t<F>>;
 
template<typename F, typename... Args>
concept CallableWith = std::is_invocable_v<F, Args...>;
 
template<typename T>
concept Duration = is_duration_v<T>;
 
template<typename T>
concept FutureLike = is_future_like_v<T>;
 
template<typename T>
concept JobType = std::is_enum_v<T> ||
                  (std::is_integral_v<T> && !std::is_same_v<T, bool>);
 
template<typename F>
concept JobCallable = std::is_invocable_v<F> &&
                      (std::is_void_v<std::invoke_result_t<F>> ||
                       std::is_same_v<std::invoke_result_t<F>, bool> ||
                       std::is_convertible_v<std::invoke_result_t<F>, std::string>);
 
template<typename Job>
concept PoolJob = Callable<Job> &&
                  (VoidCallable<Job> ||
                   std::is_convertible_v<callable_return_type_t<Job>, bool>);
 
#else
// ============================================================================
// C++17 Fallback (constexpr bool instead of concepts)
// ============================================================================
 
template<typename F>
inline constexpr bool Callable = std::is_invocable_v<F>;
 
template<typename F>
inline constexpr bool VoidCallable = std::is_invocable_v<F> &&
                                     std::is_void_v<std::invoke_result_t<F>>;
 
template<typename F>
inline constexpr bool ReturningCallable = std::is_invocable_v<F> &&
                                          !std::is_void_v<std::invoke_result_t<F>>;
 
template<typename F, typename... Args>
inline constexpr bool CallableWith = std::is_invocable_v<F, Args...>;
 
template<typename T>
inline constexpr bool Duration = is_duration_v<T>;
 
template<typename T>
inline constexpr bool FutureLike = is_future_like_v<T>;
 
template<typename T>
inline constexpr bool JobType = std::is_enum_v<T> ||
                                (std::is_integral_v<T> && !std::is_same_v<T, bool>);
 
template<typename F>
inline constexpr bool JobCallable = std::is_invocable_v<F> &&
                                    (std::is_void_v<std::invoke_result_t<F>> ||
                                     std::is_same_v<std::invoke_result_t<F>, bool> ||
                                     std::is_convertible_v<std::invoke_result_t<F>, std::string>);
 
template<typename Job>
inline constexpr bool PoolJob = Callable<Job> &&
                                (VoidCallable<Job> ||
                                 std::is_convertible_v<callable_return_type_t<Job>, bool>);
 
#endif // USE_STD_CONCEPTS
 
// ============================================================================
// Concept Validation Helpers
// ============================================================================
 
template<typename T, typename = void>
struct is_valid_job_type : std::false_type {};
 
template<typename T>
struct is_valid_job_type<T, std::enable_if_t<JobType<T>>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_valid_job_type_v = is_valid_job_type<T>::value;
 
template<typename F>
struct is_nothrow_callable : std::bool_constant<std::is_nothrow_invocable_v<F>> {};
 
template<typename F>
inline constexpr bool is_nothrow_callable_v = is_nothrow_callable<F>::value;
 
} // namespace kcenon::thread::concepts
 
// ============================================================================
// Backward Compatibility: Re-export to detail namespace
// ============================================================================
 
namespace kcenon::thread::detail {
 
using kcenon::thread::concepts::is_duration;
using kcenon::thread::concepts::is_duration_v;
using kcenon::thread::concepts::is_future_like;
using kcenon::thread::concepts::is_future_like_v;
using kcenon::thread::concepts::callable_return_type;
using kcenon::thread::concepts::callable_return_type_t;
using kcenon::thread::concepts::is_valid_job_type;
using kcenon::thread::concepts::is_valid_job_type_v;
using kcenon::thread::concepts::is_nothrow_callable;
using kcenon::thread::concepts::is_nothrow_callable_v;
 
#ifdef USE_STD_CONCEPTS
using kcenon::thread::concepts::Callable;
using kcenon::thread::concepts::VoidCallable;
using kcenon::thread::concepts::ReturningCallable;
using kcenon::thread::concepts::CallableWith;
using kcenon::thread::concepts::Duration;
using kcenon::thread::concepts::FutureLike;
using kcenon::thread::concepts::JobType;
using kcenon::thread::concepts::JobCallable;
using kcenon::thread::concepts::PoolJob;
#else
// For C++17 fallback, we need to use inline constexpr
template<typename F>
inline constexpr bool Callable = concepts::Callable<F>;
 
template<typename F>
inline constexpr bool VoidCallable = concepts::VoidCallable<F>;
 
template<typename F>
inline constexpr bool ReturningCallable = concepts::ReturningCallable<F>;
 
template<typename F, typename... Args>
inline constexpr bool CallableWith = concepts::CallableWith<F, Args...>;
 
template<typename T>
inline constexpr bool Duration = concepts::Duration<T>;
 
template<typename T>
inline constexpr bool FutureLike = concepts::FutureLike<T>;
 
template<typename T>
inline constexpr bool JobType = concepts::JobType<T>;
 
template<typename F>
inline constexpr bool JobCallable = concepts::JobCallable<F>;
 
template<typename Job>
inline constexpr bool PoolJob = concepts::PoolJob<Job>;
#endif
 
} // namespace kcenon::thread::detail