chore(model-datastructure): nullability in Hamt change visitor

slisson · slisson · commit 383be43012dc · 2024-02-20T11:27:26.000+01:00
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
@@ -444,23 +444,23 @@ class CLTree : ITree, IBulkTree {
                     return changesOnly
                 }
 
-                override fun entryAdded(key: Long, value: KVEntryReference<CPNode>?) {
+                override fun entryAdded(key: Long, value: KVEntryReference<CPNode>) {
                     if (visitor is ITreeChangeVisitorEx) {
                         createElement(value, bulkQuery).map { element ->
                             visitor.nodeAdded(element!!.id)
                         }
                     }
                 }
 
-                override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>?) {
+                override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>) {
                     if (visitor is ITreeChangeVisitorEx) {
                         oldVersion.createElement(value, bulkQuery).map { element ->
                             visitor.nodeRemoved(element!!.id)
                         }
                     }
                 }
 
-                override fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>?, newValue: KVEntryReference<CPNode>?) {
+                override fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>, newValue: KVEntryReference<CPNode>) {
                     oldVersion.createElement(oldValue, bulkQuery).map { oldElement ->
                         createElement(newValue, bulkQuery).map { newElement ->
                             if (oldElement!!::class != newElement!!::class) {
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLVersion.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLVersion.kt
@@ -344,19 +344,19 @@ private fun computeDelta(keyValueStore: IKeyValueStore, versionHash: String, bas
                 oldTree.nodesMap!!,
                 object : CPHamtNode.IChangeVisitor {
                     override fun visitChangesOnly(): Boolean = false
-                    override fun entryAdded(key: Long, value: KVEntryReference<CPNode>?) {
+                    override fun entryAdded(key: Long, value: KVEntryReference<CPNode>) {
                         changedNodeIds += key
                         if (value != null) bulkQuery.get(value)
                     }
 
-                    override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>?) {
+                    override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>) {
                         changedNodeIds += key
                     }
 
                     override fun entryChanged(
                         key: Long,
-                        oldValue: KVEntryReference<CPNode>?,
-                        newValue: KVEntryReference<CPNode>?,
+                        oldValue: KVEntryReference<CPNode>,
+                        newValue: KVEntryReference<CPNode>,
                     ) {
                         changedNodeIds += key
                         if (newValue != null) bulkQuery.get(newValue)
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtInternal.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtInternal.kt
@@ -169,7 +169,7 @@ class CPHamtInternal(
         return create(newBitmap, newChildren)
     }
 
-    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {
+    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {
         return bulkQuery.map(data.children.asIterable()) { bulkQuery.get(it) }.mapBulk { children ->
             bulkQuery.map(children) { it!!.visitEntries(bulkQuery, visitor) }.map { }
         }
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtLeaf.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtLeaf.kt
@@ -67,7 +67,7 @@ class CPHamtLeaf(
         return bulkQuery.constant(if (key == this.key) value else null)
     }
 
-    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {
+    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {
         return bulkQuery.constant(visitor(key, value))
     }
 
@@ -83,17 +83,18 @@ class CPHamtLeaf(
             }
         } else {
             var oldValue: KVEntryReference<CPNode>? = null
-            val bp = { k: Long?, v: KVEntryReference<CPNode>? ->
+            val bp = { k: Long, v: KVEntryReference<CPNode> ->
                 if (k == key) {
                     oldValue = v
                 } else {
-                    visitor.entryRemoved(k!!, v)
+                    visitor.entryRemoved(k, v)
                 }
             }
             oldNode!!.visitEntries(bulkQuery, bp).onSuccess {
+                val oldValue = oldValue
                 if (oldValue == null) {
                     visitor.entryAdded(key, value)
-                } else if (oldValue?.getHash() !== value.getHash()) {
+                } else if (oldValue.getHash() !== value.getHash()) {
                     visitor.entryChanged(key, oldValue, value)
                 }
             }
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtNode.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtNode.kt
@@ -69,14 +69,14 @@ abstract class CPHamtNode : IKVValue {
     abstract fun get(key: Long, shift: Int, bulkQuery: IBulkQuery): IBulkQuery.Value<KVEntryReference<CPNode>?>
     abstract fun put(key: Long, value: KVEntryReference<CPNode>?, shift: Int, store: IDeserializingKeyValueStore): CPHamtNode?
     abstract fun remove(key: Long, shift: Int, store: IDeserializingKeyValueStore): CPHamtNode?
-    abstract fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit>
+    abstract fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit>
     abstract fun visitChanges(oldNode: CPHamtNode?, shift: Int, visitor: IChangeVisitor, bulkQuery: IBulkQuery)
     fun visitChanges(oldNode: CPHamtNode?, visitor: IChangeVisitor, bulkQuery: IBulkQuery) = visitChanges(oldNode, 0, visitor, bulkQuery)
     interface IChangeVisitor {
         fun visitChangesOnly(): Boolean
-        fun entryAdded(key: Long, value: KVEntryReference<CPNode>?)
-        fun entryRemoved(key: Long, value: KVEntryReference<CPNode>?)
-        fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>?, newValue: KVEntryReference<CPNode>?)
+        fun entryAdded(key: Long, value: KVEntryReference<CPNode>)
+        fun entryRemoved(key: Long, value: KVEntryReference<CPNode>)
+        fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>, newValue: KVEntryReference<CPNode>)
     }
 
     companion object {
diff --git a/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtSingle.kt b/model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPHamtSingle.kt
@@ -112,7 +112,7 @@ class CPHamtSingle(
         return bulkQuery[child].map { childData -> childData!! }
     }
 
-    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {
+    override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {
         return getChild(bulkQuery).mapBulk { it.visitEntries(bulkQuery, visitor) }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -444,23 +444,23 @@ class CLTree : ITree, IBulkTree {`
`444`	`444`	`return changesOnly`
`445`	`445`	`}`
`446`	`446`
`447`		`- override fun entryAdded(key: Long, value: KVEntryReference<CPNode>?) {`
	`447`	`+ override fun entryAdded(key: Long, value: KVEntryReference<CPNode>) {`
`448`	`448`	`if (visitor is ITreeChangeVisitorEx) {`
`449`	`449`	`createElement(value, bulkQuery).map { element ->`
`450`	`450`	`visitor.nodeAdded(element!!.id)`
`451`	`451`	`}`
`452`	`452`	`}`
`453`	`453`	`}`
`454`	`454`
`455`		`- override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>?) {`
	`455`	`+ override fun entryRemoved(key: Long, value: KVEntryReference<CPNode>) {`
`456`	`456`	`if (visitor is ITreeChangeVisitorEx) {`
`457`	`457`	`oldVersion.createElement(value, bulkQuery).map { element ->`
`458`	`458`	`visitor.nodeRemoved(element!!.id)`
`459`	`459`	`}`
`460`	`460`	`}`
`461`	`461`	`}`
`462`	`462`
`463`		`- override fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>?, newValue: KVEntryReference<CPNode>?) {`
	`463`	`+ override fun entryChanged(key: Long, oldValue: KVEntryReference<CPNode>, newValue: KVEntryReference<CPNode>) {`
`464`	`464`	`oldVersion.createElement(oldValue, bulkQuery).map { oldElement ->`
`465`	`465`	`createElement(newValue, bulkQuery).map { newElement ->`
`466`	`466`	`if (oldElement!!::class != newElement!!::class) {`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ class CPHamtInternal(`
`169`	`169`	`return create(newBitmap, newChildren)`
`170`	`170`	`}`
`171`	`171`
`172`		`- override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {`
	`172`	`+ override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {`
`173`	`173`	`return bulkQuery.map(data.children.asIterable()) { bulkQuery.get(it) }.mapBulk { children ->`
`174`	`174`	`bulkQuery.map(children) { it!!.visitEntries(bulkQuery, visitor) }.map { }`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ class CPHamtLeaf(`
`67`	`67`	`return bulkQuery.constant(if (key == this.key) value else null)`
`68`	`68`	`}`
`69`	`69`
`70`		`- override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {`
	`70`	`+ override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {`
`71`	`71`	`return bulkQuery.constant(visitor(key, value))`
`72`	`72`	`}`
`73`	`73`
`@@ -83,17 +83,18 @@ class CPHamtLeaf(`
`83`	`83`	`}`
`84`	`84`	`} else {`
`85`	`85`	`var oldValue: KVEntryReference<CPNode>? = null`
`86`		`- val bp = { k: Long?, v: KVEntryReference<CPNode>? ->`
	`86`	`+ val bp = { k: Long, v: KVEntryReference<CPNode> ->`
`87`	`87`	`if (k == key) {`
`88`	`88`	`oldValue = v`
`89`	`89`	`} else {`
`90`		`- visitor.entryRemoved(k!!, v)`
	`90`	`+ visitor.entryRemoved(k, v)`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`oldNode!!.visitEntries(bulkQuery, bp).onSuccess {`
	`94`	`+ val oldValue = oldValue`
`94`	`95`	`if (oldValue == null) {`
`95`	`96`	`visitor.entryAdded(key, value)`
`96`		`- } else if (oldValue?.getHash() !== value.getHash()) {`
	`97`	`+ } else if (oldValue.getHash() !== value.getHash()) {`
`97`	`98`	`visitor.entryChanged(key, oldValue, value)`
`98`	`99`	`}`
`99`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ class CPHamtSingle(`
`112`	`112`	`return bulkQuery[child].map { childData -> childData!! }`
`113`	`113`	`}`
`114`	`114`
`115`		`- override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>?) -> Unit): IBulkQuery.Value<Unit> {`
	`115`	`+ override fun visitEntries(bulkQuery: IBulkQuery, visitor: (Long, KVEntryReference<CPNode>) -> Unit): IBulkQuery.Value<Unit> {`
`116`	`116`	`return getChild(bulkQuery).mapBulk { it.visitEntries(bulkQuery, visitor) }`
`117`	`117`	`}`
`118`	`118`