Archetype Object Model 1.4 (AOM1.4)

Archetype equivalent to ARCHETYPED class in Common reference model. Defines semantics of identfication, lifecycle, versioning, composition and specialisation.

Root node of the definition of this archetype.

The ontology of the archetype.

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

Multi-axial identifier of this archetype in archetype space.

OID identifier of this archetype.

The normative meaning of the archetype as a whole, expressed as a local archetype code, typically “at0000”.

Identifier of the specialisation parent of this archetype.

Invariant statements about this object. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.

The concept name of the archetype in language a_lang; corresponds to the term definition of the concept attribute in the archetype ontology.

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.

True if the archetype is valid overall; various tests should be used, including checks on node_ids, internal references, and constraint references.

True if every node_id found on a C_OBJECT node is found in ontology.term_codes.

Version of predecessor archetype of this archetype, if any.

True if every ARCHETYPE_INTERNAL_REF. target_path refers to a legitimate node in the archetype definition.

True if every CONSTRAINT_REF.reference found on a C_OBJECT node in the archetype definition is found in ontology.constraint_codes.

The short concept name of the archetype extracted from the archetype_id.

Inv_concept_valid: ontology.has_term_code (concept_code)

Inv_specialisation_validity: is_specialised implies specialisation_depth > 0

Inv_invariants_valid: invariants /= Void implies not invariants.is_empty

Inv_uid_validity: uid /= Void implies not uid.is_empty

Inv_version_validity: version /= Void and then version.is_equal(archetype_id.version_id)

Inv_description_valid: description /= Void

Inv_original_language_valid: original_language /= void and then language /= Void

An enumeration of three values that may commonly occur in constraint models.

Use as the type of any attribute within this model, which expresses constraint on some attribute in a class in a reference model. For example to indicate validity of Date/Time fields.

Constant to indicate mandatory presence of something.

Constant to indicate optional presence of something.

Constant to indicate disallowed presence of something.

Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model.

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.

Path of this node relative to root of archetype.

True if the relative path a_path exists at this node.

Abstract model of constraint on any kind of attribute node.

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

Constraint 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).

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.

True if any value (i.e. instance) of the reference model attribute represented by this C_ATTIRBUTE is allowed.

Rm_attribute_name_valid: not rm_attribute_name.is_empty

Existence_set: existence.lower >= 0 and existence.upper <= 1

Children_validity: any_allowed xor children /= Void

Concrete model of constraint on a single-valued attribute node. The meaning of the inherited children attribute is that they are alternatives.

List of alternative constraints for the single child of this attribute within the data.

Concrete model of constraint on multiply-valued (ie. container) attribute node.

Cardinality of this attribute constraint, if it constraints a container attribute.

List of constraints representing members of the container value of this attribute within the data. Semantics of the uniqueness and ordering of items in the container are given by the cardinality.

Members_valid: members /= Void and then members.for_all(co: C_OBJECT | co.occurrences.upper <= 1)

Express constraints on the cardinality of container objects which are the values of multiply-valued attributes, including uniqueness and ordering, providing the means to state that a container acts like a logical list, set or bag. The cardinality cannot contradict the cardinality of the corresponding attribute within the relevant reference model.

The interval of this cardinality.

True if the members of the container attribute to which this cardinality refers are ordered.

True if the members of the container attribute to which this cardinality refers are unique.

True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership.

True if the semantics of this cardinality represent a list, i.e. ordered, non-unique membership.

True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership.

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).

Semantic identifier of this node, used to dis-tinguish 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 terminolo-gy. For valid structures, all node ids are id-codes. For C_PRIMITIVE_OBJECTs, it will have the special value Primitive_node_id.

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.

Value to be assumed if none sent in data.

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.

Generate a default value from this constraint object.

True if any value of the reference model type being constrained is allowed. Redefine in descendants.

