refactor(model-datastructure): renamed methods in IBulkQuery

IBulkQuery is not public API, so this is not considered a
breaking change.

Author: slisson

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

@@ -39,11 +39,11 @@ class BulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
     }
 
     fun <T : IKVValue> query(key: KVEntryReference<T>, callback: (T) -> Unit) {
-        if (queue.size >= BATCH_SIZE && !processing) process()
+        if (queue.size >= BATCH_SIZE && !processing) executeQuery()
         queue.add(Pair(key as KVEntryReference<IKVValue>, callback as (IKVValue?) -> Unit))
     }
 
-    override fun <T : IKVValue> get(hash: KVEntryReference<T>): IBulkQuery.Value<T?> {
+    override fun <T : IKVValue> query(hash: KVEntryReference<T>): IBulkQuery.Value<T?> {
         val result = Value<T?>()
         query(hash) { value: T? -> result.success(value) }
         return result
@@ -53,7 +53,7 @@ class BulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
         return Value(value)
     }
 
-    override fun process() {
+    override fun executeQuery() {
         if (processing) {
             throw RuntimeException("Already processing")
         }
@@ -83,22 +83,22 @@ class BulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
         }
     }
 
-    override fun <I, O> map(input_: Iterable<I>, f: (I) -> IBulkQuery.Value<O>): IBulkQuery.Value<List<O>> {
-        val input = input_.toList()
-        if (input.isEmpty()) {
+    override fun <I, O> flatMap(input: Iterable<I>, f: (I) -> IBulkQuery.Value<O>): IBulkQuery.Value<List<O>> {
+        val inputList = input.toList()
+        if (inputList.isEmpty()) {
             return constant(emptyList())
         }
-        val output = arrayOfNulls<Any>(input.size)
-        val done = BooleanArray(input.size)
-        var remaining = input.size
+        val output = arrayOfNulls<Any>(inputList.size)
+        val done = BooleanArray(inputList.size)
+        var remaining = inputList.size
         val result = Value<List<O>>()
-        for (i_ in input.indices) {
-            f(input[i_]).onSuccess { value ->
-                if (done[i_]) {
-                    return@onSuccess
+        for (i in inputList.indices) {
+            f(inputList[i]).onReceive { value ->
+                if (done[i]) {
+                    return@onReceive
                 }
-                output[i_] = value
-                done[i_] = true
+                output[i] = value
+                done[i] = true
                 remaining--
                 if (remaining == 0) {
                     result.success(output.map { e: Any? -> e as O })
@@ -131,16 +131,16 @@ class BulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
         }
 
         @Synchronized
-        override fun onSuccess(handler: (T) -> Unit) {
+        override fun onReceive(handler: (T) -> Unit) {
             if (done) {
                 handler(value as T)
             } else {
                 handlers!!.add(handler)
             }
         }
 
-        override fun execute(): T {
-            process()
+        override fun executeQuery(): T {
+            this@BulkQuery.executeQuery()
             if (!done) {
                 throw RuntimeException("No value received")
             }
@@ -149,13 +149,13 @@ class BulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
 
         override fun <R> map(handler: (T) -> R): IBulkQuery.Value<R> {
             val result = Value<R>()
-            onSuccess { v -> result.success(handler(v)) }
+            onReceive { v -> result.success(handler(v)) }
             return result
         }
 
-        override fun <R> mapBulk(handler: (T) -> IBulkQuery.Value<R>): IBulkQuery.Value<R> {
+        override fun <R> flatMap(handler: (T) -> IBulkQuery.Value<R>): IBulkQuery.Value<R> {
             val result = Value<R>()
-            onSuccess { v -> handler(v).onSuccess { value -> result.success(value) } }
+            onReceive { v -> handler(v).onReceive { value -> result.success(value) } }
             return result
         }
     }

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

@@ -82,9 +82,9 @@ class CLNode(private val tree: CLTree, private val data: CPNode) {
             getDescendants(bulkQuery, false)
                 .map { descendants -> (sequenceOf(this) + descendants).asIterable() }
         } else {
-            getChildren(bulkQuery).mapBulk { children: Iterable<CLNode> ->
+            getChildren(bulkQuery).flatMap { children: Iterable<CLNode> ->
                 val d: IBulkQuery.Value<Iterable<CLNode>> = bulkQuery
-                    .map(children) { child: CLNode -> child.getDescendants(bulkQuery, true) }
+                    .flatMap(children) { child: CLNode -> child.getDescendants(bulkQuery, true) }
                     .map { it.flatten() }
                 d
             }

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

@@ -92,7 +92,7 @@ class CLTree : ITree, IBulkTree {
     }
 
     fun getSize(): Long {
-        return (nodesMap ?: return 0L).calculateSize(store.newBulkQuery()).execute()
+        return (nodesMap ?: return 0L).calculateSize(store.newBulkQuery()).executeQuery()
     }
 
     fun prefetchAll() {
@@ -315,43 +315,43 @@ class CLTree : ITree, IBulkTree {
     }
 
     override fun getAllChildren(parentId: Long): Iterable<Long> {
-        val children = getChildren(resolveElement(parentId)!!, store.newBulkQuery()).execute()
+        val children = getChildren(resolveElement(parentId)!!, store.newBulkQuery()).executeQuery()
         return children.map { it.id }
     }
 
     override fun getDescendants(root: Long, includeSelf: Boolean): Iterable<CLNode> {
         val parent = resolveElement(root)
-        return getDescendants(parent!!, store.newBulkQuery(), includeSelf).execute().map { CLNode(this, it) }
+        return getDescendants(parent!!, store.newBulkQuery(), includeSelf).executeQuery().map { CLNode(this, it) }
     }
 
     override fun getDescendants(rootIds: Iterable<Long>, includeSelf: Boolean): Iterable<CLNode> {
         val bulkQuery = store.newBulkQuery()
         val roots: IBulkQuery.Value<List<CPNode>> = resolveElements(rootIds.toList(), bulkQuery)
-        val descendants = roots.mapBulk { bulkQuery.map(it) { getDescendants(it, bulkQuery, includeSelf) } }
-        return descendants.execute().flatten().map { CLNode(this, it) }
+        val descendants = roots.flatMap { bulkQuery.flatMap(it) { getDescendants(it, bulkQuery, includeSelf) } }
+        return descendants.executeQuery().flatten().map { CLNode(this, it) }
     }
 
     override fun getAncestors(nodeIds: Iterable<Long>, includeSelf: Boolean): Set<Long> {
         val bulkQuery = store.newBulkQuery()
         val nodes: IBulkQuery.Value<List<CPNode>> = resolveElements(nodeIds, bulkQuery)
-        val ancestors = nodes.mapBulk { bulkQuery.map(it) { getAncestors(it, bulkQuery, includeSelf) } }
+        val ancestors = nodes.flatMap { bulkQuery.flatMap(it) { getAncestors(it, bulkQuery, includeSelf) } }
         val result = HashSet<Long>()
-        ancestors.execute().forEach { result.addAll(it.map { it.id }) }
+        ancestors.executeQuery().forEach { result.addAll(it.map { it.id }) }
         return result
     }
 
     override fun getChildren(parentId: Long, role: String?): Iterable<Long> {
         checkChildRoleId(parentId, role)
         val parent = resolveElement(parentId)
-        val children = getChildren(parent!!, store.newBulkQuery()).execute()
+        val children = getChildren(parent!!, store.newBulkQuery()).executeQuery()
         return children
             .filter { it.roleInParent == role }
             .map { it.id }
     }
 
     override fun getChildRoles(sourceId: Long): Iterable<String?> {
         val parent = resolveElement(sourceId)
-        val children: Iterable<CPNode> = getChildren(parent!!, store.newBulkQuery()).execute()
+        val children: Iterable<CPNode> = getChildren(parent!!, store.newBulkQuery()).executeQuery()
         return children.map { it.roleInParent }.distinct()
     }
 
@@ -443,7 +443,7 @@ class CLTree : ITree, IBulkTree {
     override fun visitChanges(oldVersion: ITree, visitor: ITreeChangeVisitor) {
         val bulkQuery = store.newBulkQuery()
         visitChanges(oldVersion, visitor, bulkQuery)
-        (bulkQuery as? BulkQuery)?.process()
+        (bulkQuery as? BulkQuery)?.executeQuery()
     }
 
     fun visitChanges(oldVersion: ITree, visitor: ITreeChangeVisitor, bulkQuery: IBulkQuery) {
@@ -512,7 +512,7 @@ class CLTree : ITree, IBulkTree {
                                     }
                                 }
 
-                            bulkQuery.map(listOf(oldVersion.getChildren(oldElement, bulkQuery), getChildren(newElement, bulkQuery))) { it }.onSuccess { childrenLists ->
+                            bulkQuery.flatMap(listOf(oldVersion.getChildren(oldElement, bulkQuery), getChildren(newElement, bulkQuery))) { it }.onReceive { childrenLists ->
                                 val (oldChildrenList, newChildrenList) = childrenLists
                                 val oldChildren: MutableMap<String?, MutableList<CPNode>> = HashMap()
                                 val newChildren: MutableMap<String?, MutableList<CPNode>> = HashMap()
@@ -567,15 +567,15 @@ class CLTree : ITree, IBulkTree {
     }
 
     fun resolveElement(id: Long): CPNode? {
-        return resolveElement(id, NonBulkQuery(store)).execute()
+        return resolveElement(id, NonBulkQuery(store)).executeQuery()
     }
 
     fun resolveElement(id: Long, bulkQuery: IBulkQuery): IBulkQuery.Value<CPNode?> {
         if (id == 0L) {
             return bulkQuery.constant(null)
         }
         val hash = nodesMap!!.get(id, bulkQuery)
-        return hash.mapBulk {
+        return hash.flatMap {
             if (it == null) throw NodeNotFoundException(id)
             createElement(it, bulkQuery)
         }
@@ -587,24 +587,24 @@ class CLTree : ITree, IBulkTree {
         val b: IBulkQuery.Value<List<KVEntryReference<CPNode>>> = a.map { hashes: List<KVEntryReference<CPNode>?> ->
             hashes.mapIndexed { index, s -> s ?: throw NodeNotFoundException(ids[index]) }
         }
-        return b.mapBulk { hashes -> createElements(hashes, bulkQuery) }
+        return b.flatMap { hashes -> createElements(hashes, bulkQuery) }
     }
 
     fun createElement(hash: KVEntryReference<CPNode>?, query: IBulkQuery): IBulkQuery.Value<CPNode?> {
         return if (hash == null) {
             query.constant(null)
         } else {
-            query[hash]
+            query.query(hash)
         }
     }
 
     fun createElement(hash: KVEntryReference<CPNode>?): CPNode? {
-        return createElement(hash, NonBulkQuery(store)).execute()
+        return createElement(hash, NonBulkQuery(store)).executeQuery()
     }
 
     fun createElements(hashes: List<KVEntryReference<CPNode>>, bulkQuery: IBulkQuery): IBulkQuery.Value<List<CPNode>> {
-        return bulkQuery.map(hashes) { hash: KVEntryReference<CPNode> ->
-            bulkQuery[hash].map { n -> n!! }
+        return bulkQuery.flatMap(hashes) { hash: KVEntryReference<CPNode> ->
+            bulkQuery.query(hash).map { n -> n!! }
         }
     }
 
@@ -635,9 +635,9 @@ class CLTree : ITree, IBulkTree {
             getDescendants(node, bulkQuery, false)
                 .map { descendants -> (sequenceOf(node) + descendants).asIterable() }
         } else {
-            getChildren(node, bulkQuery).mapBulk { children: Iterable<CPNode> ->
+            getChildren(node, bulkQuery).flatMap { children: Iterable<CPNode> ->
                 val d: IBulkQuery.Value<Iterable<CPNode>> = bulkQuery
-                    .map(children) { child: CPNode -> getDescendants(child, bulkQuery, true) }
+                    .flatMap(children) { child: CPNode -> getDescendants(child, bulkQuery, true) }
                     .map { it.flatten() }
                 d
             }

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

@@ -349,7 +349,7 @@ private fun computeDelta(keyValueStore: IKeyValueStore, versionHash: String, bas
                     override fun visitChangesOnly(): Boolean = false
                     override fun entryAdded(key: Long, value: KVEntryReference<CPNode>) {
                         changedNodeIds += key
-                        if (value != null) bulkQuery.get(value)
+                        if (value != null) bulkQuery.query(value)
                     }
 
                     override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>) {
@@ -362,14 +362,14 @@ private fun computeDelta(keyValueStore: IKeyValueStore, versionHash: String, bas
                         newValue: KVEntryReference<CPNode>,
                     ) {
                         changedNodeIds += key
-                        if (newValue != null) bulkQuery.get(newValue)
+                        if (newValue != null) bulkQuery.query(newValue)
                     }
                 },
                 bulkQuery,
             )
             v1 = v2
         }
-        (bulkQuery as? BulkQuery)?.process()
+        (bulkQuery as? BulkQuery)?.executeQuery()
     }
     val oldEntries: Map<String, String?> = trackAccessedEntries(keyValueStore) { store ->
         if (baseVersionHash == null) return@trackAccessedEntries
@@ -386,12 +386,12 @@ private fun computeDelta(keyValueStore: IKeyValueStore, versionHash: String, bas
 
         val nodesMap = oldTree.nodesMap!!
         changedNodeIds.forEach { changedNodeId ->
-            nodesMap.get(changedNodeId, 0, bulkQuery).onSuccess { nodeRef: KVEntryReference<CPNode>? ->
-                if (nodeRef != null) bulkQuery.get(nodeRef)
+            nodesMap.get(changedNodeId, 0, bulkQuery).onReceive { nodeRef: KVEntryReference<CPNode>? ->
+                if (nodeRef != null) bulkQuery.query(nodeRef)
             }
         }
 
-        (bulkQuery as? BulkQuery)?.process()
+        (bulkQuery as? BulkQuery)?.executeQuery()
     }
     return oldAndNewEntries - oldEntries.keys
 }

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

@@ -18,14 +18,14 @@ package org.modelix.model.lazy
 import org.modelix.model.persistent.IKVValue
 
 interface IBulkQuery {
-    fun process()
-    fun <I, O> map(input_: Iterable<I>, f: (I) -> Value<O>): Value<List<O>>
+    fun executeQuery()
+    fun <I, O> flatMap(input: Iterable<I>, f: (I) -> Value<O>): Value<List<O>>
     fun <T> constant(value: T): Value<T>
-    operator fun <T : IKVValue> get(hash: KVEntryReference<T>): Value<T?>
+    fun <T : IKVValue> query(hash: KVEntryReference<T>): Value<T?>
     interface Value<out T> {
-        fun execute(): T
-        fun <R> mapBulk(handler: (T) -> Value<R>): Value<R>
+        fun executeQuery(): T
+        fun <R> flatMap(handler: (T) -> Value<R>): Value<R>
         fun <R> map(handler: (T) -> R): Value<R>
-        fun onSuccess(handler: (T) -> Unit)
+        fun onReceive(handler: (T) -> Unit)
     }
 }

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

@@ -18,37 +18,37 @@ package org.modelix.model.lazy
 import org.modelix.model.persistent.IKVValue
 
 class NonBulkQuery(private val store: IDeserializingKeyValueStore) : IBulkQuery {
-    override fun <I, O> map(input_: Iterable<I>, f: (I) -> IBulkQuery.Value<O>): IBulkQuery.Value<List<O>> {
-        val list = input_.asSequence().map(f).map { it.execute() }.toList()
+    override fun <I, O> flatMap(input: Iterable<I>, f: (I) -> IBulkQuery.Value<O>): IBulkQuery.Value<List<O>> {
+        val list = input.asSequence().map(f).map { it.executeQuery() }.toList()
         return Value(list)
     }
 
     override fun <T> constant(value: T): IBulkQuery.Value<T> {
         return Value(value)
     }
 
-    override fun <T : IKVValue> get(hash: KVEntryReference<T>): IBulkQuery.Value<T?> {
+    override fun <T : IKVValue> query(hash: KVEntryReference<T>): IBulkQuery.Value<T?> {
         return constant(hash.getValue(store))
     }
 
-    override fun process() {
+    override fun executeQuery() {
         // all requests are processed immediately
     }
 
     class Value<T>(private val value: T) : IBulkQuery.Value<T> {
-        override fun execute(): T {
+        override fun executeQuery(): T {
             return value
         }
 
-        override fun <R> mapBulk(handler: (T) -> IBulkQuery.Value<R>): IBulkQuery.Value<R> {
+        override fun <R> flatMap(handler: (T) -> IBulkQuery.Value<R>): IBulkQuery.Value<R> {
             return handler(value)
         }
 
         override fun <R> map(handler: (T) -> R): IBulkQuery.Value<R> {
             return Value(handler(value))
         }
 
-        override fun onSuccess(handler: (T) -> Unit) {
+        override fun onReceive(handler: (T) -> Unit) {
             handler(value)
         }
     }