feat(model-api): added flow based API in INode

This is an alternative to the IBulkQuery that already exists in CLTree.
It allows a batching of request to the key-value store.

Author: slisson

model-api/src/commonMain/kotlin/org/modelix/model/api/INode.kt

@@ -15,6 +15,7 @@
 
 package org.modelix.model.api
 
+import kotlinx.coroutines.flow.*
 import org.modelix.model.area.IArea
 
 /**
@@ -217,6 +218,25 @@ interface INode {
     fun getAllReferenceTargets(): List<Pair<IReferenceLink, INode>> = getReferenceLinks().map { it to getReferenceTarget(it) }.filterSecondNotNull()
     fun getAllReferenceTargetRefs(): List<Pair<IReferenceLink, INodeReference>> = getReferenceLinks().map { it to getReferenceTargetRef(it) }.filterSecondNotNull()
     // </editor-fold>
+
+    // <editor-fold desc="flow API">
+    fun getParentAsFlow(): Flow<INode> = flowOf(parent).filterNotNull()
+    fun getPropertyValueAsFlow(role: IProperty): Flow<String?> = flowOf(getPropertyValue(role))
+    fun getAllChildrenAsFlow(): Flow<INode> = allChildren.asFlow()
+    fun getAllReferenceTargetsAsFlow(): Flow<Pair<IReferenceLink, INode>> = getAllReferenceTargets().asFlow()
+    fun getAllReferenceTargetRefsAsFlow(): Flow<Pair<IReferenceLink, INodeReference>> = getAllReferenceTargetRefs().asFlow()
+    fun getChildrenAsFlow(role: IChildLink): Flow<INode> = getChildren(role).asFlow()
+    fun getReferenceTargetAsFlow(role: IReferenceLink): Flow<INode> = flowOf(getReferenceTarget(role)).filterNotNull()
+    fun getReferenceTargetRefAsFlow(role: IReferenceLink): Flow<INodeReference> = flowOf(getReferenceTargetRef(role)).filterNotNull()
+
+    fun getDescendantsAsFlow(includeSelf: Boolean = false): Flow<INode> {
+        return if (includeSelf) {
+            flowOf(flowOf(this), getDescendantsAsFlow(false)).flattenConcat()
+        } else {
+            getAllChildrenAsFlow().flatMapConcat { it.getDescendantsAsFlow(true) }
+        }
+    }
+    // </editor-fold>
 }
 
 fun <T1, T2> List<Pair<T1, T2?>>.filterSecondNotNull(): List<Pair<T1, T2>> = filter { it.second != null } as List<Pair<T1, T2>>

model-api/src/commonMain/kotlin/org/modelix/model/api/ITree.kt

@@ -15,6 +15,8 @@
 
 package org.modelix.model.api
 
+import kotlinx.coroutines.flow.*
+
 /**
  * Consists of [INode]s.
  */
