feat(model-api): add and implement INode::replaceNode

mhuster23 · mhuster23 · commit 0e73b2194dec · 2024-04-05T14:35:19.000+02:00
diff --git a/light-model-client/src/commonMain/kotlin/org/modelix/client/light/LightModelClient.kt b/light-model-client/src/commonMain/kotlin/org/modelix/client/light/LightModelClient.kt
@@ -455,6 +455,10 @@ class LightModelClient internal constructor(
             }
         }
 
+        override fun replaceNode(concept: ConceptReference): INode {
+            TODO("Not yet implemented")
+        }
+
         override fun removeChild(child: INode) {
             require(child is NodeAdapter && child.getClient() == getClient()) { "Unsupported child type: $child" }
             requiresWrite {
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/INode.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/INode.kt
@@ -47,6 +47,15 @@ interface INode {
 
     fun tryGetConcept(): IConcept? = getConceptReference()?.tryResolve()
 
+    /**
+     * Replaces this node with a new node of the given concept that uses the same id as this node.
+     * Properties, references and children will be the same.
+     *
+     * @param concept the concept of the new node
+     * @return replacement for this node with the new given concept
+     */
+    fun replaceNode(concept: ConceptReference): INode
+
     /**
      * Role of this node in its parent node if it exists,or null otherwise.
      */
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/ITree.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/ITree.kt
@@ -254,6 +254,12 @@ interface ITree {
      */
     fun deleteNodes(nodeIds: LongArray): ITree
 
+    /**
+     * @param nodeId id of the node
+     * @param concept the concept ref of the new concept for the node, or null to remove the concept
+     */
+    fun setConcept(nodeId: Long, concept: IConceptReference?): ITree
+
     fun getAllChildrenAsFlow(parentId: Long): Flow<Long> = getAllChildren(parentId).asFlow()
     fun getDescendantsAsFlow(nodeId: Long, includeSelf: Boolean = false): Flow<Long> {
         return if (includeSelf) {
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/IWriteTransaction.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/IWriteTransaction.kt
@@ -105,6 +105,14 @@ interface IWriteTransaction : ITransaction {
     fun addNewChildren(parentId: Long, role: String?, index: Int, concepts: Array<IConceptReference?>): LongArray
     fun addNewChildren(parentId: Long, role: String?, index: Int, childIds: LongArray, concepts: Array<IConceptReference?>)
 
+    /**
+     * Sets the concept of the node identified by the given id.
+     *
+     * @param nodeId id of the node
+     * @param concept the new concept, or null to remove the concept
+     */
+    fun setConcept(nodeId: Long, concept: IConceptReference?)
+
     /**
      * Deletes the given node.
      *
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/PNodeAdapter.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/PNodeAdapter.kt
@@ -82,6 +82,11 @@ open class PNodeAdapter(val nodeId: Long, val branch: IBranch) : INode, INodeEx
         return PNodeAdapter(branch.writeTransaction.addNewChild(nodeId, role.key(this), index, concept), branch)
     }
 
+    override fun replaceNode(concept: ConceptReference): INode {
+        branch.writeTransaction.setConcept(nodeId, concept)
+        return this
+    }
+
     override val allChildren: Iterable<INode>
         get() {
             notifyAccess()
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/TreePointer.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/TreePointer.kt
@@ -138,6 +138,10 @@ class TreePointer(private var tree_: ITree, val idGenerator: IIdGenerator = IdGe
         tree = tree.addNewChildren(parentId, role, index, childIds, concepts)
     }
 
+    override fun setConcept(nodeId: Long, concept: IConceptReference?) {
+        tree = tree.setConcept(nodeId, concept)
+    }
+
     override fun deleteNode(nodeId: Long) {
         tree = tree.deleteNode(nodeId)
     }
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/WriteTransaction.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/WriteTransaction.kt
@@ -91,6 +91,11 @@ class WriteTransaction(_tree: ITree, branch: IBranch, idGenerator: IIdGenerator)
         return newIds
     }
 
+    override fun setConcept(nodeId: Long, concept: IConceptReference?) {
+        checkNotClosed()
+        tree = tree.setConcept(nodeId, concept)
+    }
+
     override fun deleteNode(nodeId: Long) {
         checkNotClosed()
         tree.getAllChildren(nodeId).forEach { deleteNode(it) }
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/area/AreaWithMounts.kt b/model-api/src/commonMain/kotlin/org/modelix/model/area/AreaWithMounts.kt
@@ -13,6 +13,7 @@
  */
 package org.modelix.model.area
 
+import org.modelix.model.api.ConceptReference
 import org.modelix.model.api.IBranch
 import org.modelix.model.api.IConcept
 import org.modelix.model.api.IConceptReference
@@ -159,6 +160,10 @@ class AreaWithMounts(val rootArea: IArea, mounts: Map<INode, IArea>) : IArea {
             return node.getChildren(role).map { NodeWrapper(getMountedArea(it)?.getRoot() ?: it) }
         }
 
+        override fun replaceNode(concept: ConceptReference): INode {
+            return NodeWrapper(node.replaceNode(concept))
+        }
+
         override fun removeChild(child: INode) {
             val hiddenNode = getHiddenNode(child)
             if (hiddenNode == null) {
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/area/CompositeArea.kt b/model-api/src/commonMain/kotlin/org/modelix/model/area/CompositeArea.kt
@@ -13,6 +13,7 @@
  */
 package org.modelix.model.area
 
+import org.modelix.model.api.ConceptReference
 import org.modelix.model.api.IBranch
 import org.modelix.model.api.IConcept
 import org.modelix.model.api.IConceptReference
@@ -163,6 +164,10 @@ class CompositeArea : IArea {
             throw UnsupportedOperationException("Read only. Create a new CompositeArea instance instead.")
         }
 
+        override fun replaceNode(concept: ConceptReference): INode {
+            throw UnsupportedOperationException("Root cannot have a concept.")
+        }
+
         override fun removeChild(child: INode) {
             throw UnsupportedOperationException("Read only. Create a new CompositeArea instance instead.")
         }
@@ -219,6 +224,8 @@ class CompositeArea : IArea {
             return node.getChildren(role).map { NodeWrapper(it) }
         }
 
+        override fun replaceNode(concept: ConceptReference): INode = NodeWrapper(node.replaceNode(concept))
+
         override fun removeChild(child: INode) {
             node.removeChild(unwrapNode(child))
         }
diff --git a/model-client/src/commonMain/kotlin/org/modelix/model/AutoTransactionsBranch.kt b/model-client/src/commonMain/kotlin/org/modelix/model/AutoTransactionsBranch.kt
@@ -80,6 +80,9 @@ class AutoWriteTransaction(branch: IBranch) : AutoTransaction(branch), IWriteTra
         childId: Long,
         concept: IConceptReference?,
     ) = branch.computeWriteT { it.addNewChild(parentId, role, index, childId, concept) }
+    override fun setConcept(nodeId: Long, concept: IConceptReference?) =
+        branch.computeWriteT { it.setConcept(nodeId, concept) }
+
     override fun deleteNode(nodeId: Long) = branch.computeWriteT { it.deleteNode(nodeId) }
 
     override var tree: ITree
diff --git a/model-client/src/commonMain/kotlin/org/modelix/model/IncrementalBranch.kt b/model-client/src/commonMain/kotlin/org/modelix/model/IncrementalBranch.kt
@@ -326,6 +326,15 @@ class IncrementalBranch(val branch: IBranch) : IBranch, IBranchWrapper {
             modified(UnclassifiedNodeDependency(this@IncrementalBranch, childId)) // see .containsNode
         }
 
+        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(ContainmentDependency(this@IncrementalBranch, nodeId))
+            modified(UnclassifiedNodeDependency(this@IncrementalBranch, nodeId))
+        }
+
         override fun deleteNode(nodeId: Long) {
             val oldParentId = transaction.getParent(nodeId)
             val oldRole = transaction.getRole(nodeId)
@@ -463,6 +472,11 @@ class IncrementalBranch(val branch: IBranch) : IBranch, IBranchWrapper {
             return tree.addNewChildren(parentId, role, index, newIds, concepts).wrap()
         }
 
+        override fun setConcept(nodeId: Long, concept: IConceptReference?): ITree {
+            // No modification event, because the branch doesn't change
+            return tree.setConcept(nodeId, concept)
+        }
+
         override fun deleteNode(nodeId: Long): ITree {
             // No modification event, because the branch doesn't change
             return tree.deleteNode(nodeId).wrap()
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLTree.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLTree.kt
@@ -28,7 +28,6 @@ import org.modelix.model.api.ITreeChangeVisitorEx
 import org.modelix.model.api.LocalPNodeReference
 import org.modelix.model.api.PNodeReference
 import org.modelix.model.api.tryResolve
-import org.modelix.model.lazy.COWArrays.add
 import org.modelix.model.lazy.COWArrays.insert
 import org.modelix.model.lazy.COWArrays.remove
 import org.modelix.model.lazy.RepositoryId.Companion.random
@@ -257,6 +256,25 @@ class CLTree : ITree, IBulkTree {
         return CLTree(data.id, newIdToHash!!, store, data.usesRoleIds)
     }
 
+    override fun setConcept(nodeId: Long, concept: IConceptReference?): ITree {
+        val node = checkNotNull(resolveElement(nodeId)) { "nodeId could not be resolved. id=$nodeId" }
+        val newData = create(
+            node.id,
+            concept?.getUID(),
+            node.parentId,
+            node.roleInParent,
+            node.childrenIdArray,
+            node.propertyRoles,
+            node.propertyValues,
+            node.referenceRoles,
+            node.referenceTargets,
+        )
+        val nodesMap = checkNotNull(nodesMap) { "nodesMap not found" }
+
+        val newIdToHash = checkNotNull(nodesMap.put(newData, store)) { "could not put new data" }
+        return CLTree(data.id, newIdToHash, store, data.usesRoleIds)
+    }
+
     override fun deleteNode(nodeId: Long): ITree {
         return deleteNode(nodeId, true)
     }
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/operations/OTWriteTransaction.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/operations/OTWriteTransaction.kt
@@ -129,6 +129,10 @@ class OTWriteTransaction(
         }
     }
 
+    override fun setConcept(nodeId: Long, concept: IConceptReference?) {
+        apply(SetConceptOp(nodeId, concept))
+    }
+
     override fun containsNode(nodeId: Long): Boolean {
         return transaction.containsNode(nodeId)
     }
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/operations/SetConceptOp.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/operations/SetConceptOp.kt
@@ -0,0 +1,57 @@
+/*
+ * 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.operations
+
+import org.modelix.model.api.IConceptReference
+import org.modelix.model.api.ITree
+import org.modelix.model.api.IWriteTransaction
+import org.modelix.model.lazy.IDeserializingKeyValueStore
+import org.modelix.model.persistent.SerializationUtil
+
+/**
+ * Operation to set the concept of a node.
+ *
+ * @param nodeId id of the node
+ * @param concept reference to the new concept, or null to remove the concept
+ */
+class SetConceptOp(val nodeId: Long, val concept: IConceptReference?) : AbstractOperation(), IOperationIntend {
+    override fun apply(transaction: IWriteTransaction, store: IDeserializingKeyValueStore): IAppliedOperation {
+        val originalConcept = transaction.getConceptReference(nodeId)
+        transaction.setConcept(nodeId, concept)
+        return Applied(originalConcept)
+    }
+
+    override fun toString(): String {
+        return "SetConceptOp ${SerializationUtil.longToHex(nodeId)} concept: $concept"
+    }
+
+    override fun getOriginalOp(): IOperation = this
+
+    override fun restoreIntend(tree: ITree): List<IOperation> {
+        return if (tree.containsNode(nodeId)) listOf(this) else listOf(NoOp())
+    }
+
+    override fun captureIntend(tree: ITree, store: IDeserializingKeyValueStore) = this
+
+    inner class Applied(private val originalConcept: IConceptReference?) : AbstractOperation.Applied(), IAppliedOperation {
+        override fun getOriginalOp(): IOperation = this@SetConceptOp
+
+        override fun invert(): List<IOperation> = listOf(SetConceptOp(nodeId, originalConcept))
+
+        override fun toString(): String = "${super.toString()}, originalConcept: $originalConcept"
+    }
+}
diff --git a/model-datastructure/src/jvmMain/kotlin/org/modelix/model/InMemoryModel.kt b/model-datastructure/src/jvmMain/kotlin/org/modelix/model/InMemoryModel.kt
@@ -317,6 +317,10 @@ data class InMemoryNode(val model: InMemoryModel, val nodeId: Long) : INode, INo
         throw UnsupportedOperationException("read-only")
     }
 
+    override fun replaceNode(concept: ConceptReference): INode {
+        throw UnsupportedOperationException("read-only")
+    }
+
     override fun removeChild(child: INode) {
         throw UnsupportedOperationException("read-only")
     }
diff --git a/modelql-client/src/commonMain/kotlin/org/modelix/modelql/client/ModelQLNode.kt b/modelql-client/src/commonMain/kotlin/org/modelix/modelql/client/ModelQLNode.kt
@@ -149,6 +149,10 @@ abstract class ModelQLNode(val client: ModelQLClient) : INode, ISupportsModelQL,
         return addNewChild(resolveChildLinkOrFallback(role), index, concept)
     }
 
+    override fun replaceNode(concept: ConceptReference): INode {
+        throw UnsupportedOperationException("ModelQL currently does not support replacing nodes.")
+    }
+
     override fun removeChild(child: INode) {
         blockingQuery { child.reference.asMono().resolve().remove() }
     }
diff --git a/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/IDefaultNodeAdapter.kt b/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/IDefaultNodeAdapter.kt
@@ -16,6 +16,7 @@
 
 package org.modelix.model.mpsadapters
 
+import org.modelix.model.api.ConceptReference
 import org.modelix.model.api.IChildLink
 import org.modelix.model.api.IConcept
 import org.modelix.model.api.IConceptReference
@@ -96,4 +97,8 @@ interface IDefaultNodeAdapter : IDeprecatedNodeDefaults {
         val link = child.getContainmentLink() ?: error("ContainmentLink not found for node $child")
         throw UnsupportedOperationException("Cannot remove child in link $link of concept $concept.")
     }
+
+    override fun replaceNode(concept: ConceptReference): INode {
+        throw UnsupportedOperationException("Node replacement is not possible for node: $this")
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -455,6 +455,10 @@ class LightModelClient internal constructor(`
`455`	`455`	`}`
`456`	`456`	`}`
`457`	`457`
	`458`	`+ override fun replaceNode(concept: ConceptReference): INode {`
	`459`	`+ TODO("Not yet implemented")`
	`460`	`+ }`
	`461`	`+`
`458`	`462`	`override fun removeChild(child: INode) {`
`459`	`463`	`require(child is NodeAdapter && child.getClient() == getClient()) { "Unsupported child type: $child" }`
`460`	`464`	`requiresWrite {`
Original file line number	Diff line number	Diff line change
`@@ -138,6 +138,10 @@ class TreePointer(private var tree_: ITree, val idGenerator: IIdGenerator = IdGe`
`138`	`138`	`tree = tree.addNewChildren(parentId, role, index, childIds, concepts)`
`139`	`139`	`}`
`140`	`140`
	`141`	`+ override fun setConcept(nodeId: Long, concept: IConceptReference?) {`
	`142`	`+ tree = tree.setConcept(nodeId, concept)`
	`143`	`+ }`
	`144`	`+`
`141`	`145`	`override fun deleteNode(nodeId: Long) {`
`142`	`146`	`tree = tree.deleteNode(nodeId)`
`143`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`*/`
`14`	`14`	`package org.modelix.model.area`
`15`	`15`
	`16`	`+import org.modelix.model.api.ConceptReference`
`16`	`17`	`import org.modelix.model.api.IBranch`
`17`	`18`	`import org.modelix.model.api.IConcept`
`18`	`19`	`import org.modelix.model.api.IConceptReference`
`@@ -163,6 +164,10 @@ class CompositeArea : IArea {`
`163`	`164`	`throw UnsupportedOperationException("Read only. Create a new CompositeArea instance instead.")`
`164`	`165`	`}`
`165`	`166`
	`167`	`+ override fun replaceNode(concept: ConceptReference): INode {`
	`168`	`+ throw UnsupportedOperationException("Root cannot have a concept.")`
	`169`	`+ }`
	`170`	`+`
`166`	`171`	`override fun removeChild(child: INode) {`
`167`	`172`	`throw UnsupportedOperationException("Read only. Create a new CompositeArea instance instead.")`
`168`	`173`	`}`
`@@ -219,6 +224,8 @@ class CompositeArea : IArea {`
`219`	`224`	`return node.getChildren(role).map { NodeWrapper(it) }`
`220`	`225`	`}`
`221`	`226`
	`227`	`+ override fun replaceNode(concept: ConceptReference): INode = NodeWrapper(node.replaceNode(concept))`
	`228`	`+`
`222`	`229`	`override fun removeChild(child: INode) {`
`223`	`230`	`node.removeChild(unwrapNode(child))`
`224`	`231`	`}`