service.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 <memory>
#include <functional>
 
namespace kcenon::common {
 
// Forward declarations
namespace di {
class IServiceContainer;
}
 
namespace concepts {
 
template<typename T>
concept ServiceInterface = std::is_polymorphic_v<T> &&
    std::has_virtual_destructor_v<T>;
 
template<typename TImpl, typename TInterface>
concept ServiceImplementation =
    ServiceInterface<TInterface> &&
    std::is_base_of_v<TInterface, TImpl> &&
    std::is_default_constructible_v<TImpl>;
 
template<typename F, typename T>
concept ServiceFactory = std::invocable<F, di::IServiceContainer&> &&
    std::convertible_to<std::invoke_result_t<F, di::IServiceContainer&>,
                        std::shared_ptr<T>>;
 
template<typename F, typename T>
concept SimpleServiceFactory = std::invocable<F> &&
    std::convertible_to<std::invoke_result_t<F>, std::shared_ptr<T>>;
 
template<typename T>
concept ServiceContainerLike = requires(T t) {
    { t.create_scope() };
    { t.registered_services() };
    { t.clear() };
};
 
template<typename T>
concept ServiceScopeLike = ServiceContainerLike<T> && requires(T t) {
    { t.parent() };
};
 
template<typename T>
concept InjectableService = std::is_class_v<T> &&
    std::is_default_constructible_v<T>;
 
template<typename T>
concept SharedService = std::is_class_v<T> &&
    requires { typename std::shared_ptr<T>; };
 
template<typename T>
concept ConfigSection =
    std::is_default_constructible_v<T> &&
    std::is_copy_constructible_v<T>;
 
template<typename T>
concept Validatable = requires(const T t) {
    { t.validate() };
};
 
template<typename T>
concept ServiceWithDependencies = requires {
    typename T::dependencies;
};
 
template<typename T>
concept InitializableService = requires(T t) {
    { t.initialize() };
};
 
template<typename T>
concept DisposableService = requires(T t) {
    { t.dispose() } -> std::same_as<void>;
};
 
template<typename T>
concept ModuleRegistrar = requires(T registrar, di::IServiceContainer& container) {
    { T::module_name() } -> std::convertible_to<std::string_view>;
    { registrar.register_services(container) };
};
 
} // namespace concepts
} // namespace kcenon::common