Archetype Object Model 2 (AOM2)

Definitions relating to the internal code system of archetypes.

String leader of ‘identifier’ codes, i.e. codes used to identify archteype nodes.

String leader of ‘value’ codes, i.e. codes used to identify codes values, including value set members.

String leader of ‘value set’ codes, i.e. codes used to identify value sets.

Character used to separate numeric parts of codes belonging to different specialisation levels.

Regex used to define the legal numeric part of any archetype code. Corresponds to the simple pattern of dotted numbers, as used in typical multi-level numbering schemes.

Regex pattern of the root id code of any archetype. Corresponds to codes of the form id1, id1.1, id1.1.1 etc..

Code id used for C_PRIMITIVE_OBJECT nodes on creation.

True if a_child_code conforms to a_parent_code in the sense of specialisation, i.e. is a_child_code the same as or more specialised than a_parent_code.

True if a_code is any kind of ADL archetype local code.

True if a_code is an 'id' code.

True if a_code is an 'at' code, i.e. a code representing a single terminology item.

True if a_code is an 'ac' code, i.e. a code referring to a terminologyvalue set.

A code has been specialised if there is a non-zero code index anywhere above the last index e.g.

Is `a_code' valid at level `a_level' or less, i.e. if we remove its trailing specialised part corresponding to specialisation below `a_level', and then any trailing '.0' pieces, do we end up with a valid code? If so it means that the code corresponds to a real node from `a_level' or higher.

The ARCHETYPE class defines the core formal model of the root object of any archetype or template. It includes only basic identification information, and otherwise provides the structural connections from the Archetype to its constituent parts, i.e. definition (a C_COMPLEX_OBJECT), terminology (ARCHEYTPE_TERMINOLOGY) and so on. It is the parent class of all concrete types of archetype.

Archetype reference of the specialisation par-ent of this archetype, if applicable. May take the form of an archetype interface identifier, i.e. the identifier up to the major version only, or can be deeper.

Identifier of this archetype.

Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True.

Root node of the definition of this archetype.

The terminology of the archetype.

Rules relating to this archetype. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.

The concept code of the root object of the archetype, also standing for the concept of the archetype as a whole.

Set of language-independent paths extracted from archetype. Paths obey Xpath-like syntax and are formed from alternations of C_OBJECT.node_id and C_ATTRIBUTE.rm_attribute_name values.

Set of language-dependent paths extracted from archetype. Paths obey the same syntax as physical_paths, but with node_ids replaced by their meanings from the ontology.

Specialisation depth of this archetype; larger than 0 if this archetype has a parent. Derived from terminology.specialisation_depth.

True if this archetype is a specialisation of another.

Invariant_concept_valid: terminology.has_term_code (concept_code)

Invariant_specialisation_validity: is_specialised implies specialisation_depth > 0

Root object of a standalone, authored archetype, including all meta-data, description, other identifiers and lifecycle.

ADL version if archetype was read in from an ADL sharable archetype.

Unique identifier of this archetype artefact instance. A new identifier is assigned every time the content is changed by a tool. Used by tools to distinguish different revisions and/or interim snapshots of the same artefact.

Semver.org compatible release of the most recent reference model release on which the archetype in its current version is based. This does not imply conformance only to this release, since an archetype may be valid with respect to multiple releases of a reference model.

If True, indicates that this artefact was machine-generated from some other source, in which case, tools would expect to overwrite this artefact on a new generation. Editing tools should set this value to False when a user starts to manually edit an archetype.

Invariant_adl_version_validity: valid_version_id (adl_version)

Invariant_rm_release: valid_version_id (rm_release)

Description_validity: description /= Void

Human_readable structured identifier (HRID) for an archetype or template.

Reverse domain name namespace identifier.

Name of the Reference Model publisher.

Name of the package in whose reachability graph the rm_class class is found (there can be more than one possibility in many reference models).

Name of the root class of this archetype.

The short concept name of the archetype as used in the multi-axial archetype_hrid.

The full numeric version of this archetype consisting of 3 parts, e.g. "1.8.2". The archetype_hrid feature includes only the major version.

The status of the version, i.e. released, release_candidate etc.

The build count since last increment of any version part.

The ‘interface’ form of the HRID, i.e. down to the major version.

The ‘physical’ form of the HRID, i.e. with complete version information.

Full version identifier string, based on release_version and lifecycle, e.g. "1.8.2-rc.4".

Major version of this archetype, extracted from release_version.

Minor version of this archetype, extracted from release_version.

Patch version of this archetype, extracted from release_version. Equivalent to patch version in patch version in semver.org sytem.

Inv_rm_publisher_validity: not rm_publisher.is_empty

Inv_rm_package_validity: not rm_package.is_empty

Inv_class_name_validity: not rm_class.is_empty

Inv_concept_id_validity: not concept_id.is_empty

Inv_release_version_validity: valid_version (release_version)

Class representing source template, i.e. a kind of archetype that may include template overlays, and may be restricted by tools to only defining mandations, prohibitions, and restrictions on elements already defined in the flat parent.

Overlay archetypes, i.e. partial archetypes that include full definition and terminology, but logically derive all their meta-data from from the owning template.

Inv_is_specialised: is_specialised

A concrete form of the bare ARCHETYPE class, used to represent overlays in a source template. Overlays have no meta-data of their own, and are instead documented by their owning template.

Inv_is_specialised: is_specialised

Root object of an operational template. An operational template is derived from a TEMPLATE definition and the ARCHETYPEs and/or TEMPLATE_OVERLAYs mentioned by that template by a process of flattening, and potentially removal of unneeded languages and terminologies.

An operational template is used for generating and validating RM-canonical instance data, and also as a source artefact for generating other downstream technical artefacts, including XML schemas, APIs and UI form definitions.

Compendium of flattened terminologies of archetypes externally referenced from this archetype, keyed by archetype identifier. This will almost always be present in a template.

Directory of term definitions as a two-level table. The outer hash keys are term codes, e.g. "at4", and the inner hash key are term attribute names, e.g. "text", "description" etc.

Specialisation_validity: is_specialised

Abstract parent of all constraint model types. Defines conformance and congruence function signatures.

Parent node, except in the case of the top of a tree, i.e. root C_COMPLEX_OBJECT of an archetype definition.

Inverse relationship for ARCHETYPE_CONSTRAINT node owned by C_SECOND_ORDER.members attribute.

True if this node is prohibited. Implemented in subtypes.

True if the relative path a_path exists at this node.

Path of this node relative to root of archetype.

True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of special-ised archetype nodes.

True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of node_id redefnition in C_OBJECT nodes.

Typically used to test if an inherited node locally contains any constraints.

True if there is a second order constraint such as a tuple constraint on this node.

True if this node is the root of the tree.

True if this node is a terminal node in the tree structure, i.e. having no child nodes.

Abstract model of constraint on any kind of attribute in a class model.

Reference model attribute within the enclosing type represented by a C_OBJECT.

Constraint settable on every attribute, regardless of whether it is singular or of a container type, which indicates whether its target object exists or not (i.e. is mandatory or not). Only set if it overrides the underlying reference model or parent archetype in the case of specialised archetypes.

Child C_OBJECT nodes. Each such node represents a constraint on the type of this attribute in its reference model. Multiples occur both for multiple items in the case of container attributes, and alternatives in the case of singular attributes.

Path to the parent object of this attribute (i.e. doesn’t include the name of this attribute). Used only for attributes in differential form, specialised archetypes. Enables only the re-defined parts of a specialised archetype to be expressed, at the path where they occur.

Cardinality constraint of attribute, if a container attribute.

Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute.

True if there is no effective constraint on the children of the RM attribute to which this C_ATTRIBUTE refers.

True if this C_ATTRIBUTE has an existence constraint of 1..1, i..e. mandation.

Path of this attribute with respect to owning C_OBJECT, including differential path where applicable.

True if this node logically represents a single-valued attribute. Evaluated as not is_multiple.

True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of node_id redefnition in C_OBJECT nodes.

Typically used to test if an inherited node locally contains any constraints.

True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of special-ised archetype nodes.

True if this C_ATTRIBUTE has an existence constraint of 0..0, i.e. prohibition.

Abstract model of constraint on any kind of object node.

Reference model type that this node corresponds to.

Occurrences of this object node in the data, under the owning attribute. Upper limit can only be greater than 1 if owning attribute has a cardinality of more than 1. Only set if it overrides the parent archetype in the case of specialised archetypes, or else the occurrences inferred from the underlying reference model existence and/or cardinality of the containing attribute.

Semantic identifier of this node, used to distinguish sibling nodes. All nodes must have a node_id; for nodes under a container C_ATTRIBUTE, the id must be an id-code must be defined in the archetype terminology. For valid structures, all node ids are id-codes.

For C_PRIMITIVE_OBJECTs represented in ADL inline form, this attribute will have the special value Primitive_node_id; otherwise it will have the node id read during parsing.

True if this node and by implication all sub-nodes are deprecated for use.

Optional indicator of order of this node with respect to another sibling. Only meaningful in a specialised archetype for a C_OBJECT within a C_ATTRIBUTE with is_multiple = True.

Level of specialisation of this archetype node, based on its node_id. The value 0 corresponds to non-specialised, 1 to first-level specialisation and so on. The level is the same as the number of ‘.’ characters in the node_id code. If node_id is not set, the return value is -1, signifying that the specialisation level should be determined from the nearest parent C_OBJECT node having a node_id.

True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of special-ised archetype nodes.

True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of node_id redefnition in C_OBJECT nodes.

Typically used to test if an inherited node locally contains any constraints.

True if this node occurrences conforms to other.occurrences; `other' is assumed to be in a flat archetype.

