lib

Author: anioutkazharkova

.idea/artifacts/di_multiplatform_lib_jvm_1_0_4.xml

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "com.azharkova"
-version = "1.0.3"
+version = "1.0.4.5"
 
 repositories {
     jcenter()

.idea/gradle.xml

@@ -0,0 +1,51 @@
+package com.azharkova.di.container
+
+import com.azharkova.di.resolver.Resolver
+import com.azharkova.di.scope.ScopeType
+import com.azharkova.di.util.createType
+import kotlin.native.concurrent.ThreadLocal
+import kotlin.reflect.KClass
+
+public interface ContainerProtocol {
+   fun <T : Any> register(type: String?, scope: ScopeType = ScopeType.Graph, fabric: () -> T?)
+
+  fun <T : Any> resolve(type: String?): T?
+}
+
+public class DIContainer : ContainerProtocol {
+    @ThreadLocal
+    public companion object {
+        val Factory = DIContainer()
+    }
+
+    val resolver = Resolver()
+
+    public fun <T : Any> register(clazz: KClass<T>, scope: ScopeType = ScopeType.Graph, fabric: () -> T?) {
+        resolver.register(clazz,scope,fabric)
+    }
+
+    public fun <T : Any> resolve(clazz: KClass<T>): T? {
+        return resolver.resolve(clazz)
+    }
+
+   public override fun <T : Any> resolve(type: String?): T? {
+       if (type != null) {
+           val clazz = createType<T>(type)
+           if (clazz != null) {
+               return resolver.resolve(clazz)
+           }
+       }
+        return null
+    }
+
+ public   override fun <T : Any> register(type: String?, scope: ScopeType, fabric: () -> T?) {
+     if (type != null) {
+         val clazz = createType<T>(type)
+         if (clazz != null) {
+             resolver.register(clazz, scope, fabric)
+         }
+     }
+ }
+}
+
+public inline fun <reified T:Any> resolved(container: DIContainer = DIContainer.Factory) = container.resolve(T::class)

build.gradle.kts

@@ -1,7 +1,8 @@
 package com.azharkova.di.init
 
+import com.azharkova.di.container.ContainerProtocol
 import com.azharkova.di.container.DIContainer
 
-class ConfiguratorApp {
-    val appDIContainer: DIContainer by lazy { DIContainer() }
+public class ConfiguratorApp {
+    public val appDIContainer: DIContainer by lazy { DIContainer() }
 }

src/commonMain/kotlin/com/azharkova/di/container/DIContainer.kt

@@ -21,4 +21,4 @@ class SingletonValue<T:Any>(private val clazz: KClass<T>,
     }
 }
 
-inline fun <reified T:Any> single(container: DIContainer = DIContainer.Factory, noinline fabric: () -> T?) = CachedValue(T::class,container,fabric)
+public inline fun <reified T:Any> single(container: DIContainer = DIContainer.Factory, noinline fabric: () -> T?) = CachedValue(T::class,container,fabric)

src/commonMain/kotlin/com/azharkova/di/init/ConfiguratorApp.kt

@@ -0,0 +1,5 @@
+package com.azharkova.di.util
+
+import kotlin.reflect.KClass
+
+public expect fun<T: Any> createType(type: String): KClass<T>?

src/commonMain/kotlin/com/azharkova/di/memory/reference/singleton/SingletonValue.kt

@@ -0,0 +1,26 @@
+package com.azharkova.di.util
+
+import com.azharkova.di.container.DIContainer
+import com.azharkova.di.scope.ScopeType
+import kotlinx.cinterop.ObjCClass
+import kotlinx.cinterop.getOriginalKotlinClass
+import kotlin.reflect.KClass
+
+fun<T: Any> DIContainer.createType(type: ObjCClass): KClass<T>? {
+    return getOriginalKotlinClass(type) as? KClass<T>
+}
+
+fun<T: Any> DIContainer.register(type: ObjCClass, scope: ScopeType, fabric: () -> T?) {
+    val clazz = createType<T>(type)
+    if (clazz != null) {
+        resolver.register(clazz,scope,fabric)
+    }
+}
+
+fun <T : Any> DIContainer.resolve(type: ObjCClass): T? {
+    val clazz = createType<T>(type)
+    if (clazz != null) {
+        return resolver.resolve(clazz)
+    }
+    return null
+}

src/commonMain/kotlin/com/azharkova/di/util/TypeCreator.kt

@@ -0,0 +1,16 @@
+package com.azharkova.di.util
+
+import platform.objc.objc_sync_enter
+import platform.objc.objc_sync_exit
+
+
+actual inline fun <R> trySynchronized(lock: Any?, block: () -> R): R {
+    if (lock != null) {
+        objc_sync_enter(lock)
+        val result = block()
+        objc_sync_exit(lock)
+        return result
+    } else {
+        return block()
+    }
+}