(vision) SCS/DDD

shared/src/commonMain/kotlin/at/mocode/di/ServiceLocator.kt

@@ -0,0 +1,119 @@
+package at.mocode.di
+
+import kotlin.reflect.KClass
+
+/**
+ * Service Locator interface for dependency injection.
+ * Provides a centralized way to register and resolve dependencies across the application.
+ */
+interface ServiceLocator {
+
+    /**
+     * Register a service instance with the locator
+     */
+    fun <T : Any> register(serviceClass: KClass<T>, instance: T)
+
+    /**
+     * Register a service factory with the locator
+     */
+    fun <T : Any> register(serviceClass: KClass<T>, factory: () -> T)
+
+    /**
+     * Resolve a service instance from the locator
+     */
+    fun <T : Any> resolve(serviceClass: KClass<T>): T
+
+    /**
+     * Check if a service is registered
+     */
+    fun <T : Any> isRegistered(serviceClass: KClass<T>): Boolean
+
+    /**
+     * Clear all registered services
+     */
+    fun clear()
+}
+
+/**
+ * Default implementation of ServiceLocator
+ */
+class DefaultServiceLocator : ServiceLocator {
+
+    private val instances = mutableMapOf<KClass<*>, Any>()
+    private val factories = mutableMapOf<KClass<*>, () -> Any>()
+
+    override fun <T : Any> register(serviceClass: KClass<T>, instance: T) {
+        instances[serviceClass] = instance
+        factories.remove(serviceClass) // Remove factory if exists
+    }
+
+    override fun <T : Any> register(serviceClass: KClass<T>, factory: () -> T) {
+        factories[serviceClass] = factory
+        instances.remove(serviceClass) // Remove instance if exists
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Any> resolve(serviceClass: KClass<T>): T {
+        // First check if we have a cached instance
+        instances[serviceClass]?.let { return it as T }
+
+        // Then check if we have a factory
+        factories[serviceClass]?.let { factory ->
+            val instance = factory() as T
+            instances[serviceClass] = instance // Cache the instance
+            return instance
+        }
+
+        throw IllegalArgumentException("Service ${serviceClass.simpleName} is not registered")
+    }
+
+    override fun <T : Any> isRegistered(serviceClass: KClass<T>): Boolean {
+        return instances.containsKey(serviceClass) || factories.containsKey(serviceClass)
+    }
+
+    override fun clear() {
+        instances.clear()
+        factories.clear()
+    }
+}
+
+/**
+ * Global service locator instance
+ */
+object ServiceRegistry {
+    private var _serviceLocator: ServiceLocator = DefaultServiceLocator()
+
+    val serviceLocator: ServiceLocator
+        get() = _serviceLocator
+
+    /**
+     * Set a custom service locator implementation
+     */
+    fun setServiceLocator(locator: ServiceLocator) {
+        _serviceLocator = locator
+    }
+
+    /**
+     * Reset to default service locator
+     */
+    fun reset() {
+        _serviceLocator = DefaultServiceLocator()
+    }
+}
+
+// Kotlin extension functions for easier usage
+inline fun <reified T : Any> ServiceLocator.register(instance: T) {
+    register(T::class, instance)
+}
+
+inline fun <reified T : Any> ServiceLocator.register(noinline factory: () -> T) {
+    register(T::class, factory)
+}
+
+inline fun <reified T : Any> ServiceLocator.resolve(): T {
+    return resolve(T::class)
+}
+
+inline fun <reified T : Any> ServiceLocator.isRegistered(): Boolean {
+    return isRegistered(T::class)
+}