fix(model-datastructure): cache entries acquired through get PrefetchCache.getAll

Cache entries when using `getAll` like they are cached when using get `get`.
This guarantees that after accessing the values once no requests are required.

Author: Oleksandr Dzhychko

model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/AccessTrackingStore.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2024.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modelix.model.lazy
+
+import org.modelix.model.IKeyListener
+import org.modelix.model.IKeyValueStore
+
+/**
+ * Internal API.
+ * Only public for tests.
+ */
+class AccessTrackingStore(val store: IKeyValueStore) : IKeyValueStore {
+    val accessedEntries: MutableMap<String, String?> = LinkedHashMap()
+
+    override fun newBulkQuery(deserializingCache: IDeserializingKeyValueStore, config: BulkQueryConfiguration): IBulkQuery {
+        return store.newBulkQuery(deserializingCache, config)
+    }
+
+    override fun get(key: String): String? {
+        val value = store.get(key)
+        accessedEntries.put(key, value)
+        return value
+    }
+
+    override fun getIfCached(key: String): String? {
+        val value = store.getIfCached(key)
+        if (value != null) {
+            accessedEntries[key] = value
+        }
+        return value
+    }
+
+    override fun put(key: String, value: String?) {
+        TODO("Not yet implemented")
+    }
+
+    override fun getAll(keys: Iterable<String>): Map<String, String?> {
+        val entries = store.getAll(keys)
+        accessedEntries.putAll(entries)
+        return entries
+    }
+
+    override fun putAll(entries: Map<String, String?>) {
+        TODO("Not yet implemented")
+    }
+
+    override fun prefetch(key: String) {
+        TODO("Not yet implemented")
+    }
+
+    override fun listen(key: String, listener: IKeyListener) {
+        TODO("Not yet implemented")
+    }
+
+    override fun removeListener(key: String, listener: IKeyListener) {
+        TODO("Not yet implemented")
+    }
+
+    override fun getPendingSize(): Int {
+        TODO("Not yet implemented")
+    }
+}

model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLVersion.kt

@@ -19,7 +19,6 @@ import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toInstant
-import org.modelix.model.IKeyListener
 import org.modelix.model.IKeyValueStore
 import org.modelix.model.IVersion
 import org.modelix.model.LinearHistory
@@ -403,58 +402,6 @@ private fun trackAccessedEntries(store: IKeyValueStore, body: (IDeserializingKey
     return accessTrackingStore.accessedEntries
 }
 
-private class AccessTrackingStore(val store: IKeyValueStore) : IKeyValueStore {
-    val accessedEntries: MutableMap<String, String?> = LinkedHashMap()
-
-    override fun newBulkQuery(deserializingCache: IDeserializingKeyValueStore, config: BulkQueryConfiguration): IBulkQuery {
-        return store.newBulkQuery(deserializingCache, config)
-    }
-
-    override fun get(key: String): String? {
-        val value = store.get(key)
-        accessedEntries.put(key, value)
-        return value
-    }
-
-    override fun getIfCached(key: String): String? {
-        val value = store.getIfCached(key)
-        if (value != null) {
-            accessedEntries[key] = value
-        }
-        return value
-    }
-
-    override fun put(key: String, value: String?) {
-        TODO("Not yet implemented")
-    }
-
-    override fun getAll(keys: Iterable<String>): Map<String, String?> {
-        val entries = store.getAll(keys)
-        accessedEntries.putAll(entries)
-        return entries
-    }
-
-    override fun putAll(entries: Map<String, String?>) {
-        TODO("Not yet implemented")
-    }
-
-    override fun prefetch(key: String) {
-        TODO("Not yet implemented")
-    }
-
-    override fun listen(key: String, listener: IKeyListener) {
-        TODO("Not yet implemented")
-    }
-
-    override fun removeListener(key: String, listener: IKeyListener) {
-        TODO("Not yet implemented")
-    }
-
-    override fun getPendingSize(): Int {
-        TODO("Not yet implemented")
-    }
-}
-
 fun CLVersion.runWrite(idGenerator: IIdGenerator, author: String?, body: (IWriteTransaction) -> Unit): CLVersion {
     val branch = OTBranch(TreePointer(getTree(), idGenerator), idGenerator, store)
     branch.computeWriteT(body)

model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/PrefetchCache.kt

@@ -55,7 +55,8 @@ class PrefetchCache(private val store: IDeserializingKeyValueStore) : IDeseriali
         val missingHashes = hashes.filterNot { entries.containsKey(it) }
         val missingValues = store.getAll(missingHashes, deserializer).toList()
         val missingEntries = missingHashes.mapIndexed { index, hash -> hash to missingValues[index] }.associate { it }
-        return hashes.map { missingEntries[it] ?: entries[it] as T }
+        entries.putAll(missingEntries)
+        return hashes.map { entries[it] as T }
     }
 
     override fun put(hash: String, deserialized: Any, serialized: String) {

model-datastructure/src/commonTest/kotlin/org/modelix/model/lazy/PrefetchCacheTest.kt

@@ -0,0 +1,27 @@
+import org.modelix.model.lazy.AccessTrackingStore
+import org.modelix.model.lazy.NonCachingObjectStore
+import org.modelix.model.lazy.PrefetchCache
+import org.modelix.model.persistent.MapBasedStore
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class PrefetchCacheTest {
+
+    private val keyValueStore = MapBasedStore()
+    private val accessTrackingKeyValueStore = AccessTrackingStore(keyValueStore)
+    private val deserializingKeyValueStore = NonCachingObjectStore(accessTrackingKeyValueStore)
+    private val prefetchCache = PrefetchCache(deserializingKeyValueStore)
+
+    @Test
+    fun entriesAreCachedAfterGettingMultipleEntriesAsIterable() {
+        keyValueStore.put("key", "value")
+        prefetchCache.getAll(listOf("key")) { _, value -> value }
+        accessTrackingKeyValueStore.accessedEntries.clear()
+
+        val result = prefetchCache.getAll(listOf("key")) { _, value -> value }
+
+        assertEquals(result, listOf("value"))
+        assertTrue(accessTrackingKeyValueStore.accessedEntries.isEmpty())
+    }
+}