use cache4k as LruCache backing that is thread safe. fixes #75

gradle/libs.versions.toml

@@ -11,6 +11,7 @@ com-android-application = { id = "com.android.application", version.ref = "agp"
 
 [versions]
 
+cache4k = "0.12.0"
 kotlin = "1.9.21"
 agp = "8.1.4"
 
@@ -30,7 +31,7 @@ batik = "1.17"
 
 [libraries]
 
-androidx-startup = { module = "androidx.startup:startup-runtime", version.ref = "startup-runtime" }
+cache4k = { module = "io.github.reactivecircus.cache4k:cache4k", version.ref = "cache4k" }
 okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
 okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okio" }
 
@@ -51,6 +52,7 @@ dev-icerock-moko-resources-test = { module = "dev.icerock.moko:resources-test",
 
 pdvrieze-xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", version.ref = "xmlutil" }
 
+androidx-startup = { module = "androidx.startup:startup-runtime", version.ref = "startup-runtime" }
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activity-compose" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
 google-android-material = { module = "com.google.android.material:material", version.ref = "material" }

kamel-core/build.gradle.kts

@@ -66,6 +66,7 @@ kotlin {
                 implementation(libs.kotlinx.coroutines.core)
                 implementation(libs.ktor.client.core)
                 implementation(libs.okio)
+                implementation(libs.cache4k)
             }
         }
 

kamel-core/src/commonMain/kotlin/io/kamel/core/cache/LruCache.kt

@@ -3,4 +3,28 @@ package io.kamel.core.cache
 /**
  * Cache implementation which evicts items using an LRU algorithm.
  */
-internal expect class LruCache<K, V>(maxSize: Int) : Cache<K, V>
+internal class LruCache<K : Any, V : Any>(override val maxSize: Int) : Cache<K, V> {
+
+    private val cache: io.github.reactivecircus.cache4k.Cache<K, V> =
+        io.github.reactivecircus.cache4k.Cache.Builder<K, V>()
+            .maximumCacheSize(maxSize.toLong())
+            .build()
+
+    override val size: Int
+        get() = cache.asMap().size
+
+    init {
+        require(maxSize >= 0) { "Cache max size must be positive number" }
+    }
+
+    override fun get(key: K): V? = cache.get(key)
+
+    override fun set(key: K, value: V) = cache.put(key, value)
+
+    override fun remove(key: K): Boolean {
+        cache.invalidate(key)
+        return true
+    }
+
+    override fun clear(): Unit = cache.invalidateAll()
+}