feat(model-api): INode now has an ID based API and the name based is deprecated

Author: slisson

commitlint.config.js

@@ -18,5 +18,6 @@ module.exports = {
         "ts-model-api",
       ],
     ],
+    "subject-case": [0, 'never']
   },
 };

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

@@ -26,4 +26,39 @@ interface IChildLink : ILink {
 
     @Deprecated("use .targetConcept")
     val childConcept: IConcept
+
+    companion object {
+        fun fromName(name: String): IChildLink = ChildLinkFromName(name)
+    }
+}
+
+data class ChildLinkFromName(override val name: String) : LinkFromName(), IChildLink {
+    override val isMultiple: Boolean
+        get() = throw UnsupportedOperationException()
+    override val childConcept: IConcept
+        get() = throw UnsupportedOperationException()
+}
+
+object NullChildLink : IChildLink {
+    override val isMultiple: Boolean
+        get() = true
+    override val childConcept: IConcept
+        get() = throw UnsupportedOperationException()
+    override val targetConcept: IConcept
+        get() = throw UnsupportedOperationException()
+
+    override fun getConcept(): IConcept {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getUID(): String {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getSimpleName(): String {
+        throw UnsupportedOperationException()
+    }
+
+    override val isOptional: Boolean
+        get() = true
 }

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

@@ -11,3 +11,8 @@ interface ILink : IRole {
      */
     val targetConcept: IConcept
 }
+
+abstract class LinkFromName : RoleFromName(), ILink {
+    override val targetConcept: IConcept
+        get() = throw UnsupportedOperationException()
+}

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

@@ -41,6 +41,7 @@ interface INode {
     /**
      * Role of this node in its parent node if it exists,or null otherwise.
      */
+    @Deprecated("use getContainmentLink()")
     val roleInParent: String?
 
     /**
@@ -61,6 +62,7 @@ interface INode {
      * @param role the desired role
      * @return iterable over the child nodes
      */
+    @Deprecated("use IChildLink instead of String")
     fun getChildren(role: String?): Iterable<INode>
 
     /**
@@ -76,6 +78,7 @@ interface INode {
      * @param index target index within the role
      * @param child child node to be moved
      */
+    @Deprecated("use IChildLink instead of String")
     fun moveChild(role: String?, index: Int, child: INode)
 
     /**
@@ -90,6 +93,7 @@ interface INode {
      *
      * @see addNewChild
      */
+    @Deprecated("use IChildLink instead of String")
     fun addNewChild(role: String?, index: Int, concept: IConcept?): INode
 
     /**
@@ -102,6 +106,7 @@ interface INode {
      * @param concept reference to a concept, of which the new node is instance of
      * @return new child node
      */
+    @Deprecated("use IChildLink instead of String")
     fun addNewChild(role: String?, index: Int, concept: IConceptReference?): INode {
         return addNewChild(role, index, concept?.resolve())
     }
@@ -119,6 +124,7 @@ interface INode {
      * @param role the desired reference role
      * @return target node, or null if the target could not be found
      */
+    @Deprecated("use IReferenceLink instead of String")
     fun getReferenceTarget(role: String): INode?
 
     /**
@@ -127,6 +133,7 @@ interface INode {
      * @param role the desired reference role
      * @return node reference to the target, or null if the target could not be found
      */
+    @Deprecated("use IReferenceLink instead of String")
     fun getReferenceTargetRef(role: String): INodeReference? {
         return getReferenceTarget(role)?.reference
     }
@@ -137,6 +144,7 @@ interface INode {
      * @param role the desired reference role
      * @param target new target for this node's reference
      */
+    @Deprecated("use IReferenceLink instead of String")
     fun setReferenceTarget(role: String, target: INode?)
 
     /**
@@ -146,9 +154,10 @@ interface INode {
      * @param role the desired reference role
      * @param target reference to the new target for this node's reference
      */
+    @Deprecated("use IReferenceLink instead of String")
     fun setReferenceTarget(role: String, target: INodeReference?) {
         // Default implementation for backward compatibility only.
-        setReferenceTarget(role, target?.resolveNode(getArea()))
+        setReferenceTarget(role, target?.resolveIn(getArea()!!))
     }
 
     /**
@@ -157,6 +166,7 @@ interface INode {
      * @param role the desired property role
      * @return property value, or null if there is no value
      */
+    @Deprecated("use getPropertyValue(IProperty)")
     fun getPropertyValue(role: String): String?
 
     /**
@@ -165,25 +175,27 @@ interface INode {
      * @param role the desired property role
      * @param value the new property value
      */
+    @Deprecated("use setPropertyValue(IProperty, String?)")
     fun setPropertyValue(role: String, value: String?)
 
     /**
      * Returns all property roles of this node.
      *
      * @return list of all property roles
      */
+    @Deprecated("use getPropertyLinks()")
     fun getPropertyRoles(): List<String>
 
     /**
      * Returns all reference roles of this node.
      *
      * @return list of all reference roles
      */
+    @Deprecated("use getReferenceLinks()")
     fun getReferenceRoles(): List<String>
-}
 
-interface INodeEx : INode {
-    fun usesRoleIds(): Boolean
+    // <editor-fold desc="non-string based API">
+    fun usesRoleIds(): Boolean = false
     fun getContainmentLink(): IChildLink? = roleInParent?.let { role ->
         parent?.concept?.getAllChildLinks()?.find { (if (usesRoleIds()) it.getUID() else it.getSimpleName()) == role }
     }
@@ -193,10 +205,54 @@ interface INodeEx : INode {
     fun addNewChild(role: IChildLink, index: Int, concept: IConceptReference?): INode = addNewChild(role.key(this), index, concept)
     fun getReferenceTarget(link: IReferenceLink): INode? = getReferenceTarget(link.key(this))
     fun setReferenceTarget(link: IReferenceLink, target: INode?) = setReferenceTarget(link.key(this), target)
-    fun getReferenceTargetRef(role: IReferenceLink): INodeReference? = getReferenceTargetRef(role.key(this))
     fun setReferenceTarget(role: IReferenceLink, target: INodeReference?) = setReferenceTarget(role.key(this), target)
+    fun removeReference(role: IReferenceLink) = setReferenceTarget(role, null as INodeReference?)
+    fun getReferenceTargetRef(role: IReferenceLink): INodeReference? = getReferenceTargetRef(role.key(this))
     fun getPropertyValue(property: IProperty): String? = getPropertyValue(property.key(this))
     fun setPropertyValue(property: IProperty, value: String?) = setPropertyValue(property.key(this), value)
+
+    fun getReferenceLinks(): List<IReferenceLink> = getReferenceRoles().map { tryResolveReferenceLink(it) ?: ReferenceLinkFromName(it) }
+    fun getPropertyLinks(): List<IProperty> = getPropertyRoles().map { tryResolveProperty(it) ?: PropertyFromName(it) }
+    fun getAllProperties(): List<Pair<IProperty, String>> = getPropertyLinks().map { it to getPropertyValue(it) }.filterSecondNotNull()
+    fun getAllReferenceTargets(): List<Pair<IReferenceLink, INode>> = getReferenceLinks().map { it to getReferenceTarget(it) }.filterSecondNotNull()
+    fun getAllReferenceTargetRefs(): List<Pair<IReferenceLink, INodeReference>> = getReferenceLinks().map { it to getReferenceTargetRef(it) }.filterSecondNotNull()
+    // </editor-fold>
+}
+
+fun <T1, T2> List<Pair<T1, T2?>>.filterSecondNotNull(): List<Pair<T1, T2>> = filter { it.second != null } as List<Pair<T1, T2>>
+
+@Deprecated("all members moved to INode", ReplaceWith("INode"))
+interface INodeEx : INode
+
+interface IDeprecatedNodeDefaults : INode {
+    override val roleInParent: String? get() = getContainmentLink()?.getUID()
+    override fun getChildren(role: String?): Iterable<INode> = getChildren(resolveChildLinkOrFallback(role))
+    override fun moveChild(role: String?, index: Int, child: INode) = moveChild(resolveChildLinkOrFallback(role), index, child)
+    override fun addNewChild(role: String?, index: Int, concept: IConcept?): INode = addNewChild(resolveChildLinkOrFallback(role), index, concept)
+    override fun addNewChild(role: String?, index: Int, concept: IConceptReference?): INode = addNewChild(resolveChildLinkOrFallback(role), index, concept)
+    override fun getReferenceTarget(role: String): INode? = getReferenceTarget(resolveReferenceLinkOrFallback(role))
+    override fun getReferenceTargetRef(role: String): INodeReference? = getReferenceTargetRef(resolveReferenceLinkOrFallback(role))
+    override fun setReferenceTarget(role: String, target: INode?) = setReferenceTarget(resolveReferenceLinkOrFallback(role), target)
+    override fun setReferenceTarget(role: String, target: INodeReference?) = setReferenceTarget(resolveReferenceLinkOrFallback(role), target)
+    override fun getPropertyValue(role: String): String? = getPropertyValue(resolvePropertyOrFallback(role))
+    override fun setPropertyValue(role: String, value: String?) = setPropertyValue(resolvePropertyOrFallback(role), value)
+    override fun getPropertyRoles(): List<String> = getPropertyLinks().map { it.key(this) }
+    override fun getReferenceRoles(): List<String> = getReferenceLinks().map { it.key(this) }
+
+    override fun usesRoleIds(): Boolean = true
+    override fun getContainmentLink(): IChildLink?
+    override fun getChildren(link: IChildLink): Iterable<INode>
+    override fun moveChild(role: IChildLink, index: Int, child: INode)
+    override fun addNewChild(role: IChildLink, index: Int, concept: IConcept?): INode
+    override fun addNewChild(role: IChildLink, index: Int, concept: IConceptReference?): INode
+    override fun getReferenceTarget(link: IReferenceLink): INode?
+    override fun setReferenceTarget(link: IReferenceLink, target: INode?)
+    override fun setReferenceTarget(role: IReferenceLink, target: INodeReference?)
+    override fun getReferenceTargetRef(role: IReferenceLink): INodeReference?
+    override fun getPropertyValue(property: IProperty): String?
+    override fun setPropertyValue(property: IProperty, value: String?)
+    override fun getPropertyLinks(): List<IProperty>
+    override fun getReferenceLinks(): List<IReferenceLink>
 }
 
 @Deprecated("Use .key(INode), .key(IBranch), .key(ITransaction) or .key(ITree)")
@@ -214,7 +270,7 @@ fun INode.getPropertyValue(property: IProperty): String? = if (this is INodeEx)
 fun INode.setPropertyValue(property: IProperty, value: String?): Unit = if (this is INodeEx) setPropertyValue(property, value) else setPropertyValue(property.key(this), value)
 
 fun INode.getConcept(): IConcept? = getConceptReference()?.resolve()
-fun INode.getResolvedReferenceTarget(role: String): INode? = getReferenceTargetRef(role)?.resolveNode(getArea())
+fun INode.getResolvedReferenceTarget(role: String): INode? = getReferenceTargetRef(role)?.resolveIn(getArea()!!)
 fun INode.getResolvedConcept(): IConcept? = getConceptReference()?.resolve()
 
 fun INode.addNewChild(role: String?, index: Int): INode = addNewChild(role, index, null as IConceptReference?)
@@ -238,6 +294,38 @@ fun INode.resolveProperty(role: String): IProperty {
         ?: throw RuntimeException("Property '$role' not found in concept ${c.getLongName()}")
 }
 
+fun INode.tryResolveChildLink(role: String): IChildLink? {
+    val c = this.concept ?: return null
+    val allLinks = c.getAllChildLinks()
+    return allLinks.find { it.key(this) == role }
+        ?: allLinks.find { it.getSimpleName() == role }
+        ?: allLinks.find { it.getUID() == role }
+}
+fun INode.resolveChildLinkOrFallback(role: String?): IChildLink {
+    if (role == null) return NullChildLink
+    return tryResolveChildLink(role) ?: IChildLink.fromName(role)
+}
+fun INode.tryResolveReferenceLink(role: String): IReferenceLink? {
+    val c = this.concept ?: return null
+    val allLinks = c.getAllReferenceLinks()
+    return allLinks.find { it.key(this) == role }
+        ?: allLinks.find { it.getSimpleName() == role }
+        ?: allLinks.find { it.getUID() == role }
+}
+fun INode.resolveReferenceLinkOrFallback(role: String): IReferenceLink {
+    return tryResolveReferenceLink(role) ?: IReferenceLink.fromName(role)
+}
+fun INode.tryResolveProperty(role: String): IProperty? {
+    val c = this.concept ?: return null
+    val allLinks = c.getAllProperties()
+    return allLinks.find { it.key(this) == role }
+        ?: allLinks.find { it.getSimpleName() == role }
+        ?: allLinks.find { it.getUID() == role }
+}
+fun INode.resolvePropertyOrFallback(role: String): IProperty {
+    return tryResolveProperty(role) ?: IProperty.fromName(role)
+}
+
 fun INode.remove() {
     parent?.removeChild(this)
 }

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

@@ -18,4 +18,13 @@ package org.modelix.model.api
 /**
  * Representation of a property within an [IConcept].
  */
-interface IProperty : IRole
+interface IProperty : IRole {
+    companion object {
+        fun fromName(name: String): IProperty = PropertyFromName(name)
+    }
+}
+
+data class PropertyFromName(override val name: String) : RoleFromName(), IProperty {
+    override val isOptional: Boolean
+        get() = throw UnsupportedOperationException()
+}

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

@@ -18,4 +18,10 @@ package org.modelix.model.api
 /**
  * Representation of a non-containment reference link between [IConcept]s.
  */
-interface IReferenceLink : ILink
+interface IReferenceLink : ILink {
+    companion object {
+        fun fromName(name: String): IReferenceLink = ReferenceLinkFromName(name)
+    }
+}
+
+data class ReferenceLinkFromName(override val name: String) : LinkFromName(), IReferenceLink

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

@@ -61,3 +61,20 @@ object RoleAccessContext {
         return value.getValue() ?: false
     }
 }
+
+abstract class RoleFromName() : IRole {
+    override fun getConcept(): IConcept {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getUID(): String {
+        return name
+    }
+
+    override fun getSimpleName(): String {
+        return name
+    }
+
+    override val isOptional: Boolean
+        get() = throw UnsupportedOperationException()
+}

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

@@ -17,16 +17,18 @@ class SimpleChildLink(
     private val simpleName: String,
     override val isMultiple: Boolean,
     override val isOptional: Boolean,
-    override val targetConcept: IConcept
+    override val targetConcept: IConcept,
+    private val uid: String? = null
 ) : IChildLink {
     var owner: SimpleConcept? = null
     override val childConcept: IConcept = targetConcept
 
     override fun getConcept(): IConcept = owner!!
 
     override fun getUID(): String {
-        val o = owner
-        return (if (o == null) simpleName else o.getUID() + "." + simpleName)
+        return uid
+            ?: owner?.let { it.getUID() + "." + simpleName }
+            ?: simpleName
     }
 
     override fun getSimpleName(): String = simpleName

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

@@ -13,26 +13,21 @@
  */
 package org.modelix.model.api
 
-class SimpleConcept(
+open class SimpleConcept(
     private val conceptName: String,
-    private val is_abstract: Boolean,
-    directSuperConcepts: Iterable<IConcept>
+    private val is_abstract: Boolean = false,
+    directSuperConcepts: Iterable<IConcept> = emptyList(),
+    private val uid: String? = null
 ) : IConcept {
     override var language: ILanguage? = null
     val properties: MutableList<SimpleProperty> = ArrayList()
     val childLinks: MutableList<IChildLink> = ArrayList()
     val referenceLinks: MutableList<IReferenceLink> = ArrayList()
     private val superConcepts: List<IConcept> = directSuperConcepts.toList()
 
-    constructor(name: String) : this(name, false, listOf())
-
-    constructor(name: String, isAbstract: Boolean) : this(name, isAbstract, listOf())
-
-    constructor(name: String, directSuperConcepts: Iterable<IConcept>) : this(name, false, directSuperConcepts)
-
     override fun isAbstract(): Boolean = this.is_abstract
 
-    override fun getUID(): String = getLongName()
+    override fun getUID(): String = uid ?: getLongName()
 
     override fun getReference(): IConceptReference {
         return ConceptReference(getUID())

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

@@ -13,7 +13,7 @@
  */
 package org.modelix.model.api
 
-class SimpleLanguage(private val name: String) : ILanguage {
+open class SimpleLanguage(private val name: String, private val uid: String? = null) : ILanguage {
     private var registered: Boolean = false
     fun register() {
         if (registered) return
@@ -27,7 +27,7 @@ class SimpleLanguage(private val name: String) : ILanguage {
         registered = false
     }
 
-    override fun getUID(): String = name
+    override fun getUID(): String = uid ?: name
 
     private val concepts: MutableList<SimpleConcept> = ArrayList()