Assumed_value_valid: has_assumed_value implies valid_value(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.

True if any value of the reference model type being constrained is allowed.

Attributes_valid: ` any_allowed xor (attributes /= Void and not attributes.is_empty)`

Constraint on a primitive type.

Object actually defining the constraint.

True if any value of the type being constrained in item is allowed.

Item_valid: any_allowed xor item /= Void

Abstract parent type of domain-specific constrainer types, to be defined in external packages.

Standard (i.e. C_OBJECT) form of constraint.

Abstract parent type of C_OBJECT subtypes that are defined by reference.

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.

Includes_valid: includes /= Void implies not includes.is_empty

Excludes_valid: excludes /= Void implies not excludes.is_empty

Validity: any_allowed xor (includes /= Void or excludes /= Void)

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 an ARCHETYPE_INTERNAL_REF 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.

Consistency: not any_allowed

Target_path_valid: target_path /= Void and then not target_path.is_empty

Reference to a constraint described in the same archetype, but outside the main constraint structure. This is used to refer to constraints expressed in terms of external resources, such as constraints on terminology value sets.

Reference to a constraint in the archetype local ontology.

Consistency: not any_allowed

Structural model of a typed first order predicate logic assertion, in the form of an expression tree, including optional variable definitions.

Expression tag, used for differentiating multiple assertions.

String form of expression, in case an expression evaluator taking String expressions is used for evaluation.

Root of expression tree.

Definitions of variables used in the assertion expression.

Tag_valid: tag /= Void implies not tag.is_empty

Expression_valid: expression /= Void and then expression.type.is_equal(“BOOLEAN”)

Abstract parent of all expression tree items.

Type name of this item in the mathematical sense. For leaf nodes, must be the name of a primitive type, or else a reference model type. The type for any relational or boolean operator will be “Boolean”, while the type for any arithmetic operator, will be “Real” or “Integer”.

Expression tree leaf item representing one of:

Type of reference: “constant”, “attribute”, “function”, “constraint”. The first three are used to indicate the referencing mechanism for an operand. The last is used to indicate a constraint operand, as happens in the case of the right-hand operand of the ‘matches’ operator.

The value referred to; a manifest constant, an attribute path (in the form of a String), or for the right-hand side of a ‘matches’ node, a constraint, often a C_PRIMITIVE_OBJECT.

Abstract parent of operator types.

True if the natural precedence of operators is overridden in the expression represented by this node of the expression tree. If True, parentheses should be introduced around the totality of the syntax expression corresponding to this operator node and its operands.

Code of operator.

Unary operator expression node.

Operand node.

Binary operator expression node.

Left operand node.

Right operand node.

Definition of a named variable used in an assertion expression.

Name of variable.

Formal definition of the variable.

Enumeration type for operator types in assertion expressions.

Equals operator (= or ==)

Not equals operator (!= or /=)

Less-than or equals operator (<=)

Less-than operator (<=)

Greater-than or equals operator (>=)

Greater-than operator (>)

Matches operator (matches or is_in)

Not logical operator

And logical operator

Or logical operator.

Xor logical operator

Implies logical operator

For-all (universal) quantifier

Exists quantifier

Arithmetic plus operator (+)

Arithmetic minus operator (-)

Arithmetic multiplication operator (*)

Arithmetic division operator (/)

Arithmetic exponentiation operator (^)

Parent of types representing constraints on primitive types.

Value to be assumed if none sent in data.

Generate a default value from this constraint object.

True if there is an assumed value.

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

Assumed_value_valid: has_assumed_value implies valid_value(assumed_value)

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.

True if the value True is allowed.

True if the value False is allowed.

The value to assume if this item is not included in data, due to being part of an optional structure.

Constraint on instances of STRING.

Regular expression pattern for proposed instances of String to match.

Set of Strings specifying constraint.

True if the list is being used to specify the constraint but is not considered exhaustive.

The value to assume if this item is not included in data, due to being part of an optional structure.

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

Constraint on instances of Integer.

Set of Integers specifying constraint.

Range of Integers specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

Constraint on instances of Real.

Set of Reals specifying constraint.

Range of Real specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

ISO 8601-compatible constraint on instances of Date in the form either of a set of validity values, or an actual date range. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date at all. Syntax expressions of instances of this class include “YYYY-??-??” (date with optional month and day).

Validity of day in constrained date.

Validity of month in constrained date.

Validity of timezone in constrained date.

Interval of Dates specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

Month_validity_optional: month_validity = {VALIDITY_KIND}.optional implies (day_validity = {VALIDITY_KIND}.optional or day_validity = {VALIDITY_KIND}.disallowed)

Month_validity_disallowed: month_validity = {VALIDITY_KIND}.disallowed implies day_validity = {VALIDITY_KIND}.disallowed

Validity_is_range: validity_is_range = (range /= Void)

ISO 8601-compatible constraint on instances of Time. There is no validity flag for ‘hour’, since it must always be by definition mandatory in order to have a sensible time at all. Syntax expressions of instances of this class include “HH:??:xx” (time with optional minutes and seconds not allowed).

Validity of minute in constrained time.

Validity of second in constrained time.

Validity of millisecond in constrained time.

Validity of timezone in constrained date.

Interval of Times specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

True if validity is in the form of a range; useful for developers to check which kind of constraint has been set.

Minute_validity_optional: minute_validity = {VALIDITY_KIND}.optional implies (second_validity = {VALIDITY_KIND}.optional or second_validity = {VALIDITY_KIND}.disallowed)

Minute_validity_disallowed: minute_validity = {VALIDITY_KIND}.disallowed implies second_validity = {VALIDITY_KIND}.disallowed

Second_validity_optional: second_validity = {VALIDITY_KIND}.optional implies (millisecond_validity = {VALIDITY_KIND}.optional or millisecond_validity = {VALIDITY_KIND}.disallowed)

Second_validity_disallowed: second_validity = {VALIDITY_KIND}.disallowed implies millisecond_validity = {VALIDITY_KIND}.disallowed Validity_is_range: validity_is_range = (range /= Void)

ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date/time at all. Syntax expressions of instances of this class include “YYYY-MM-DDT??:??:??” (date/time with optional time) and “YYYY-MMDDTHH:MM:xx” (date/time, seconds not allowed).

Validity of month in constrained date.

Validity of day in constrained date.

Validity of hour in constrained time.

Validity of minute in constrained time.

Validity of second in constrained time.

Validity of millisecond in constrained time.

Validity of timezone in constrained date.

Range of Date_times specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

True if validity is in the form of a range; useful for developers to check which kind of constraint has been set.

Month_validity_optional:: month_validity = {VALIDITY_KIND}.optional implies (day_validity = {VALIDITY_KIND}.optional or day_validity = {VALIDITY_KIND}.disallowed)

Month_validity_disallowed: month_validity = {VALIDITY_KIND}.disallowed implies day_validity = {VALIDITY_KIND}.disallowed

Day_validity_optional: day_validity = {VALIDITY_KIND}.optional implies (hour_validity = {VALIDITY_KIND}.optional or hour_validity = {VALIDITY_KIND}.disallowed)

Day_validity_disallowed: day_validity = {VALIDITY_KIND}.disallowed implies hour_validity = {VALIDITY_KIND}.disallowed

Hour_validity_optional: hour_validity = {VALIDITY_KIND}.optional implies (minute_validity = {VALIDITY_KIND}.optional or minute_validity = {VALIDITY_KIND}.disallowed)

Hour_validity_disallowed: hour_validity = {VALIDITY_KIND}.disallowed implies minute_validity = {VALIDITY_KIND}.disallowed

Minute_validity_optional: minute_validity = {VALIDITY_KIND}.optional implies (second_validity = {VALIDITY_KIND}.optional or second_validity = {VALIDITY_KIND}.disallowed)

Minute_validity_disallowed: minute_validity = {VALIDITY_KIND}.disallowed implies second_validity = {VALIDITY_KIND}.disallowed

Second_validity_optional: second_validity = {VALIDITY_KIND}.optional implies (millisecond_validity = {VALIDITY_KIND}.optional or millisecond_validity = {VALIDITY_KIND}.disallowed)

Second_validity_disallowed: second_validity = {VALIDITY_KIND}.disallowed implies millisecond_validity = {VALIDITY_KIND}.disallowed

Validity_is_range: validity_is_range = (range /= Void)

ISO 8601-compatible constraint on instances of Duration. In ISO 8601 terms, constraints might are of the form “PWD” (weeks and/or days), “PDTHMS” (days, hours, minutes, seconds) and so on. In official ISO 8601:2004, the ‘W’ (week) designator cannot be mixed in; allowing it is an openEHR-wide exception. Both range and the constraint pattern can be set at the same time, corresponding to the ADL constraint PWD/|P0W..P50W|.

True if months are allowed in the constrained Duration.

True if days are allowed in the constrained Duration.

True if hours are allowed in the constrained Duration.

True if minutes are allowed in the constrained Duration.

True if fractional seconds are allowed in the constrained Duration.

Range of Durations specifying constraint.

The value to assume if this item is not included in data, due to being part of an optional structure.

Local ontology of an archetype.

List of all term codes in the ontology. Most of these correspond to “at” codes in an ADL archetype, which are the node_ids on C_OBJECT descendants. There may be an extra one, if a different term is used as the overall archetype concept from that used as the node_id of the outermost C_OBJECT in the definition part.

List of all term codes in the ontology. These correspond to the “ac” codes in an ADL archetype, or equivalently, the CONSTRAINT_REF.reference values in the archetype definition.

Archetype which owns this terminology.

List of terminologies to which term or constraint bindings exist in this terminology.

Specialisation depth of this archetype. Unspecialised archetypes have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth.

True if terminology ‘a_terminology’ is present in archetype ontology.

True if terminology `a_terminology' is present in archetype ontology.

True if term_codes has a_code.

True if constraint_codes has a_code.

Term definition for a code, in a specified language.

Constraint definition for a code, in a specified language.

Binding of constraint corresponding to a_code in target external terminology a_terminology_id, as a string, which is usually a formal query expression.

Binding of constraint corresponding to a_code in target external terminology a_terminology_id, as a string, which is usually a formal query expression.

Original_language_validity: code_set (Code_set_id_languages).has_concept_id (original_language)

concept_code_validity: id_codes.has (concept_code)

Term_bindings_validity: bindings /= void implies not bindings.is_empty

Parent_archetype_valid: parent_archetype.ontology = Current

Representation of any coded entity (term or constraint) in the archetype ontology.

Code of this term.

Hash of keys (“text”, “description” etc) and corresponding values. Hash of keys ("text", "description" etc) and corresponding values.

List of all keys used in this term.

Code_valid: not code.is_empty