Merge pull request #67 from modelix/modelql-references-and-children

support for "references" and "referencesAndChildren" in ModelQL

Author: slisson

light-model-server/src/main/kotlin/org/modelix/model/server/light/QueryImplementation.kt

@@ -37,6 +37,8 @@ import org.modelix.model.server.api.QueryChildren
 import org.modelix.model.server.api.QueryDescendants
 import org.modelix.model.server.api.QueryParent
 import org.modelix.model.server.api.QueryReference
+import org.modelix.model.server.api.QueryReferences
+import org.modelix.model.server.api.QueryReferencesAndChildren
 import org.modelix.model.server.api.QueryRootNode
 import org.modelix.model.server.api.RootOrSubquery
 import org.modelix.model.server.api.RootQuery
@@ -52,6 +54,8 @@ fun RootOrSubquery.queryNodes(node: INode): Sequence<INode> {
         is QueryDescendants -> node.getDescendants(false)
         is QueryParent -> listOfNotNull(node.parent).asSequence()
         is QueryReference -> listOfNotNull(node.getReferenceTarget(this.role)).asSequence()
+        is QueryReferences -> node.getAllReferences()
+        is QueryReferencesAndChildren -> node.getReferencesAndChildren(recursive)
         is QueryById -> {
             val resolved = INodeReferenceSerializer.deserialize(this.nodeId).resolveNode(node.getArea())
             if (resolved != null) {
@@ -66,6 +70,17 @@ fun RootOrSubquery.queryNodes(node: INode): Sequence<INode> {
     }
 }
 
+private fun INode.getAllReferences() = getReferenceRoles().asSequence().mapNotNull { getReferenceTarget(it) }
+
+private fun INode.getReferencesAndChildren(recursive: Boolean): Sequence<INode> {
+    val referencesAndChildren = (getAllReferences() + allChildren.asSequence())
+    return if (recursive) {
+        referencesAndChildren.flatMap { sequenceOf(it) + it.getReferencesAndChildren(true) }
+    } else {
+        referencesAndChildren
+    }
+}
+
 fun RootOrSubquery.applyFilters(node: INode): Boolean {
     return when (this) {
         is RootQuery -> true

model-server-api/src/commonMain/kotlin/org/modelix/model/server/api/ModelQuery.kt

@@ -84,6 +84,21 @@ data class QueryReference(
     override val filters: List<Filter> = emptyList()
 ) : Subquery()
 
+@Serializable
+@SerialName("references")
+data class QueryReferences(
+    override val queries: List<Subquery> = emptyList(),
+    override val filters: List<Filter> = emptyList()
+) : Subquery()
+
+@Serializable
+@SerialName("referencesAndChildren")
+data class QueryReferencesAndChildren(
+    val recursive: Boolean = false,
+    override val queries: List<Subquery> = emptyList(),
+    override val filters: List<Filter> = emptyList()
+) : Subquery()
+
 @Serializable
 @SerialName("descendants")
 data class QueryDescendants(

model-server-api/src/commonMain/kotlin/org/modelix/model/server/api/ModelQueryBuilder.kt

@@ -20,7 +20,6 @@ fun buildModelQuery(body: ModelQueryBuilder.() -> Unit): ModelQuery {
     return ModelQueryBuilder().also(body).build()
 }
 
-
 class ModelQueryBuilder {
     private val rootQueries = ArrayList<RootQuery>()
     fun build() = ModelQuery(rootQueries)
@@ -83,6 +82,15 @@ abstract class QueryOwnerBuilder : FilterListBuilder() {
     fun reference(role: String, body: ReferenceBuilder.() -> Unit) {
         addSubquery(ReferenceBuilder(role).also(body).build())
     }
+    fun references(body: ReferencesBuilder.() -> Unit) {
+        addSubquery(ReferencesBuilder().also(body).build())
+    }
+    fun referencesAndChildren(body: ReferencesAndChildrenBuilder.() -> Unit) {
+        addSubquery(ReferencesAndChildrenBuilder(false).also(body).build())
+    }
+    fun referencesAndChildrenRecursive(body: ReferencesAndChildrenBuilder.() -> Unit) {
+        addSubquery(ReferencesAndChildrenBuilder(true).also(body).build())
+    }
     fun allChildren(body: AllChildrenBuilder.() -> Unit) {
         addSubquery(AllChildrenBuilder().also(body).build())
     }
@@ -121,6 +129,12 @@ class ChildrenBuilder(val role: String?) : SubqueryBuilder() {
 class ReferenceBuilder(val role: String) : SubqueryBuilder() {
     override fun build() = QueryReference(role, subqueries, filters)
 }
+class ReferencesBuilder() : SubqueryBuilder() {
+    override fun build() = QueryReferences(subqueries, filters)
+}
+class ReferencesAndChildrenBuilder(private val recursive: Boolean) : SubqueryBuilder() {
+    override fun build() = QueryReferencesAndChildren(recursive, subqueries, filters)
+}
 
 class AllChildrenBuilder() : SubqueryBuilder() {
     override fun build() = QueryAllChildren(subqueries, filters)