True if this node id conforms to other.node_id, which includes the ids being identical; other is assumed to be in a flat archetype.

True if this C_OBJECT node is prohibited, i.e. if its occurrences is 0..0.

Defines the order indicator that can be used on a C_OBJECT within a container attribute in a specialised archetype to indicate its order with respect to a sibling defined in a higher specialisation level.

Misuse: This type cannot be used on a C_OBJECT other than one within a container attribute in a specialised archetype.

True if the order relationship is ‘before’, if False, it is ‘after’.

Node identifier of sibling before or after which this node should come.

True if the order relationship is after, computed as the negation of is_before.

Abstract parent type of C_OBJECT subtypes that are defined by value, i.e. whose definitions are actually in the archetype rather than being by reference.

Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

True if a_value is valid with respect to constraint expressed in concrete instance of this type.

Generate a prototype value from this constraint object.

True if there is an assumed value.

Constraint on complex objects, i.e. any object that consists of other object constraints.

List of constraints on attributes of the reference model type represented by this object.

List of attribute tuple constraints under this object constraint, if any.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

A specialisation of C_COMPLEX_OBJECT whose node_id attribute is an archetype identifier rather than the normal internal node code (i.e. id-code).

Used in two situations. The first is to represent an 'external reference' to an archetype from within another archetype or template. This supports re-use. The second use is within a template, where it is used as a slot-filler.