@@ -243,6 +245,20 @@ interface ITree {
      */
     fun deleteNodes(nodeIds: LongArray): ITree
 
+    fun getAllChildrenAsFlow(parentId: Long): Flow<Long> = getAllChildren(parentId).asFlow()
+    fun getDescendantsAsFlow(nodeId: Long, includeSelf: Boolean = false): Flow<Long> {
+        return if (includeSelf) {
+            flowOf(flowOf(nodeId), getDescendantsAsFlow(nodeId, false)).flattenConcat()
+        } else {
+            getAllChildrenAsFlow(nodeId).flatMapConcat { getDescendantsAsFlow(it, true) }
+        }
+    }
+    fun getAllReferenceTargetsAsFlow(nodeId: Long): Flow<Pair<String, INodeReference>> = getReferenceRoles(nodeId).map { it to getReferenceTarget(nodeId, it) }.filterSecondNotNull().asFlow()
+    fun getChildrenAsFlow(parentId: Long, role: String): Flow<Long> = getChildren(parentId, role).asFlow()
+    fun getReferenceTargetAsFlow(nodeId: Long, role: String): Flow<INodeReference> = flowOf(getReferenceTarget(nodeId, role)).filterNotNull()
+    fun getParentAsFlow(nodeId: Long): Flow<Long> = flowOf(getParent(nodeId)).filter { it != 0L }
+    fun getPropertyValueAsFlow(nodeId: Long, role: String): Flow<String?> = flowOf(getProperty(nodeId, role))
+
     companion object {
         const val ROOT_ID = 1L
         const val DETACHED_NODES_ROLE = "detached"

model-api/src/commonMain/kotlin/org/modelix/model/api/PNodeAdapter.kt

@@ -15,16 +15,22 @@
 
 package org.modelix.model.api
 
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
 import org.modelix.model.area.ContextArea
 import org.modelix.model.area.IArea
 import org.modelix.model.area.PArea
+import kotlin.coroutines.coroutineContext
 
 open class PNodeAdapter(val nodeId: Long, val branch: IBranch) : INode, INodeEx {
 
     init {
         require(nodeId != 0L, { "Invalid node 0" })
     }
 
+    private fun getTree(): ITree = branch.transaction.tree
+
     override fun getArea(): PArea = PArea(branch)
 
     protected fun unwrap(node: INode?): Long {
@@ -111,12 +117,27 @@ open class PNodeAdapter(val nodeId: Long, val branch: IBranch) : INode, INodeEx
     override fun getReferenceTarget(role: String): INode? {
         notifyAccess()
         val targetRef = getReferenceTargetRef(role) ?: return null
-        if (targetRef is PNodeReference) {
-            return targetRef.resolveNode(PArea(branch))
+        return tryResolveNodeRef(targetRef)
+    }
+
+    private fun tryResolveNodeRef(targetRef: INodeReference): INode? {
+        return if (targetRef is PNodeReference) {
+            targetRef.resolveIn(PArea(branch)!!)
+        } else {
+            val area = ContextArea.CONTEXT_VALUE.getValue()
+                ?: throw RuntimeException(IArea::class.simpleName + " not available")
+            targetRef.resolveIn(area!!)
         }
-        val area = ContextArea.CONTEXT_VALUE.getValue()
-            ?: throw RuntimeException(IArea::class.simpleName + " not available")
-        return targetRef.resolveNode(area)
+    }
+
+    private suspend fun resolveNodeRefInCoroutine(targetRef: INodeReference): INode {
+        return if (targetRef is PNodeReference) {
+            targetRef.resolveIn(PArea(branch)!!)
+        } else {
+            val scope = coroutineContext[INodeResolutionScope]
+                ?: throw IllegalStateException("INodeResolutionScope not set")
+            targetRef.resolveIn(scope)
+        } ?: throw RuntimeException("Failed to resolve node: $targetRef")
     }
 
     override fun getReferenceTargetRef(role: String): INodeReference? {
@@ -160,6 +181,45 @@ open class PNodeAdapter(val nodeId: Long, val branch: IBranch) : INode, INodeEx
         return branch.transaction.getReferenceRoles(nodeId).toList()
     }
 
+    override fun getAllChildrenAsFlow(): Flow<INode> {
+        return getTree().getAllChildrenAsFlow(nodeId).map { wrap(it)!! }
+    }
+
+    override fun getDescendantsAsFlow(includeSelf: Boolean): Flow<INode> {
+        return getTree().getDescendantsAsFlow(nodeId, includeSelf).map { wrap(it)!! }
+    }
+
+    override fun getAllReferenceTargetsAsFlow(): Flow<Pair<IReferenceLink, INode>> {
+        return getAllReferenceTargetRefsAsFlow().map { it.first to resolveNodeRefInCoroutine(it.second) }
+    }
+
+    override fun getAllReferenceTargetRefsAsFlow(): Flow<Pair<IReferenceLink, INodeReference>> {
+        return getTree().getAllReferenceTargetsAsFlow(nodeId).map { this.resolveReferenceLinkOrFallback(it.first) to it.second }
+    }
+
+    override fun getChildrenAsFlow(role: IChildLink): Flow<INode> {
+        val tree = getTree()
+        return tree.getChildrenAsFlow(nodeId, role.key(tree)).map { wrap(it)!! }
+    }
+
+    override fun getParentAsFlow(): Flow<INode> {
+        return getTree().getParentAsFlow(nodeId).map { wrap(it)!! }
+    }
+
+    override fun getPropertyValueAsFlow(role: IProperty): Flow<String?> {
+        val tree = getTree()
+        return tree.getPropertyValueAsFlow(nodeId, role.key(tree))
+    }
+
+    override fun getReferenceTargetAsFlow(role: IReferenceLink): Flow<INode> {
+        return getReferenceTargetRefAsFlow(role).mapNotNull { tryResolveNodeRef(it) }
+    }
+
+    override fun getReferenceTargetRefAsFlow(role: IReferenceLink): Flow<INodeReference> {
+        val tree = getTree()
+        return tree.getReferenceTargetAsFlow(nodeId, role.key(tree))
+    }
+
     override fun equals(o: Any?): Boolean {
         if (this === o) {
             return true