Merge pull request #545 from modelix/clean-up-resources-in-MPSBulkSynchronizer-import

Clean up resources in MPSBulkSynchronizer import

Author: Oleksandr Dzhychko

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/ModelImporter.kt

@@ -50,7 +50,7 @@ class ModelImporter(
 ) {
 
     private val originalIdToExisting: MutableMap<String, INode> = mutableMapOf()
-    private val postponedReferences = ArrayList<() -> Unit>()
+    private val postponedReferences = mutableListOf<PostponedReference>()
     private val nodesToRemove = HashSet<INode>()
     private var numExpectedNodes = 0
     private var currentNodeProgress = 0
@@ -72,6 +72,23 @@ class ModelImporter(
         }
     }
 
+    data class PostponedReference(
+        val expectedTargetId: String,
+        val mpsNode: INode,
+        val role: String,
+    )
+
+    private fun PostponedReference.setPostponedReference() {
+        val expectedRefTarget = originalIdToExisting[expectedTargetId]
+        if (expectedRefTarget == null) {
+            // The target node is not part of the model. Assuming it exists in some other model we can
+            // store the reference and try to resolve it dynamically on access.
+            mpsNode.setReferenceTarget(role, SerializedNodeReference(expectedTargetId))
+        } else {
+            mpsNode.setReferenceTarget(role, expectedRefTarget)
+        }
+    }
+
     /**
      * Incrementally updates this importers root based on the provided [ModelData] specification.
      *
@@ -95,11 +112,7 @@ class ModelImporter(
             syncNode(root, data.root, progressReporter)
 
             logger.info { "Synchronizing references..." }
-            postponedReferences.forEach {
-                doAndPotentiallyContinueOnErrors {
-                    it.invoke()
-                }
-            }
+            postponedReferences.forEach { it.setPostponedReference() }
 
             logger.info { "Removing extra nodes..." }
             nodesToRemove.forEach {
@@ -234,16 +247,7 @@ class ModelImporter(
             if (actualTargetId != expectedTargetId) {
                 val expectedTarget = originalIdToExisting[expectedTargetId]
                 if (expectedTarget == null) {
-                    postponedReferences += {
-                        val expectedRefTarget = originalIdToExisting[expectedTargetId]
-                        if (expectedRefTarget == null) {
-                            // The target node is not part of the model. Assuming it exists in some other model we can
-                            // store the reference and try to resolve it dynamically on access.
-                            node.setReferenceTarget(it.key, SerializedNodeReference(expectedTargetId))
-                        } else {
-                            node.setReferenceTarget(it.key, expectedRefTarget)
-                        }
-                    }
+                    postponedReferences += PostponedReference(expectedTargetId, node, it.key)
                 } else {
                     node.setReferenceTarget(it.key, expectedTarget)
                 }

bulk-model-sync-lib/src/jvmMain/kotlin/org/modelix/model/sync/bulk/ModelExporter.kt

@@ -35,6 +35,8 @@ actual class ModelExporter actual constructor(private val root: INode) {
         outputFile.parentFile.mkdirs()
 
         val modelData = ModelData(root = root.asExported())
-        Json.encodeToStream(modelData, outputFile.outputStream())
+        outputFile.outputStream().use { outputStream ->
+            Json.encodeToStream(modelData, outputStream)
+        }
     }
 }

bulk-model-sync-lib/src/jvmMain/kotlin/org/modelix/model/sync/bulk/PlatformSpecific.kt

@@ -40,14 +40,11 @@ fun ModelImporter.import(jsonFile: File) {
 
 @OptIn(ExperimentalSerializationApi::class)
 fun ModelImporter.importFilesAsRootChildren(files: Collection<File>) {
-    val models: List<ModelData> = files.map {
-        Json.decodeFromStream(it.inputStream())
+    val models: List<ModelData> = files.map { file ->
+        file.inputStream().use(Json::decodeFromStream)
     }
     import(mergeModelData(models))
 }
 
 @Deprecated("use collection parameter for better performance")
-fun ModelImporter.importFilesAsRootChildren(vararg files: File) {
-    val models = files.map { ModelData.fromJson(it.readText()) }
-    import(mergeModelData(*models.toTypedArray()))
-}
+fun ModelImporter.importFilesAsRootChildren(vararg files: File) = importFilesAsRootChildren(files.asList())