modicio/modic.io.model

Package-level declarations

Types

class Accessor(instance: Instance, positionObject: IObject)

The Accessor is a helper class for doing model and instance traversal for easier access of often used field. The Fragment must be autowired() before the Accessor can be used!

Annotation

@Entity

class Annotation(var dataID: Long? = null, var versionTime: Timestamp = Timestamp.from(Instant.MIN), var versionID: String = "", var variantTime: Timestamp = Timestamp.from(Instant.MIN), var variantID: String = "")

The Annotation model element is attached to every Node. An Annotation stores the identifiers in space (variant) and time (version) of each element.

AssociationInstance

@Entity

class AssociationInstance(var dataID: Long? = null, val instanceUri: String = "", val associationUri: String = "", val instance: Fragment? = null)

The AssociationInstance represents the concretization of an AssociationRelation.

AssociationRelation

@Entity

class AssociationRelation(var dataID: Long? = null, var uri: String = "", var name: String = "", var target: String = "", val cInterface: Interface? = null, var node: Node? = null)

The AssociationRelation models a directed association edge from one Node to another Node. The association is always owned by the starting Node.

Attribute

@Entity

class Attribute(var dataID: Long? = null, var uri: String = "", var name: String = "", var dType: String = "", var node: Node? = null)

The Attribute represents the model element typically known as attribute or property. By default, only Nodes can have Attributes. An Attribute consists of identifiers and a key-datatype pair expressing the physical attribute model.

AttributeInstance

@Entity

class AttributeInstance(var dataID: Long? = null, val attributeUri: String = "", var anyValue: String = "")

The AttributeInstance represents a concretization of an Attribute.

Composition

@Entity

class Composition(var dataID: Long? = null, val uri: String = "", val role: String = "", val target: String = "", var isPublic: Boolean = false, var node: Node? = null)

A Composition is a stronger specialization of an AssociationRelation, i.e., it is a part-of relationship. To realize this binding strength, Compositions follow particular principles:

CompositionInstance

@Entity

class CompositionInstance(var dataID: Long? = null, val name: String = "", val modelRoot: String = "", val uri: String = "", val compositionUri: String = "", objects: MutableList<IObject> = LinkedList(), var rootInstance: Instance? = null, var node: Node? = null)

Concretization

@Entity

class Concretization(var dataID: Long? = null, val attributeInstance: AttributeInstance? = null, var node: Node? = null)

The Concretization binds an AttributeInstance to an Attribute. Hereby, the Concretization class adds as a proxy to hold the AttributeInstance in the Model facet (because AttributeInstances would normally live in the Instance facet). From an Instance view, the AttributeInstance contains an immutable value that predefines an Attribute.

Delta

@Entity

class Delta(var dataID: Long? = null, val content: String = "", val target: String = "")

The Delta represents a single change operation.

Fragment

@Entity

class Fragment(var dataID: Long? = null, var predecessorID: String? = null, var open: Boolean = false, var variantName: String = "", variantTime: Timestamp = Timestamp.from(Instant.MIN), variantID: String = "", var runningTime: Timestamp = Timestamp.from(Instant.MIN), var runningID: String = "", var isReference: Boolean = false, val model: Model? = null, var instance: Instance? = null, val trace: Trace? = null, var globalID: String? = UUID.randomUUID().toString())

The Fragment is the central class (aka root element) of the modicio metamodel. A Fragment is identified by its own variability identifiers variantTime and variantID (and optional variantName). A Fragment can be open or closed. Open refers to an open-world assumption regarding further model elements, i.e., if a Fragment is open, it represents a knowingly or unknowingly incomplete model.

Header

@Entity

class Header(var dataID: Long? = null, elements: MutableList<HeaderElement> = LinkedList(), var instance: Instance? = null)

The Header contains the information which IObjects of an Instance are accessible from the outside, i.e., which objects can be targeted by AssociationRelations. A Header only exists in Fragments carrying an Instance. The individual objects are defined as HeaderElements. The Composition defines if an object is publicly visible or not (non-composition objects are always public). As soon as a IObject is created that is public according to its type, it is added as a HeaderElement

HeaderElement

@Entity

class HeaderElement(var dataID: Long? = null, val compositeNodeUri: String = "", val compositeInstanceUri: String = "", var header: Header? = null)

A HeaderElement describes a publicly visible entry point for AssociationInstances defined by AssociationRelations. A HeaderElement captures a single IObject and its type Node.

Instance

@Entity

class Instance(var dataID: Long? = null, val name: String = "", val modelRoot: String = "", val uri: String = "", val header: Header? = null, objects: MutableList<IObject> = LinkedList(), var fragment: Fragment? = null, var rootNode: Node? = null)

The Instance class represents the instance facet of the ESI clabject (Fragment). The Instance contains the set of instance-objects forming a physical deep instance of the logically instantiated Node.

Interface

@Entity

class Interface(var dataID: Long? = null, leftOpenDelimiters: MutableList<LeftOpen> = LinkedList(), rightOpenDelimiters: MutableList<RightOpen> = LinkedList(), regionDelimiters: MutableList<Region> = LinkedList(), pointDelimiters: MutableList<Point> = LinkedList(), var associationRelation: AssociationRelation? = null)