For a new external reference, the node_id is set in the normal way, i.e. with a new code at the specialisation level of the archetype. For a slot-filler or a redefined external reference, the node_id is set to a specialised version of the node_id of the node being specialised, allowing matching to occur during flattening.

In all uses within source archetypes and templates, the children attribute is Void.

In an operational template, the node_id is converted to the archetype_ref, and the structure contains the result of flattening any template overlay structure and the underlying flat archetype.

Reference to archetype is being used to fill a slot or redefine an external reference. Typically an 'interface' archetype id, i.e. identifier with partial version information.

Constraint describing a slot' where another archetype can occur.

List of constraints defining other archetypes that could be included at this point.

List of constraints defining other archetypes that cannot be included at this point.

True if this slot specification in this artefact is closed to further filling either in further specialisations or at runtime. Default value False, i.e. unless explicitly set, a slot remains open.

True if no constraints stated, and slot is not closed.

A constraint defined by proxy, using a reference to an object constraint defined elsewhere in the same archetype. Note that since this object refers to another node, there are two objects with available occurrences values. The local occurrences value on a COMPLEX_OBJECT_PROXY should always be used; when setting this from a serialised form, if no occurrences is mentioned, the target occurrences should be used (not the standard default of {1..1}); otherwise the locally specified occurrences should be used as normal. When serialising out, if the occurrences is the same as that of the target, it can be left out.

