feat(model-api): introduced INodeResolutionScope and deprecated INodeReferenceSerializer

Author: slisson

model-api/build.gradle.kts

@@ -44,6 +44,7 @@ kotlin {
                 implementation(kotlin("stdlib-common"))
                 implementation(libs.kotlin.logging)
                 implementation(libs.kotlin.serialization.json)
+                implementation(libs.kotlin.coroutines.core)
             }
         }
         val commonTest by getting {
@@ -55,18 +56,19 @@ kotlin {
         val jvmMain by getting {
             dependencies {
                 implementation(kotlin("stdlib-jdk8"))
+                implementation(libs.kotlin.coroutines.core)
             }
         }
         val jvmTest by getting {
             dependencies {
                 implementation(kotlin("test"))
-                implementation(kotlin("test-junit"))
             }
         }
         val jsMain by getting {
             dependencies {
                 implementation(kotlin("stdlib-js"))
                 api(npm("@modelix/ts-model-api", rootDir.resolve("ts-model-api")))
+                implementation(libs.kotlin.coroutines.core)
             }
             kotlin.srcDir(rootDir.resolve("ts-model-api").resolve("build/dukat"))
         }

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

@@ -15,6 +15,13 @@
 
 package org.modelix.model.api
 
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
 import org.modelix.model.area.IArea
 
 /**
@@ -23,12 +30,37 @@ import org.modelix.model.area.IArea
  * The relation between an [INodeReference] and an [INode] is n to 1.
  * Two [INodeReference]s that are not equal can resolve to the same [INode].
  */
+@Serializable(with = NodeReferenceKSerializer::class)
 interface INodeReference {
     /**
      * Tries to find the referenced node in the given [IArea].
      *
      * @param area area to be searched in
      * @return the node, or null if the node could not be found
      */
-    fun resolveNode(area: IArea?): INode?
+    @Deprecated("use .resolveIn(INodeResolutionScope)", ReplaceWith("resolveIn(area!!)"))
+    fun resolveNode(area: IArea?): INode? = resolveIn(area as INodeResolutionScope)
+
+    fun serialize(): String = INodeReferenceSerializer.serialize(this)
+}
+
+fun INodeReference.resolveIn(scope: INodeResolutionScope): INode? {
+    if (this is NodeReference) {
+        val deserialized = INodeReferenceSerializer.tryDeserialize(serialized)
+        if (deserialized != null) return deserialized.resolveIn(scope)
+    }
+    return scope.resolveNode(this)
+}
+
+class NodeReferenceKSerializer : KSerializer<INodeReference> {
+    override fun deserialize(decoder: Decoder): INodeReference {
+        val serialized = decoder.decodeString()
+        return INodeReferenceSerializer.tryDeserialize(serialized) ?: SerializedNodeReference(serialized)
+    }
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("modelix.INodeReference", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: INodeReference) {
+        encoder.encodeString(value.serialize())
+    }
 }

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

@@ -5,6 +5,7 @@ import kotlin.reflect.KClass
 /**
  * Serializer for [INodeReference]s.
  */
+@Deprecated("INodeResolutionScope.resolveNode(INodeReference) is now responsible for deserializing supported references")
 interface INodeReferenceSerializer {
 
     /**
@@ -96,6 +97,10 @@ interface INodeReferenceSerializer {
         }
 
         fun deserialize(serialized: String): INodeReference {
+            return tryDeserialize(serialized) ?: SerializedNodeReference(serialized)
+        }
+
+        fun tryDeserialize(serialized: String): INodeReference? {
             val parts = serialized.split(INodeReferenceSerializerEx.SEPARATOR, limit = 2)
             if (parts.size == 2) {
                 val deserializer = deserializerForPrefix[parts[0]]
@@ -105,11 +110,11 @@ interface INodeReferenceSerializer {
             }
 
             return legacySerializers.map { it.deserialize(serialized) }.firstOrNull { it != null }
-                ?: throw RuntimeException("No deserializer found for: $serialized")
         }
     }
 }
 
+@Deprecated("INodeResolutionScope.resolveNode(INodeReference) is now responsible for deserializing supported references")
 interface INodeReferenceSerializerEx : INodeReferenceSerializer {
     val prefix: String
     val supportedReferenceClasses: Set<KClass<out INodeReference>>

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

@@ -0,0 +1,42 @@
+package org.modelix.model.api
+
+import kotlin.coroutines.CoroutineContext
+
+interface INodeResolutionScope : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*>
+        get() = Key
+
+    fun resolveNode(ref: INodeReference): INode?
+
+    companion object Key : CoroutineContext.Key<INodeResolutionScope>
+
+    override fun plus(context: CoroutineContext): CoroutineContext {
+        // coroutines are not compiled with -Xjvm-default=all-compatibility
+        // to not break existing IAreas implemented in Java, this override is necessary
+        return super.plus(context)
+    }
+
+    override fun <R> fold(initial: R, operation: (R, CoroutineContext.Element) -> R): R {
+        // coroutines are not compiled with -Xjvm-default=all-compatibility
+        // to not break existing IAreas implemented in Java, this override is necessary
+        return super.fold(initial, operation)
+    }
+
+    override fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E? {
+        // coroutines are not compiled with -Xjvm-default=all-compatibility
+        // to not break existing IAreas implemented in Java, this override is necessary
+        return super.get(key)
+    }
+
+    override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext {
+        // coroutines are not compiled with -Xjvm-default=all-compatibility
+        // to not break existing IAreas implemented in Java, this override is necessary
+        return super.minusKey(key)
+    }
+}
+
+class CompositeNodeResolutionScope(val scopes: List<INodeResolutionScope>) : INodeResolutionScope {
+    override fun resolveNode(ref: INodeReference): INode? {
+        return scopes.asSequence().mapNotNull { it.resolveNode(ref) }.firstOrNull()
+    }
+}

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

@@ -1,9 +1,8 @@
 package org.modelix.model.api
 
-import org.modelix.model.area.IArea
+@Deprecated("renamed to NodeReference", ReplaceWith("NodeReference"))
+typealias SerializedNodeReference = NodeReference
 
-data class SerializedNodeReference(val serialized: String) : INodeReference {
-    override fun resolveNode(area: IArea?): INode? {
-        return INodeReferenceSerializer.deserialize(serialized).resolveNode(area)
-    }
+data class NodeReference(val serialized: String) : INodeReference {
+    override fun serialize(): String = serialized
 }

model-api/src/commonMain/kotlin/org/modelix/model/area/IArea.kt

@@ -22,7 +22,7 @@ import org.modelix.model.api.*
  * It's like a unix filesystem with mount points. The model inside an area can also be an MPS model that is not a
  * persistent data structure.
  */
-interface IArea {
+interface IArea : INodeResolutionScope {
     /**
      * The root of an area is not allowed to change
      */
@@ -37,7 +37,7 @@ interface IArea {
      *
      * This method requires resolveNode().getNode() == this
      */
-    fun resolveNode(ref: INodeReference): INode?
+    override fun resolveNode(ref: INodeReference): INode?
 
     /**
      * This method allows resolveOriginalNode().getArea() != this