EA Toolsets project : OsMmEntities

Metamodel: Entities

An entity represents a describable ‘thing’.

An entity-type is a template (‘class’) for a specific type of entity.

An entity-type is a stack of subclasses of the root entity-type. Each subclass adds one or more properties and/or display-methods to the stack. Multiple-inheritance is allowable, at any level.

Each subclass layer in the stack optionally exposes one or more ‘linkable’ properties specific to the subclass, as a connection-identifier for a matching relation-type. This interface may be suppressed at higher levels in the stack by overriding the respective property.

Each subclass layer in the stack optionally exposes any number of subclass-specific display-methods.

Any entity (i.e. instance of an entity-type) may be used as the basis for a new entity-type. The values of its properties will then become static values inherited by all instances of the new type. The new type must add at least one property to differentiate it from its parent superclass. (Example: a serial-number property attached as a ‘subclass’ for an existing instance of hardware to make it into an item-type instantiable as specific equipment-units.)

Properties for subclasses added to the entity-type stack may be assigned predefined values. A subclass whose properties are all assigned predefined values may be added to the stack: this subclass is in effect an ‘abstract class’ which is not in itself instantiable. (Example: a subclass with a dual ‘linkable’ property of ‘BPMN’ and ‘function’ could be used to permit the instances of subclasses to be linked into a BPMN model. This subclass could also carry the default display-method for a BPMN function-object.)

Given the above mechanisms – entity-type as a stack of subclasses, relations connecting to similarly-stacked ‘linkable’ connection-interfaces, the ability to convert an instance to a type, and abstract-type subclasses – the nature of an entity-type and its instances, and optionally its available ‘legal’ relations with other entities, could be shown in a relatively-simple tree-structure. This would also permit construction of metamodels via a simple graphical process of drawing subclass-inheritance links between representations of the respective entity-types (or instances, in the case where an instance is reconverted to a type).