change the get function signature

Author: lightsing

src/main/kotlin/com/moumoux/quinine/Quinine.kt

@@ -4,6 +4,8 @@ import com.github.benmanes.caffeine.cache.Caffeine
 import com.moumoux.quinine.impl.QuinineLocalCache
 import com.moumoux.quinine.impl.QuinineLocalLoadingCache
 import io.reactivex.Single
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 
 import com.moumoux.quinine.reactive.QuinineCache as rxQuinineCache
 import com.moumoux.quinine.reactive.QuinineLoadingCache as rxQuinineLoadingCache
@@ -72,9 +74,11 @@ class Quinine<K: Any, V> private constructor() {
      *
      * @return [QuinineLoadingCache] instance
      */
-    fun <K1 : K, V1 : V?> build(mappingFunction: (K1) -> V1): QuinineLoadingCache<K1, V1> {
+    fun <K1 : K, V1 : V?> build(mappingFunction: suspend (K1) -> V1): QuinineLoadingCache<K1, V1> {
         return QuinineLocalLoadingCache(caffeine.build {
-            Single.create { emitter -> emitter.onSuccess(mappingFunction(it)) }
+            Single.create<V1> { emitter ->
+                GlobalScope.launch { emitter.onSuccess(mappingFunction(it)) }
+            }.cache()
         })
     }
 

src/main/kotlin/com/moumoux/quinine/QuinineCache.kt

@@ -98,7 +98,7 @@ interface QuinineCache<K : Any, V> {
      * @throws RuntimeException or Error if the mappingFunction does so, in which case the mapping is
      *         left unestablished
      */
-    suspend fun get(key: K, mappingFunction: (K) -> V): V
+    suspend fun get(key: K, mappingFunction: suspend (K) -> V): V
 
     /**
      * Returns the value associated with the [key] in this cache, or <pre>null</pre> if there is no

src/main/kotlin/com/moumoux/quinine/impl/QuinineLocalCache.kt

@@ -4,12 +4,13 @@ import com.github.benmanes.caffeine.cache.Cache
 import com.moumoux.quinine.QuinineCache
 import com.moumoux.quinine.QuinineCacheStats
 import io.reactivex.Single
+import kotlinx.coroutines.*
 import kotlinx.coroutines.rx2.await
-import java.util.concurrent.Executors
+import kotlin.coroutines.CoroutineContext
 
 internal open class QuinineLocalCache<K : Any, V>(private val cache: Cache<K, Single<V>>) :
-    QuinineCache<K, V> {
-    private val loaderExecutor = Executors.newSingleThreadExecutor()
+    QuinineCache<K, V>, CoroutineScope {
+    override val coroutineContext: CoroutineContext = Dispatchers.IO
 
     override val estimatedSize: Long
         get() = cache.estimatedSize()
@@ -27,12 +28,14 @@ internal open class QuinineLocalCache<K : Any, V>(private val cache: Cache<K, Si
         map.forEach { (k, u) -> cache.put(k, Single.just(u).cache()) }
     }
 
-    override suspend fun get(key: K, mappingFunction: (K) -> V): V {
-        return cache.get(key) {
-            Single.create<V> { emitter ->
-                loaderExecutor.execute { emitter.onSuccess(mappingFunction(it)) }
-            }.cache()
-        }!!.await()
+    override suspend fun get(key: K, mappingFunction: suspend (K) -> V): V {
+        return coroutineScope {
+            cache.get(key) {
+                Single.create<V> { emitter ->
+                    launch { emitter.onSuccess(mappingFunction(it)) }
+                }.cache()
+            }!!.await()
+        }
     }
 
     override suspend fun getIfPresent(key: K): V? = cache.getIfPresent(key)?.await()