Reference to an object node using archetype path notation.

True if target occurrences are to be used as the value of occurrences in this object; by the time of runtime use, the target occurrences value has to be set into this object.

True if this node occurrences conforms to other.occurrences; other is assumed to be in a flat archetype.

If other is a C_COMPLEX_OBJECT, then always True, since if occurrences defined on proxy node, it is an override of the occurrences on the target, and it doesn’t have to conform to anything except the containing attribute’s cardinality. However, if other is also a C_COMPLEX_OBJECT then the override is of another use_node, and normal occurrences apply

Parent of types representing constraints on primitive types.

Instances of this type represented in ADL inline form, the node_id attribute will have the special value Primitive_node_id; otherwise it will have the node id read during parsing.

Value to be assumed if none sent in data.

True if this object represents a constraint on an enumerated type from the reference model, where the latter is assumed to be based on a primitive type, generally Integer or String.

Constraint represented by this object; redefine in descendants.

True if there is an assumed value.

Generate name of native type that is constrained by this C_XXX type. For most types, it is the C_XXX typename without the C_, i.e. XXX. E.g. C_INTEGER → Integer. For the date/time types the mapping is different.

True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of special-ised archetype nodes.

True if this node expresses a value constraint that conforms to that of other. Effected in descendants.

True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of node_id redefnition in C_OBJECT nodes.

Typically used to test if an inherited node locally contains any constraints.

True if this node expresses the same value constraint as other. Effected in descendants.

Constraint on instances of Boolean. Both attributes cannot be set to False, since this would mean that the Boolean value being constrained cannot be True or False.

Boolean constraint - a list of Boolean values.

Assumed Boolean value.

Default Boolean value.

Prototype Boolean value.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

True if other.any_allowed or else every constraint in the constraint list exists in the other.constraint.

True if the items in constraint are equal in number and identical pair-wise with those in other.constraint.

Constraint on instances of String.

String constraint - a list of literal strings and / or regular expression strings delimited by the ‘/’ character.

To represent no constraint, use an empty list, or alternatively, a regex 'any' pattern, i.e. /.*/.

Default String value.

Assumed String value.

True if a_value is valid with respect to constraint expressed in concrete instance of this type.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

True if other.any_allowed or else every constraint in the constraint list exists in the other.constraint.

True if the items in constraint are equal in number and identical pair-wise with those in other.constraint.

Abstract parent of primitive constrainer classes based on Ordered base types, i.e. types like Integer, Real, and the Date/Time types. The model constraint is a List of Intervals, which may include point Intervals, and acts as a efficient and formally tractable representation of any number of point values and/or contiguous intervals of an ordered value domain.

In its simplest form, the constraint accessor returns just a single point Interval<T> object, representing a single value.

The next simplest form is a single proper Interval <T> (i.e. normal two-sided or half-open interval). The most complex form is a list of any combination of point and proper intervals.

Constraint in the form of a List of Intervals of the parameter type T. Concrete types generated in descendants via template binding.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

True if other.any_allowed or else for every constraint in the constraint list there is a constraint in other.constraint that contains it.

True if the items in constraint are equal in number and identical pair-wise with those in other.constraint.

Constraint on instances of Integer.

Formal constraint on Integer, in the form of one or more Interval<Integer>.

To represent no constraint, use an empty list.

Constraint on instances of Real.

Formal constraint on Real, in the form of one or more Interval<Real>.

To represent no constraint, use an empty list.

Purpose Abstract parent of C_ORDERED types whose base type is an ISO date/time type.

Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details.

True if a_pattern is a valid constraint. Define in concrete descendants.

Return True if a_pattern can be replaced by an_other_pattern in a specialised constraint. Define in concrete subtypes.

True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.

True if precursor() or else other.pattern_constraint is empty, or else pattern_constraint is a valid (narrower) replacement for other.pattern_constraint.

True if precursor (other) and pattern_constraint ~ other.pattern_constraint, i.e. either both Void or else both non-Void and identical.