model-api/org.modelix.model.area/CompositeArea

CompositeArea

class ~~CompositeArea~~ : IArea

Deprecated

not supported anymore

Constructors

constructor(vararg areas: IArea)

constructor(areas: List<IArea>)

Types

data class AreaReference(val areaRefs: List<IAreaReference>) : IAreaReference

ListenerWrapper

inner class ListenerWrapper(val wrappedListener: IAreaListener) : AreaListenerWrapper

inner class NodeWrapper(val node: INode) : INode, INodeWrapper, IReplaceableNode

NodeWrapperReference

data class NodeWrapperReference(val nodeRef: INodeReference, val areaRef: CompositeArea.AreaReference) : INodeReference

inner class Root : INode

RootNodeReference

data class RootNodeReference(val areaRef: CompositeArea.AreaReference) : INodeReference

Functions

open override fun addListener(l: IAreaListener)

open override fun canRead(): Boolean

open override fun canWrite(): Boolean

open override fun collectAreas(): List<IArea>

open operator override fun equals(other: Any?): Boolean

open override fun <T> executeRead(f: () -> T): T

open override fun <T> executeWrite(f: () -> T): T

fun flatten(): List<IArea>

fun getAreas(): List<IArea>

getLockOrderingPriority

open fun getLockOrderingPriority(): Long

bigger numbers are locked first

open override fun getReference(): CompositeArea.AreaReference

open override fun getRoot(): INode

The root of an area is not allowed to change

open override fun hashCode(): Int

open override fun removeListener(l: IAreaListener)

open override fun resolveArea(ref: IAreaReference): IArea?

open override fun resolveBranch(id: String): IBranch?

open override fun resolveConcept(ref: IConceptReference): IConcept?

open override fun resolveNode(ref: INodeReference): INode?

The area should not delegate to INodeReference.resolveNode. If it can't handle the type of reference it should just return null.

resolveOriginalNode

open override fun resolveOriginalNode(ref: INodeReference): INode?

This method allows resolveOriginalNode().getArea() != this

open fun <T> runWith(body: () -> T): T

All node references inside the body are resolved against this scope. Compared to runWithAlso, the existing scopes in the current context are not used, meaning they are replaced.

runWithAdditionalScope

open fun <T> runWithAdditionalScope(body: () -> T): T

All node references inside the body are resolved against this scope and if that fails against any other scope in the current context.

runWithAdditionalScopeInCoroutine

open suspend fun <T> runWithAdditionalScopeInCoroutine(body: suspend () -> T): T

Does the same as runWithAlso, but with support for suspendable functions.

runWithInCoroutine

open suspend fun <T> runWithInCoroutine(body: suspend () -> T): T

Does the same as runWithOnly, but with support for suspendable functions.

fun unwrapNode(node: INode): INode

fun unwrapNodeRef(ref: INodeReference): INodeReference

fun wrapNode(node: INode?): CompositeArea.NodeWrapper?