fix(model-datastructure): implement PrefetchCache.getAll with prefetch support

Not implementing the method caused unsupported operations exceptions in existing projects.

Author: Oleksandr Dzhychko

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

@@ -16,6 +16,7 @@ package org.modelix.model.lazy
 import org.modelix.kotlin.utils.ContextValue
 import org.modelix.model.IKeyValueStore
 import org.modelix.model.api.ITree
+import org.modelix.model.persistent.IKVValue
 
 /**
  * There is no size limit. Entries are not evicted.
@@ -59,6 +60,15 @@ class PrefetchCache(private val store: IDeserializingKeyValueStore) : IDeseriali
         return hashes.map { entries[it] as T }
     }
 
+    override fun <T : IKVValue> getAll(regular: List<IKVEntryReference<T>>, prefetch: List<IKVEntryReference<T>>): Map<String, T?> {
+        val missingRegular = regular.filterNot { entries.containsKey(it.getHash()) }
+        val missingPrefetch = prefetch.filterNot { entries.containsKey(it.getHash()) }
+        val missingEntries = store.getAll(missingRegular, missingPrefetch)
+        entries.putAll(missingEntries)
+        val regularAndPrefetch = regular.asSequence() + prefetch.asSequence()
+        return regularAndPrefetch.associate { it.getHash() to entries[it.getHash()] as T? }
+    }
+
     override fun put(hash: String, deserialized: Any, serialized: String) {
         entries[hash] = deserialized
         store.put(hash, deserialized, serialized)

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

@@ -1,6 +1,8 @@
 import org.modelix.model.lazy.AccessTrackingStore
 import org.modelix.model.lazy.NonCachingObjectStore
 import org.modelix.model.lazy.PrefetchCache
+import org.modelix.model.lazy.WrittenEntry
+import org.modelix.model.persistent.CPNode
 import org.modelix.model.persistent.MapBasedStore
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -24,4 +26,28 @@ class PrefetchCacheTest {
         assertEquals(result, listOf("value"))
         assertTrue(accessTrackingKeyValueStore.accessedEntries.isEmpty())
     }
+
+    @Test
+    fun entriesAreCachedAfterGettingMultipleEntriesAsMap() {
+        val regularKey = "regularKey"
+        val prefetchKey = "prefetchKey"
+        val nodeForRegularKey = CPNode.create(
+            2, null, 1, null, LongArray(0),
+            emptyArray(), emptyArray(), emptyArray(), emptyArray(),
+        )
+        val nodeForPrefetchKey = CPNode.create(
+            3, null, 1, null, LongArray(0),
+            emptyArray(), emptyArray(), emptyArray(), emptyArray(),
+        )
+        keyValueStore.putAll(mapOf(regularKey to nodeForRegularKey.serialize(), prefetchKey to nodeForPrefetchKey.serialize()))
+        val regularKeyReference = WrittenEntry(regularKey) { nodeForRegularKey }
+        val prefetchKeyReference = WrittenEntry(prefetchKey) { nodeForPrefetchKey }
+        prefetchCache.getAll(listOf(regularKeyReference), listOf(prefetchKeyReference))
+        accessTrackingKeyValueStore.accessedEntries.clear()
+
+        val result = prefetchCache.getAll(listOf(regularKeyReference), listOf(prefetchKeyReference))
+
+        assertEquals(result, mapOf(regularKey to nodeForRegularKey, prefetchKey to nodeForPrefetchKey))
+        assertTrue(accessTrackingKeyValueStore.accessedEntries.isEmpty())
+    }
 }