fix(model-client): use new ConceptDependency

ChildrenDependency should not be necessary because the childlist does not change.

Co-authored-by: Oleksandr Dzhychko <[email protected]>

Author: mhuster23

model-client/src/commonMain/kotlin/org/modelix/model/IncrementalBranch.kt

@@ -178,12 +178,12 @@ class IncrementalBranch(val branch: IBranch) : IBranch, IBranchWrapper {
         }
 
         override fun getConcept(nodeId: Long): IConcept? {
-            accessed(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+            accessed(ConceptDependency(this@IncrementalBranch, nodeId))
             return transaction.getConcept(nodeId)
         }
 
         override fun getConceptReference(nodeId: Long): IConceptReference? {
-            accessed(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+            accessed(ConceptDependency(this@IncrementalBranch, nodeId))
             return transaction.getConceptReference(nodeId)
         }
 
@@ -331,11 +331,8 @@ class IncrementalBranch(val branch: IBranch) : IBranch, IBranchWrapper {
         }
 
         override fun setConcept(nodeId: Long, concept: IConceptReference?) {
-            val oldParentId = transaction.getParent(nodeId)
-            val oldRole = transaction.getRole(nodeId)
             transaction.setConcept(nodeId, concept)
-            modified(ChildrenDependency(this@IncrementalBranch, oldParentId, oldRole))
-            modified(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+            modified(ConceptDependency(this@IncrementalBranch, nodeId))
         }
 
         override fun deleteNode(nodeId: Long) {
@@ -378,12 +375,12 @@ class IncrementalBranch(val branch: IBranch) : IBranch, IBranchWrapper {
         }
 
         override fun getConcept(nodeId: Long): IConcept? {
-            accessed(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+            accessed(ConceptDependency(this@IncrementalBranch, nodeId))
             return tree.getConcept(nodeId)
         }
 
         override fun getConceptReference(nodeId: Long): IConceptReference? {
-            accessed(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+            accessed(ConceptDependency(this@IncrementalBranch, nodeId))
             return tree.getConceptReference(nodeId)
         }
 
@@ -502,6 +499,11 @@ data class BranchDependency(val branch: IBranch) : IStateVariableReference<IBran
     override fun read(): IBranch = branch
 }
 
+/**
+ * Catch-all dependency for changes to a node.
+ * It's the group dependency for a single node.
+ * Also used directly when a node is added/deleted as a whole.
+ */
 data class UnclassifiedNodeDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup(): IStateVariableGroup? {
         return try {
@@ -516,34 +518,70 @@ data class UnclassifiedNodeDependency(val branch: IBranch, val nodeId: Long) : D
     }
 }
 
+/**
+ * Dependency for a single property change.
+ *
+ * @see AllPropertiesDependency
+ */
 data class PropertyDependency(val branch: IBranch, val nodeId: Long, val role: String) : DependencyBase() {
     override fun getGroup() = AllPropertiesDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for a single reference change.
+ *
+ * @see AllReferencesDependency
+ */
 data class ReferenceDependency(val branch: IBranch, val nodeId: Long, val role: String) : DependencyBase() {
     override fun getGroup() = AllReferencesDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for a single child role change.
+ *
+ * @see AllChildrenDependency
+ */
 data class ChildrenDependency(val branch: IBranch, val nodeId: Long, val role: String?) : DependencyBase() {
     override fun getGroup() = AllChildrenDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for any child role changes.
+ *
+ * @see ChildrenDependency
+ */
 data class AllChildrenDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup() = UnclassifiedNodeDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for any reference changes.
+ *
+ * @see ReferenceDependency
+ */
 data class AllReferencesDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup() = UnclassifiedNodeDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for any property changes.
+ *
+ * @see PropertyDependency
+ */
 data class AllPropertiesDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup() = UnclassifiedNodeDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for parent or role in parent changes.
+ */
 data class ContainmentDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup() = UnclassifiedNodeDependency(branch, nodeId)
 }
 
+/**
+ * Dependency for concept changes.
+ */
 data class ConceptDependency(val branch: IBranch, val nodeId: Long) : DependencyBase() {
     override fun getGroup(): IStateVariableGroup = UnclassifiedNodeDependency(branch, nodeId)
 }

model-client/src/commonTest/kotlin/org/modelix/model/IncrementalBranchTest.kt

@@ -18,8 +18,10 @@ package org.modelix.model
 
 import org.modelix.incremental.IncrementalEngine
 import org.modelix.incremental.incrementalFunction
+import org.modelix.model.api.ConceptReference
 import org.modelix.model.api.IConceptReference
 import org.modelix.model.api.IProperty
+import org.modelix.model.api.IReplaceableNode
 import org.modelix.model.api.ITree
 import org.modelix.model.api.PBranch
 import org.modelix.model.api.getRootNode
@@ -31,8 +33,7 @@ class IncrementalBranchTest {
 
     @Test
     fun propertyChange() {
-        val branch = PBranch(ModelFacade.newLocalTree(), IdGenerator.getInstance(17865))
-        val incrementalBranch = IncrementalBranch(branch)
+        val incrementalBranch = initializeIncrementalBranch()
         val rootNode = incrementalBranch.getRootNode()
         incrementalBranch.runWrite { rootNode.setPropertyValue(IProperty.fromName("name"), "abc") }
         val engine = IncrementalEngine()
@@ -57,6 +58,38 @@ class IncrementalBranchTest {
         }
     }
 
+    @Test
+    fun conceptChange() {
+        val incrementalBranch = initializeIncrementalBranch()
+        val root = incrementalBranch.getRootNode() as IReplaceableNode
+        incrementalBranch.runWrite { root.replaceNode(ConceptReference("myConcept")) }
+        val engine = IncrementalEngine()
+
+        try {
+            var callCount = 0
+            val conceptUidWithSuffix = engine.incrementalFunction("f") { _ ->
+                callCount++
+                val conceptRef = incrementalBranch.getRootNode().getConceptReference()?.getUID()
+                conceptRef + "Suffix"
+            }
+            assertEquals(callCount, 0)
+            assertEquals("myConceptSuffix", incrementalBranch.computeRead { conceptUidWithSuffix() })
+            assertEquals(callCount, 1)
+            assertEquals("myConceptSuffix", incrementalBranch.computeRead { conceptUidWithSuffix() })
+            assertEquals(callCount, 1)
+            incrementalBranch.runWrite {
+                (incrementalBranch.getRootNode() as IReplaceableNode).replaceNode(
+                    ConceptReference("myConcept2"),
+                )
+            }
+            assertEquals(callCount, 1)
+            assertEquals("myConcept2Suffix", incrementalBranch.computeRead { conceptUidWithSuffix() })
+            assertEquals(callCount, 2)
+        } finally {
+            engine.dispose()
+        }
+    }
+
     @Test
     fun addNewChild_modifies_containsNode() {
         val childId = 12345L
@@ -76,4 +109,10 @@ class IncrementalBranchTest {
             engine.dispose()
         }
     }
+
+    private fun initializeIncrementalBranch(): IncrementalBranch {
+        val branch = PBranch(ModelFacade.newLocalTree(), IdGenerator.getInstance(17865))
+        val incrementalBranch = IncrementalBranch(branch)
+        return incrementalBranch
+    }
 }