The Interface contains the compatability information of a AssociationRelation target in the variability time-space. An Interface can contain multiple types of intervals and points describing subsets of time-space. An AssociationRelation regarding a certain target type is fulfilled if the target fulfils at least one of the subsets defined by this class.

IObject

@Entity

class IObject(var dataID: Long? = null, val instanceOf: String = "", attributeInstances: MutableList<AttributeInstance> = LinkedList(), associationInstances: MutableList<AssociationInstance> = LinkedList(), compositionInstances: MutableList<CompositionInstance> = LinkedList(), var instance: Instance? = null, var node: Node? = null)

The IObject represents an instantiated Node. For each Node there must be exactly one Object per Fragment. The Object holds all instance information: AttributeInstances, AssociationInstances and CompositionInstances. ParentRelations are not part of the IObject because they are purely represented by the Node and can be accessed via the Node reference.

LeftOpen

@Entity

class LeftOpen(var dataID: Long? = null, val borderVersionTime: Timestamp = Timestamp.from(Instant.MIN), val borderVersionID: String? = null)

The LeftOpen class represents an open interval in time over a range of version. The interval targets one particular variant that is inferred by the usage context of the interval.

Model

@Entity

class Model(var dataID: Long? = null, nodes: MutableSet<Node> = HashSet(), var fragment: Fragment? = null)

The Model is the part of a Fragment representing type information. The Model is an object-oriented class structure. Classes are denoted as Nodes. Nodes can be connected through associations and inheritance. These relations are directed edges and are owned by the starting node. A Node can compose other Nodes (part-of relationship).

Node

@Entity

class Node(dataID: Long? = null, val name: String = "", val uri: String = "", isAbstract: Boolean = false, val annotation: Annotation? = null, attributes: MutableList<Attribute> = LinkedList(), associationRelations: MutableList<AssociationRelation> = LinkedList(), parentRelations: MutableSet<ParentRelation> = HashSet(), plugins: MutableSet<Plugin> = HashSet(), concretizations: MutableSet<Concretization> = HashSet(), compositions: MutableSet<Composition> = HashSet(), scripts: MutableList<Script> = LinkedList(), var model: Model? = null)

The Node is the top-level model element of the modicio metamodel. It represents a class in an object-oriented sense but can also represent a Node in a typed graph. The Node as first-level element contains all further model elements such as relations to other Nodes which are always unidirectional edges.

ParentRelation

@Entity

class ParentRelation(var dataID: Long? = null, val uri: String = "", var node: Node? = null)

The ParentRelation models inheritance between two Nodes. This relation is a unidirectional edge and is owned by the child Node, i.e., the specialization.

Plugin

@Entity

class Plugin(var dataID: Long? = null, var description: String = "", var resolver: String = "", var content: String = "", var node: Node? = null)

A Plugin is a generic Model extension part of a Node. A Plugin consists of a description, content and resolver reference. The content can basically contain any string value providing information, presets, image references etc. Plugins can be executable by the modicio engine directly, if an internal resolver is used. However, the client can use custom resolvers and store required information in the Plugin. The resolver will receive the Instance to do any computation based on the Plugin. Note that for scripts / code-based plugins, there is a separate Script model element directly supported by the modicio engine.

Point

@Entity

class Point(var dataID: Long? = null, val variantTime: Timestamp = Timestamp.from(Instant.MIN), val variantID: String? = null, val versionTime: Timestamp? = null, val versionID: String? = null)

The Point class represents a closed interval in space-time over a single variant (point in space) or a single point in space-time by adding a single version (that is optional). The interval targets one particular variant that is inferred by the usage context of the interval.

Region

@Entity

class Region(var dataID: Long? = null, val leftBorderVersionTime: Timestamp = Timestamp.from(Instant.MIN), val leftBorderVersionID: String? = null, val rightBorderVersionTime: Timestamp = Timestamp.from(Instant.MIN), val rightBorderVersionID: String? = null)

The Region class represents a closed interval in time over a range of version. The interval targets one particular variant that is inferred by the usage context of the interval.

RightOpen

@Entity

class RightOpen(var dataID: Long?, val borderVersionTime: Timestamp = Timestamp.from(Instant.MIN), val borderVersionID: String? = null)

The RightOpen class represents an open interval in time over a range of version. The interval targets one particular variant that is inferred by the usage context of the interval.

Script

@Entity

class Script(var dataID: Long? = null, var uri: String = "", var name: String = "", var actionType: String = "", var resolver: String = "", var anyValue: String = "", var node: Node? = null)

A script is a special kind of Plugin to hold executable code. This code is directly executed by the modicio engine and can be specified by the modeller.

Trace

@Entity

class Trace(var dataID: Long? = null, deltas: MutableList<Delta> = LinkedList(), var fragment: Fragment? = null)

The Trace is an optional part of a Fragment that contains change operations (deltas) that were performed to the Fragment in the past. The usage of the Trace is implementation specific and may be refined in future work. In general, the Trace targets the Model, but could target Instance changes as well. The coarse idea is the following: Each evolution step by the client (e.g. that increments the running version) produces a sequence of Deltas which are added to the Trace. This allows going back in time (reverse operations) and helps to (re-)construct model transformations between different variants and versions. If a new Fragment is created from an existing one, the Trace of the new Fragment is emptied.