concepts.cppm

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.
 
module;
 
#include <chrono>
#include <concepts>
#include <functional>
#include <future>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
export module kcenon.common:concepts;
 
// Forward declarations for interface types
namespace kcenon::common::interfaces {
class IJob;
}
 
export namespace kcenon::common::concepts {
 
// ============================================================================
// Core Concepts (Result/Optional)
// ============================================================================
 
template<typename T>
concept Resultable = requires(const T t) {
    { t.is_ok() } -> std::convertible_to<bool>;
    { t.is_err() } -> std::convertible_to<bool>;
};
 
template<typename T>
concept Unwrappable = requires(T t) {
    typename T::value_type;
    { t.unwrap() } -> std::same_as<typename std::add_lvalue_reference<
        typename std::add_const<typename T::value_type>::type>::type>;
    { t.unwrap_or(std::declval<typename T::value_type>()) }
        -> std::convertible_to<typename T::value_type>;
};
 
template<typename T>
concept Mappable = requires(const T t) {
    { t.map(std::declval<std::function<int(typename T::value_type)>>()) };
};
 
template<typename T>
concept Chainable = requires(const T t) {
    { t.and_then(std::declval<std::function<T(typename T::value_type)>>()) };
};
 
template<typename T>
concept MonadicResult = Resultable<T> && Mappable<T> && Chainable<T>;
 
template<typename T>
concept OptionalLike = requires(const T t) {
    { t.has_value() } -> std::convertible_to<bool>;
    { t.is_some() } -> std::convertible_to<bool>;
    { t.is_none() } -> std::convertible_to<bool>;
};
 
template<typename T>
concept ErrorInfo = requires(const T t) {
    { t.code } -> std::convertible_to<int>;
    { t.message } -> std::convertible_to<std::string>;
    { t.module } -> std::convertible_to<std::string>;
};
 
template<typename T>
concept ValueOrError = Resultable<T> && requires(const T t) {
    { t.value() };
    { t.error() };
};
 
// ============================================================================
// Callable 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>>;
 
// ============================================================================
// Event Concepts
// ============================================================================
 
template<typename T>
concept EventType = std::is_class_v<T> &&
    std::is_copy_constructible_v<T>;
 
template<typename H, typename E>
concept EventHandler = std::invocable<H, const E&> &&
    std::is_void_v<std::invoke_result_t<H, const E&>>;
 
template<typename F, typename E>
concept EventFilter = std::invocable<F, const E&> &&
    std::convertible_to<std::invoke_result_t<F, const E&>, bool>;
 
template<typename T>
concept TimestampedEvent = EventType<T> && requires(const T t) {
    { t.timestamp } -> std::convertible_to<std::chrono::steady_clock::time_point>;
};
 
template<typename T>
concept NamedEvent = EventType<T> && requires(const T t) {
    { t.module_name } -> std::convertible_to<std::string>;
};
 
template<typename T>
concept ErrorEvent = EventType<T> && requires(const T t) {
    { t.error_message } -> std::convertible_to<std::string>;
    { t.error_code } -> std::convertible_to<int>;
};
 
template<typename T>
concept MetricEvent = EventType<T> && requires(const T t) {
    { t.name } -> std::convertible_to<std::string>;
    { t.value } -> std::convertible_to<double>;
    { t.unit } -> std::convertible_to<std::string>;
};
 
template<typename T>
concept ModuleLifecycleEvent = NamedEvent<T> && TimestampedEvent<T>;
 
template<typename T>
concept FullErrorEvent = ErrorEvent<T> && NamedEvent<T> && TimestampedEvent<T>;
 
template<typename T>
concept FullMetricEvent = MetricEvent<T> && TimestampedEvent<T>;
 
template<typename T>
concept EventBusLike = requires(T t, uint64_t id) {
    { t.start() } -> std::same_as<void>;
    { t.stop() } -> std::same_as<void>;
    { t.is_running() } -> std::convertible_to<bool>;
    { t.unsubscribe(id) } -> std::same_as<void>;
};
 
// ============================================================================
// Service Concepts (DI)
// ============================================================================
 
template<typename T>
concept ServiceInterface = std::is_class_v<T> && std::has_virtual_destructor_v<T>;
 
template<typename Impl, typename Interface>
concept ServiceImplementation = std::derived_from<Impl, Interface> &&
    std::is_constructible_v<Impl>;
 
template<typename F, typename T>
concept ServiceFactory = Invocable<F> &&
    std::convertible_to<std::invoke_result_t<F>, std::shared_ptr<T>>;
 
template<typename T>
concept Validatable = requires(const T t) {
    { t.validate() } -> std::convertible_to<bool>;
};
 
// ============================================================================
// Container Concepts
// ============================================================================
 
template<typename T>
concept Container = requires(T t) {
    typename T::value_type;
    typename T::size_type;
    { t.size() } -> std::convertible_to<typename T::size_type>;
    { t.empty() } -> std::convertible_to<bool>;
    { t.begin() };
    { t.end() };
};
 
template<typename T>
concept SequenceContainer = Container<T> && requires(T t, typename T::value_type v) {
    { t.push_back(v) };
    { t.front() } -> std::same_as<typename T::value_type&>;
    { t.back() } -> std::same_as<typename T::value_type&>;
};
 
template<typename T>
concept ResizableContainer = Container<T> && requires(T t, typename T::size_type n) {
    { t.resize(n) };
    { t.reserve(n) };
    { t.capacity() } -> std::convertible_to<typename T::size_type>;
};
 
// ============================================================================
// Logger Concepts
// ============================================================================
 
template<typename T>
concept BasicLogger = requires(T t, const std::string& msg) {
    { t.log(msg) };
};
 
template<typename T>
concept FlushableLogger = BasicLogger<T> && requires(T t) {
    { t.flush() };
};
 
// ============================================================================
// Monitoring Concepts
// ============================================================================
 
template<typename T>
concept CounterMetric = requires(T t, const std::string& name, int64_t val) {
    { t.increment(name) };
    { t.increment(name, val) };
};
 
template<typename T>
concept GaugeMetric = requires(T t, const std::string& name, double val) {
    { t.set_gauge(name, val) };
};
 
template<typename T>
concept HistogramMetric = requires(T t, const std::string& name, double val) {
    { t.observe(name, val) };
};
 
// ============================================================================
// Transport Concepts
// ============================================================================
 
template<typename T>
concept Sendable = requires(T t, const std::string& data) {
    { t.send(data) };
};
 
template<typename T>
concept Receivable = requires(T t) {
    { t.receive() } -> std::convertible_to<std::string>;
};
 
template<typename T>
concept TransportClient = Sendable<T> && Receivable<T>;
 
} // namespace kcenon::common::concepts