fix(model-datastructure): use the ObjectHash instead of the version ID

In addition to the hash a version also had a generated ID, but

Author: slisson

datastructures/src/commonMain/kotlin/org/modelix/datastructures/objects/ObjectHash.kt

@@ -5,7 +5,7 @@ import org.modelix.kotlin.utils.base64UrlEncoded
 import kotlin.jvm.JvmInline
 
 @JvmInline
-value class ObjectHash(private val hash: String) {
+value class ObjectHash(private val hash: String) : Comparable<ObjectHash> {
     init {
         require(isValidHashString(hash)) { "Not an object hash: $hash" }
     }
@@ -14,6 +14,10 @@ value class ObjectHash(private val hash: String) {
         return hash
     }
 
+    override fun compareTo(other: ObjectHash): Int {
+        return hash.compareTo(other.hash)
+    }
+
     companion object {
         val HASH_PATTERN = Regex("""[a-zA-Z0-9\-_]{5}\*[a-zA-Z0-9\-_]{38}""")
 

model-client/src/jvmMain/kotlin/org/modelix/model/client/ReplicatedRepository.kt

@@ -124,9 +124,9 @@ actual open class ReplicatedRepository actual constructor(
                             LOG.debug {
                                 String.format(
                                     "Merged local %s with remote %s -> %s",
-                                    newLocalVersion.hash,
-                                    remoteBase!!.hash,
-                                    mergedVersion.hash,
+                                    newLocalVersion.getObjectHash().toString(),
+                                    remoteBase!!.getObjectHash().toString(),
+                                    mergedVersion.getObjectHash().toString(),
                                 )
                             }
                         } catch (ex: Exception) {
@@ -163,7 +163,7 @@ actual open class ReplicatedRepository actual constructor(
 
     protected fun writeRemoteVersion(newVersion: CLVersion) {
         synchronized(mergeLock) {
-            if (remoteVersion!!.hash != newVersion.hash) {
+            if (remoteVersion!!.getObjectHash() != newVersion.getObjectHash()) {
                 remoteVersion = newVersion
                 client.asyncStore.put(branchReference.getKey(), newVersion.getContentHash())
             }
@@ -271,9 +271,9 @@ actual open class ReplicatedRepository actual constructor(
                                 LOG.debug(
                                     String.format(
                                         "Merged remote %s with local %s -> %s",
-                                        newRemoteVersion.hash,
-                                        localBase.value!!.hash,
-                                        mergedVersion.hash,
+                                        newRemoteVersion.getObjectHash().toString(),
+                                        localBase.value!!.getObjectHash().toString(),
+                                        mergedVersion.getObjectHash().toString(),
                                     ),
                                 )
                             }

model-datastructure/src/commonMain/kotlin/org/modelix/model/LinearHistory.kt

@@ -24,7 +24,7 @@ class LinearHistory(private val baseVersionHash: String?) {
     private val byVersionDistanceFromGlobalRoot = mutableMapOf<CLVersion, Int>()
 
     /**
-     * Returns all versions between the [fromVersions] (inclusive) and a common version (inclusive).
+     * Returns all versions between the [fromVersions] (inclusive) and a common version (exclusive).
      * The common version may be identified by [baseVersionHash].
      * If no [baseVersionHash] is given, the common version will be the first version
      * aka the version without a [CLVersion.baseVersion].
@@ -70,7 +70,7 @@ class LinearHistory(private val baseVersionHash: String?) {
         // Sorting the subtree roots by distance from base ensures topological order.
         val comparator = compareBy(byVersionDistanceFromGlobalRoot::getValue)
             // Sorting the subtree roots by distance from base and then by id ensures "monotonic" order.
-            .thenBy(CLVersion::id)
+            .thenBy(CLVersion::getObjectHash)
         val rootsOfSubtreesToVisit = globalRoot + byVersionDistanceFromGlobalRoot.keys.filter(CLVersion::isMerge)
         val orderedRootsOfSubtree = rootsOfSubtreesToVisit.distinct().sortedWith(comparator)
 
@@ -85,7 +85,7 @@ class LinearHistory(private val baseVersionHash: String?) {
                 val childrenWithoutMerges = children.filterNot(CLVersion::isMerge)
                 // Order so that child with the lowest id is processed first
                 // and comes first in the history.
-                stack.addAll(childrenWithoutMerges.sortedByDescending(CLVersion::id))
+                stack.addAll(childrenWithoutMerges.sortedByDescending(CLVersion::getObjectHash))
             }
             historyOfSubtree
         }
@@ -102,11 +102,11 @@ class LinearHistory(private val baseVersionHash: String?) {
             while (stack.isNotEmpty()) {
                 val version = stack.last()
                 val parents = version.getParents()
-                // Version is the base version or the first version and therfore a root.
+                // Version is the base version or the first version and therefore a root.
                 if (parents.isEmpty()) {
                     stack.removeLast()
                     globalRoot.add(version)
-                    byVersionDistanceFromGlobalRoot[version] = 0
+                    byVersionDistanceFromGlobalRoot[version] = if (version.getObjectHash().toString() == baseVersionHash) 0 else 1
                 } else {
                     parents.forEach { parent ->
                         byVersionChildren.getOrPut(parent, ::mutableSetOf).add(version)

model-datastructure/src/commonMain/kotlin/org/modelix/model/VersionMerger.kt

@@ -1,5 +1,6 @@
 package org.modelix.model
 
+import org.modelix.datastructures.objects.ObjectHash
 import org.modelix.model.api.IIdGenerator
 import org.modelix.model.async.IAsyncObjectStore
 import org.modelix.model.lazy.CLVersion
@@ -24,7 +25,7 @@ class VersionMerger(private val idGenerator: IIdGenerator) {
         require(lastMergedVersion.graph == newVersion.graph) {
             "Versions are part of different object graphs: $lastMergedVersion, $newVersion"
         }
-        if (newVersion.hash == lastMergedVersion.hash) {
+        if (newVersion.getObjectHash() == lastMergedVersion.getObjectHash()) {
             return lastMergedVersion
         }
         checkRepositoryIds(lastMergedVersion, newVersion)
@@ -40,31 +41,31 @@ class VersionMerger(private val idGenerator: IIdGenerator) {
         }
     }
 
-    private fun collectLatestNonMerges(version: CLVersion?, visited: MutableSet<String>, result: MutableSet<Long>) {
+    private fun collectLatestNonMerges(version: CLVersion?, visited: MutableSet<ObjectHash>, result: MutableSet<ObjectHash>) {
         if (version == null) return
-        if (!visited.add(version.getContentHash())) return
+        if (!visited.add(version.getObjectHash())) return
         if (version.isMerge()) {
             collectLatestNonMerges(version.getMergedVersion1(), visited, result)
             collectLatestNonMerges(version.getMergedVersion2(), visited, result)
         } else {
-            result.add(version.id)
+            result.add(version.getObjectHash())
         }
     }
 
     protected fun mergeHistory(leftVersion: CLVersion, rightVersion: CLVersion): CLVersion {
-        if (leftVersion.hash == rightVersion.hash) return leftVersion
+        if (leftVersion.getObjectHash() == rightVersion.getObjectHash()) return leftVersion
         val commonBase = requireNotNull(commonBaseVersion(leftVersion, rightVersion)) {
             "Cannot merge versions without a common base: $leftVersion, $rightVersion"
         }
         if (commonBase.getContentHash() == leftVersion.getContentHash()) return rightVersion
         if (commonBase.getContentHash() == rightVersion.getContentHash()) return leftVersion
 
-        val leftNonMerges = HashSet<Long>().also { collectLatestNonMerges(leftVersion, HashSet(), it) }
-        val rightNonMerges = HashSet<Long>().also { collectLatestNonMerges(rightVersion, HashSet(), it) }
+        val leftNonMerges = HashSet<ObjectHash>().also { collectLatestNonMerges(leftVersion, HashSet(), it) }
+        val rightNonMerges = HashSet<ObjectHash>().also { collectLatestNonMerges(rightVersion, HashSet(), it) }
         if (leftNonMerges == rightNonMerges) {
             // If there is no actual change on both sides, but they just did the same merge, we have to pick one
             // of them, otherwise both sides will continue creating merges forever.
-            return if (leftVersion.id < rightVersion.id) leftVersion else rightVersion
+            return if (leftVersion.getObjectHash() < rightVersion.getObjectHash()) leftVersion else rightVersion
         }
 
         val versionsToApply = filterUndo(LinearHistory(commonBase.getContentHash()).load(leftVersion, rightVersion))
@@ -104,7 +105,7 @@ class VersionMerger(private val idGenerator: IIdGenerator) {
                 .build()
         }
         if (mergedVersion == null) {
-            throw RuntimeException("Failed to merge ${leftVersion.hash} and ${rightVersion.hash}")
+            throw RuntimeException("Failed to merge ${leftVersion.getObjectHash()} and ${rightVersion.getObjectHash()}")
         }
         return mergedVersion
     }
@@ -131,7 +132,7 @@ class VersionMerger(private val idGenerator: IIdGenerator) {
         val operations = version.operations.toList()
         if (operations.isEmpty()) return listOf()
         val baseVersion = version.baseVersion
-            ?: throw RuntimeException("Version ${version.hash} has operations but no baseVersion")
+            ?: throw RuntimeException("Version ${version.getObjectHash()} has operations but no baseVersion")
         val tree = baseVersion.getModelTree()
         val mutableTree = tree.asMutableSingleThreaded()
         return mutableTree.runWrite {

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

@@ -61,6 +61,7 @@ class CLVersion(val obj: Object<CPVersion>) : IVersion {
     val author: String?
         get() = data.author
 
+    @Deprecated("Use the ObjectHash instead. New versions of Modelix may set this to 0 and not generate actual IDs.")
     val id: Long
         get() = data.id
 
@@ -79,7 +80,7 @@ class CLVersion(val obj: Object<CPVersion>) : IVersion {
         return null
     }
 
-    @Deprecated("Use getContentHash()", ReplaceWith("getContentHash()"))
+    @Deprecated("Use getObjectHash()", ReplaceWith("getObjectHash()"))
     val hash: String
         get() = getContentHash()
 

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

@@ -1,5 +1,6 @@
 package org.modelix.model.lazy
 
+import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import org.modelix.datastructures.model.IModelTree
 import org.modelix.datastructures.objects.IObjectGraph
@@ -30,10 +31,13 @@ class VersionBuilder {
     private var numberOfOperations: Int = 0
     private var graph: IObjectGraph? = null
 
+    @Deprecated("Not mandatory anymore. Usages of the ID should be replaced by the ObjectHash.")
     fun id(value: Long) = also { this.id = value }
+
     fun author(value: String?) = also { this.author = value }
     fun time(value: String?) = also { this.time = value }
     fun time(value: Instant) = time(value.epochSeconds.toString())
+    fun currentTime() = time(Clock.System.now())
     fun tree(type: TreeType, value: Object<CPTree>) = also {
         this.treeRefs[type] = value
         if (it.graph == null) it.graph = value.graph
@@ -44,12 +48,13 @@ class VersionBuilder {
     fun graph(value: IObjectGraph?) = also { it.graph = value }
 
     fun regularUpdate(baseVersion: IVersion) = regularUpdate((baseVersion as CLVersion).obj.ref)
+    fun baseVersion(baseVersion: IVersion?) = regularUpdate((baseVersion as CLVersion?)?.obj?.ref)
 
-    fun regularUpdate(baseVersion: ObjectReference<CPVersion>) = also {
+    fun regularUpdate(baseVersion: ObjectReference<CPVersion>?) = also {
         it.baseVersion = baseVersion
         it.mergedVersion1 = null
         it.mergedVersion2 = null
-        if (it.graph == null) it.graph = baseVersion.graph
+        if (baseVersion != null && it.graph == null) it.graph = baseVersion.graph
     }
 
     fun autoMerge(commonBase: ObjectReference<CPVersion>, version1: ObjectReference<CPVersion>, version2: ObjectReference<CPVersion>) = also {
@@ -80,7 +85,7 @@ class VersionBuilder {
     }
 
     fun buildData() = CPVersion(
-        id = checkNotNull(id) { "id not specified" },
+        id = id ?: 0,
         time = time,
         author = author,
         treeRefs = treeRefs.also {

model-datastructure/src/commonMain/kotlin/org/modelix/model/operations/RevertToOp.kt

@@ -48,7 +48,7 @@ class RevertToOp(val latestKnownVersionRef: ObjectReference<CPVersion>, val vers
         val result = mutableListOf<IOperation>()
         val commonBase = VersionMerger.commonBaseVersion(latestKnownVersion, versionToRevertTo)
         result += getPath(latestKnownVersion, commonBase).map { UndoOp(it.resolvedData.ref) }
-        if (commonBase == null || commonBase.hash != versionToRevertTo.hash) {
+        if (commonBase == null || commonBase.getObjectHash() != versionToRevertTo.getObjectHash()) {
             // redo operations on a branch
             result += getPath(versionToRevertTo, commonBase).reversed().flatMap { it.operations }
         }
@@ -58,7 +58,7 @@ class RevertToOp(val latestKnownVersionRef: ObjectReference<CPVersion>, val vers
     private fun getPath(newerVersion: CLVersion, olderVersionExclusive: CLVersion?): List<CLVersion> {
         val result = mutableListOf<CLVersion>()
         var v = newerVersion
-        while (olderVersionExclusive == null || v.hash != olderVersionExclusive.hash) {
+        while (olderVersionExclusive == null || v.getObjectHash() != olderVersionExclusive.getObjectHash()) {
             result += v
             v = v.baseVersion ?: break
         }

model-datastructure/src/commonMain/kotlin/org/modelix/model/persistent/CPVersion.kt

@@ -18,7 +18,14 @@ import org.modelix.model.persistent.SerializationUtil.unescape
 import org.modelix.streams.IStream
 
 data class CPVersion(
+    /**
+     * This ID was used in earlier versions where merges were done by rebasing.
+     * After supporting a non-linear history where the two merged versions are recorded and stay part of the history
+     * with their original ObjectHash, this ID isn't necessary anymore.
+     */
+    @Deprecated("Use the ObjectHash instead")
     val id: Long,
+
     val time: String?,
     val author: String?,
 

model-datastructure/src/commonTest/kotlin/LinearHistoryTest.kt

@@ -43,7 +43,7 @@ class LinearHistoryTest {
         val v20 = version(20, null)
         val v21 = version(21, null)
 
-        assertHistory(v20, v21, listOf(v20, v21))
+        assertHistory(v20, v21, listOf(v21, v20))
     }
 
     @Test
@@ -52,7 +52,7 @@ class LinearHistoryTest {
         val v20 = version(20, v10)
         val v21 = version(21, v10)
 
-        assertHistory(v20, v21, listOf(v20, v21))
+        assertHistory(v20, v21, listOf(v21, v20))
     }
 
     @Test
@@ -69,14 +69,26 @@ class LinearHistoryTest {
 
     @Test
     fun correctHistoryIfIdsAreNotAscending() {
+        /**
+         *           v1
+         *          /  \
+         *        v2    v3
+         *       /  \  /
+         *     v9   v4
+         *     |    |
+         *    v8    |
+         *     \   /
+         *       x
+         */
+
         val v1 = version(1, null)
         val v2 = version(2, v1)
         val v3 = version(3, v1)
         val v9 = version(9, v2)
         val v4 = merge(4, v2, v3)
         val v8 = version(8, v9)
 
-        val expected = listOf(v2, v9, v8, v3)
+        val expected = listOf(v3, v2, v9, v8)
         assertHistory(v4, v8, expected)
     }
 
@@ -132,14 +144,11 @@ class LinearHistoryTest {
     }
 
     private fun version(id: Long, base: CLVersion?): CLVersion {
-        return CLVersion.createRegularVersion(
-            id,
-            null,
-            null,
-            initialTree,
-            base,
-            emptyArray(),
-        )
+        return CLVersion.builder()
+            .id(id)
+            .tree(initialTree)
+            .baseVersion(base)
+            .build()
     }
 
     private fun merge(id: Long, v1: CLVersion, v2: CLVersion): CLVersion {

model-datastructure/src/commonTest/kotlin/TreeSerializationTest.kt

@@ -92,7 +92,7 @@ class TreeSerializationTest {
         assertTree(tree)
         assertEquals(expectedVersionHash, versionHash) // ensures that JVM and JS targets produce the same serialized data
 
-        val deserializedVersion = CLVersion.loadFromHash(version.hash, store)
+        val deserializedVersion = CLVersion.loadFromHash(version.getObjectHash().toString(), store)
         assertTree(deserializedVersion.tree)
     }