diff --git a/computable/BMM/openehr_am_1.4.0.bmm.json b/computable/BMM/openehr_am_1.4.0.bmm.json new file mode 100644 index 00000000..8197f21b --- /dev/null +++ b/computable/BMM/openehr_am_1.4.0.bmm.json @@ -0,0 +1,1914 @@ +{ + "bmm_version": "2.4", + "rm_publisher": "openehr", + "schema_name": "am", + "rm_release": "1.4.0", + "schema_revision": "1.4.0.2", + "schema_lifecycle_state": "stable", + "schema_description": "openEHR Archetype Model", + "schema_author": "Thomas Beale , code-generator", + "includes": { + "openehr_base_1.3.0": { + "id": "openehr_base_1.3.0" + } + }, + "packages": { + "org.openehr.am.aom14": { + "name": "org.openehr.am.aom14", + "packages": { + "openehr_archetype_profile": { + "name": "openehr_archetype_profile", + "classes": [ + "C_ORDINAL", + "C_CODED_TEXT", + "C_QUANTITY", + "C_QUANTITY_ITEM", + "ORDINAL" + ] + }, + "archetype": { + "name": "archetype", + "packages": { + "assertion": { + "name": "assertion", + "classes": [ + "ASSERTION", + "ASSERTION_VARIABLE", + "EXPR_ITEM", + "EXPR_LEAF", + "EXPR_OPERATOR", + "EXPR_UNARY_OPERATOR", + "EXPR_BINARY_OPERATOR", + "OPERATOR_KIND" + ] + }, + "constraint_model": { + "name": "constraint_model", + "classes": [ + "ARCHETYPE_CONSTRAINT", + "C_OBJECT", + "C_ATTRIBUTE", + "C_DEFINED_OBJECT", + "CARDINALITY", + "ARCHETYPE_INTERNAL_REF", + "ARCHETYPE_SLOT", + "C_SINGLE_ATTRIBUTE", + "CONSTRAINT_REF", + "C_MULTIPLE_ATTRIBUTE", + "C_DOMAIN_TYPE", + "C_REFERENCE_OBJECT", + "C_PRIMITIVE_OBJECT", + "C_COMPLEX_OBJECT" + ] + }, + "ontology": { + "name": "ontology", + "classes": [ + "ARCHETYPE_TERM", + "ARCHETYPE_ONTOLOGY" + ] + }, + "primitive": { + "name": "primitive", + "classes": [ + "C_BOOLEAN", + "C_STRING", + "C_INTEGER", + "C_REAL", + "C_TIME", + "C_DATE", + "C_DATE_TIME", + "C_DURATION", + "C_PRIMITIVE" + ] + } + }, + "classes": [ + "ARCHETYPE" + ] + } + } + } + }, + "class_definitions": { + "C_ORDINAL": { + "name": "C_ORDINAL", + "documentation": "Constrainer class for Ordinal data.", + "ancestors": [ + "C_DOMAIN_TYPE" + ], + "properties": { + "list": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "list", + "documentation": "Value set of allowed Ordinals in the constraint.", + "type_def": { + "container_type": "List", + "type": "ORDINAL" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + } + }, + "C_CODED_TEXT": { + "name": "C_CODED_TEXT", + "documentation": "Constrainer class for Coded text data.", + "ancestors": [ + "C_DOMAIN_TYPE" + ], + "properties": { + "terminology": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "terminology", + "documentation": "Terminology identifier.", + "is_mandatory": true, + "type": "String" + }, + "code_list": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "code_list", + "documentation": "Optional list of codes from the terminology. No list means any code from the terminology is allowed.", + "type_def": { + "root_type": "List", + "generic_parameters": [ + "String" + ] + } + }, + "reference": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "reference", + "type": "String" + } + } + }, + "C_QUANTITY": { + "name": "C_QUANTITY", + "documentation": "Constrainer class for Quantity data.", + "ancestors": [ + "C_DOMAIN_TYPE" + ], + "properties": { + "property": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "property", + "documentation": "Name of physical property for Quantities being constrained.", + "is_mandatory": true, + "type": "String" + }, + "list": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "list", + "documentation": "Value set of allowed individual Quantity item constraints in this Quantity constraint.", + "type_def": { + "container_type": "List", + "type": "C_QUANTITY_ITEM" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + } + }, + "C_QUANTITY_ITEM": { + "name": "C_QUANTITY_ITEM", + "documentation": "Constrainer class for a single Quantity.", + "properties": { + "magnitude": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "magnitude", + "documentation": "Quantity magnitude constraint.", + "is_mandatory": true, + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Real" + ] + } + }, + "units": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "units", + "documentation": "Optional units constraint.", + "type": "String" + } + } + }, + "ORDINAL": { + "name": "ORDINAL", + "documentation": "Constrainer object representing a single Ordinal value.", + "properties": { + "symbol": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "symbol", + "documentation": "Terminology code providing the Ordinal's symbol.", + "is_mandatory": true, + "type": "CODE_PHRASE" + }, + "value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "value", + "documentation": "Ordinal value.", + "is_mandatory": true, + "type": "Integer" + } + } + }, + "ARCHETYPE": { + "name": "ARCHETYPE", + "documentation": "Archetype equivalent to ARCHETYPED class in Common reference model. Defines semantics of identfication, lifecycle, versioning, composition and specialisation.", + "ancestors": [ + "AUTHORED_RESOURCE" + ], + "properties": { + "definition": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "definition", + "documentation": "Root node of the definition of this archetype.", + "is_mandatory": true, + "type": "C_COMPLEX_OBJECT" + }, + "ontology": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "ontology", + "documentation": "The ontology of the archetype.", + "is_mandatory": true, + "type": "ARCHETYPE_ONTOLOGY" + }, + "adl_version": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "adl_version", + "documentation": "ADL version if archetype was read in from an ADL sharable archetype.", + "type": "String" + }, + "archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_id", + "documentation": "Multi-axial identifier of this archetype in archetype space.", + "is_mandatory": true, + "type": "ARCHETYPE_ID" + }, + "uid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "uid", + "documentation": "OID identifier of this archetype.", + "type": "HIER_OBJECT_ID" + }, + "concept": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "concept", + "documentation": "The normative meaning of the archetype as a whole, expressed as a local archetype code, typically \u201cat0000\u201d.", + "is_mandatory": true, + "type": "String" + }, + "parent_archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "parent_archetype_id", + "documentation": "Identifier of the specialisation parent of this archetype.", + "type": "ARCHETYPE_ID" + }, + "invariants": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "invariants", + "documentation": "Invariant statements about this object. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.", + "type_def": { + "container_type": "List", + "type": "ASSERTION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "concept_name": { + "name": "concept_name", + "documentation": "The concept name of the archetype in language a_lang; corresponds to the term definition of the concept attribute in the archetype ontology.", + "parameters": { + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + } + }, + "post_conditions": { + "post-condition": "Result.is_equal (definition.node_id)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "physical_paths": { + "name": "physical_paths", + "documentation": "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. ", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "logical_paths": { + "name": "logical_paths", + "documentation": "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. ", + "parameters": { + "lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "lang", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "specialisation_depth": { + "name": "specialisation_depth", + "documentation": "Specialisation depth of this archetype; larger than 0 if this archetype has a parent. Derived from terminology.specialisation_depth.", + "post_conditions": { + "post-condition": "Result = terminology.specialisation_depth" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + }, + "is_specialised": { + "name": "is_specialised", + "documentation": "True if this archetype is a specialisation of another. ", + "post_conditions": { + "post-condition": "Result implies parent_archetype_id \/= Void" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_valid": { + "name": "is_valid", + "documentation": "True if the archetype is valid overall; various tests should be used, including checks on node_ids, internal references, and constraint references.", + "post_conditions": { + "Post": "not (node_ids_valid and internal_references_valid and constraint_references_valid) implies not Result" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "node_ids_valid": { + "name": "node_ids_valid", + "documentation": "True if every node_id found on a C_OBJECT node is found in ontology.term_codes.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "previous_version": { + "name": "previous_version", + "documentation": "Version of predecessor archetype of this archetype, if any.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "is_nullable": true + }, + "internal_references_valid": { + "name": "internal_references_valid", + "documentation": "True if every ARCHETYPE_INTERNAL_REF. target_path refers to a legitimate node in the archetype definition.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "constraint_references_valid": { + "name": "constraint_references_valid", + "documentation": "True if every CONSTRAINT_REF.reference found on a C_OBJECT node in the archetype definition is found in ontology.constraint_codes.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "short_concept_name": { + "name": "short_concept_name", + "documentation": "The short concept name of the archetype extracted from the archetype_id.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "version": { + "name": "version", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + } + }, + "invariants": { + "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" + } + }, + "ASSERTION": { + "name": "ASSERTION", + "documentation": "Structural model of a typed first order predicate logic assertion, in the form of an expression tree, including optional variable definitions. ", + "properties": { + "tag": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "tag", + "documentation": "Expression tag, used for differentiating multiple assertions.", + "type": "String" + }, + "string_expression": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "string_expression", + "documentation": "String form of expression, in case an expression evaluator taking String expressions is used for evaluation. ", + "type": "String" + }, + "expression": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "expression", + "documentation": "Root of expression tree.", + "is_mandatory": true, + "type": "EXPR_ITEM" + }, + "variables": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "variables", + "documentation": "Definitions of variables used in the assertion expression.", + "type_def": { + "container_type": "List", + "type": "ASSERTION_VARIABLE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "invariants": { + "Tag_valid": "tag \/= Void implies not tag.is_empty", + "Expression_valid": "expression \/= Void and then expression.type.is_equal(\u201cBOOLEAN\u201d)" + } + }, + "ASSERTION_VARIABLE": { + "name": "ASSERTION_VARIABLE", + "documentation": "Definition of a named variable used in an assertion expression.", + "properties": { + "name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "name", + "documentation": "Name of variable.", + "is_mandatory": true, + "type": "String" + }, + "definition": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "definition", + "documentation": "Formal definition of the variable.", + "is_mandatory": true, + "type": "String" + } + } + }, + "EXPR_ITEM": { + "name": "EXPR_ITEM", + "documentation": "Abstract parent of all expression tree items.", + "is_abstract": true, + "properties": { + "type": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "type", + "documentation": "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 \u201cBoolean\u201d, while the type for any arithmetic operator, will be \u201cReal\u201d or \u201cInteger\u201d.", + "is_mandatory": true, + "type": "String" + } + } + }, + "EXPR_LEAF": { + "name": "EXPR_LEAF", + "documentation": "Expression tree leaf item representing one of:\n\n* a manifest constant of any primitive type;\n* a path referring to a value in the archetype;\n* a constraint;\n* a variable reference.\n", + "ancestors": [ + "EXPR_ITEM" + ], + "properties": { + "reference_type": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "reference_type", + "documentation": "Type of reference: \u201cconstant\u201d, \u201cattribute\u201d, \u201cfunction\u201d, \u201cconstraint\u201d. 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 \u2018matches\u2019 operator.", + "is_mandatory": true, + "type": "String" + }, + "item": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "item", + "documentation": "The value referred to; a manifest constant, an attribute path (in the form of a String), or for the right-hand side of a \u2018matches\u2019 node, a constraint, often a C_PRIMITIVE_OBJECT.", + "is_mandatory": true, + "type": "Any" + } + } + }, + "EXPR_OPERATOR": { + "name": "EXPR_OPERATOR", + "documentation": "Abstract parent of operator types.", + "is_abstract": true, + "ancestors": [ + "EXPR_ITEM" + ], + "properties": { + "precedence_overridden": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "precedence_overridden", + "documentation": "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.", + "type": "Boolean" + }, + "operator": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "operator", + "documentation": "Code of operator.", + "is_mandatory": true, + "type": "OPERATOR_KIND" + } + } + }, + "EXPR_UNARY_OPERATOR": { + "name": "EXPR_UNARY_OPERATOR", + "documentation": "Unary operator expression node.", + "ancestors": [ + "EXPR_OPERATOR" + ], + "properties": { + "operand": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "operand", + "documentation": "Operand node.", + "is_mandatory": true, + "type": "EXPR_ITEM" + } + } + }, + "EXPR_BINARY_OPERATOR": { + "name": "EXPR_BINARY_OPERATOR", + "documentation": "Binary operator expression node.", + "ancestors": [ + "EXPR_OPERATOR" + ], + "properties": { + "left_operand": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "left_operand", + "documentation": "Left operand node.", + "is_mandatory": true, + "type": "EXPR_ITEM" + }, + "right_operand": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "right_operand", + "documentation": "Right operand node.", + "is_mandatory": true, + "type": "EXPR_ITEM" + } + } + }, + "OPERATOR_KIND": { + "_type": "P_BMM_ENUMERATION_STRING", + "name": "OPERATOR_KIND", + "documentation": "Enumeration type for operator types in assertion expressions.", + "ancestors": [ + "String" + ], + "item_names": [ + "op_eq", + "op_ne", + "op_le", + "op_lt", + "op_ge", + "op_gt", + "op_matches", + "op_not", + "op_and", + "op_or", + "op_xor", + "op_implies", + "op_for_all", + "op_exists", + "op_plus", + "op_minus", + "op_multiply", + "op_divide", + "op_exponent" + ], + "item_documentations": [ + "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 (^)" + ] + }, + "ARCHETYPE_CONSTRAINT": { + "name": "ARCHETYPE_CONSTRAINT", + "documentation": "Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model. ", + "is_abstract": true, + "functions": { + "is_subset_of": { + "name": "is_subset_of", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of special-ised archetype nodes.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_valid": { + "name": "is_valid", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "path": { + "name": "path", + "documentation": "Path of this node relative to root of archetype.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "has_path": { + "name": "has_path", + "documentation": "True if the relative path a_path exists at this node.", + "parameters": { + "a_path": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_path", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Post": "Result = soc_parent \/= Void or parent.soc_parent \/= Void", + "Path_exists": "path \/= Void" + } + }, + "C_OBJECT": { + "name": "C_OBJECT", + "documentation": "Abstract model of constraint on any kind of object node. ", + "is_abstract": true, + "ancestors": [ + "ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_type_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_type_name", + "documentation": "Reference model type that this node corresponds to. ", + "is_mandatory": true, + "type": "String" + }, + "occurrences": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "occurrences", + "documentation": "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).", + "is_mandatory": true, + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Integer" + ] + } + }, + "node_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "node_id", + "documentation": "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 at-codes.\nFor C_PRIMITIVE_OBJECTs, it will have the special value Primitive_node_id.", + "is_mandatory": true, + "type": "String" + } + } + }, + "C_ATTRIBUTE": { + "name": "C_ATTRIBUTE", + "documentation": "Abstract model of constraint on any kind of attribute node.", + "is_abstract": true, + "ancestors": [ + "ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_attribute_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_attribute_name", + "documentation": "Reference model attribute within the enclosing type represented by a C_OBJECT.", + "is_mandatory": true, + "type": "String" + }, + "existence": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "existence", + "documentation": "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).", + "is_mandatory": true, + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Integer" + ] + } + }, + "children": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "children", + "documentation": "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. ", + "type_def": { + "container_type": "List", + "type": "C_OBJECT" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model attribute represented by this C_ATTIRBUTE is allowed.", + "post_conditions": { + "Post": "Result := children = Void or else children.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "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" + } + }, + "C_DEFINED_OBJECT": { + "name": "C_DEFINED_OBJECT", + "documentation": "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. ", + "is_abstract": true, + "ancestors": [ + "C_OBJECT" + ], + "properties": { + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Any" + } + }, + "functions": { + "valid_value": { + "name": "valid_value", + "documentation": "True if a_value is valid with respect to constraint expressed in concrete instance of this type.", + "is_abstract": true, + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "Any" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "prototype_value": { + "name": "prototype_value", + "documentation": "Generate a prototype value from this constraint object.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Any" + } + }, + "has_assumed_value": { + "name": "has_assumed_value", + "documentation": "True if there is an assumed value.\n", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "default_value": { + "name": "default_value", + "documentation": "Generate a default value from this constraint object.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Any" + }, + "is_nullable": true + }, + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value of the reference model type being constrained is allowed. Redefine in descendants.", + "is_abstract": true, + "post_conditions": { + "Post": "Result = attributes.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Assumed_value_valid": "has_assumed_value implies valid_value(assumed_value)" + } + }, + "CARDINALITY": { + "name": "CARDINALITY", + "documentation": "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.", + "properties": { + "interval": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "interval", + "documentation": "The interval of this cardinality. ", + "is_mandatory": true, + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Integer" + ] + } + }, + "is_ordered": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_ordered", + "documentation": "True if the members of the container attribute to which this cardinality refers are ordered. ", + "is_mandatory": true, + "type": "Boolean" + }, + "is_unique": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_unique", + "documentation": "True if the members of the container attribute to which this cardinality refers are unique.", + "is_mandatory": true, + "type": "Boolean" + } + }, + "functions": { + "is_bag": { + "name": "is_bag", + "documentation": "True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_list": { + "name": "is_list", + "documentation": "True if the semantics of this cardinality represent a list, i.e. ordered, non-unique membership.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_set": { + "name": "is_set", + "documentation": "True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "ARCHETYPE_INTERNAL_REF": { + "name": "ARCHETYPE_INTERNAL_REF", + "documentation": "A constraint defined by proxy, using a reference to an object constraint defined elsewhere in the same\narchetype.\n\nNote 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.", + "ancestors": [ + "C_REFERENCE_OBJECT" + ], + "properties": { + "target_path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "target_path", + "documentation": "Reference to an object node using archetype path notation.", + "is_mandatory": true, + "type": "String" + } + }, + "invariants": { + "Consistency": "not any_allowed", + "Target_path_valid": "target_path \/= Void and then not target_path.is_empty" + } + }, + "ARCHETYPE_SLOT": { + "name": "ARCHETYPE_SLOT", + "documentation": "Constraint describing a slot' where another archetype can occur. ", + "ancestors": [ + "C_REFERENCE_OBJECT" + ], + "properties": { + "includes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "includes", + "documentation": "List of constraints defining other archetypes that could be included at this point. ", + "type_def": { + "container_type": "List", + "type": "ASSERTION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "excludes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "excludes", + "documentation": "List of constraints defining other archetypes that cannot be included at this point. ", + "type_def": { + "container_type": "List", + "type": "ASSERTION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "invariants": { + "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)" + } + }, + "C_SINGLE_ATTRIBUTE": { + "name": "C_SINGLE_ATTRIBUTE", + "documentation": "Concrete model of constraint on a single-valued attribute node. The meaning of the inherited children attribute is that they are alternatives.", + "ancestors": [ + "C_ATTRIBUTE" + ], + "functions": { + "alternatives": { + "name": "alternatives", + "documentation": "List of alternative constraints for the single child of this attribute within the data.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "C_OBJECT" + }, + "is_nullable": true + } + }, + "invariants": { + "Members_valid": "alternatives \/= Void and then alternatives.for_all(co: C_OBJECT | co.occurrences.upper <= 1)" + } + }, + "CONSTRAINT_REF": { + "name": "CONSTRAINT_REF", + "documentation": "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.", + "ancestors": [ + "C_REFERENCE_OBJECT" + ], + "properties": { + "reference": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "reference", + "documentation": "Reference to a constraint in the archetype local ontology.", + "is_mandatory": true, + "type": "String" + } + }, + "invariants": { + "Consistency": "not any_allowed" + } + }, + "C_MULTIPLE_ATTRIBUTE": { + "name": "C_MULTIPLE_ATTRIBUTE", + "documentation": "Concrete model of constraint on multiply-valued (ie. container) attribute node.", + "ancestors": [ + "C_ATTRIBUTE" + ], + "properties": { + "cardinality": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "cardinality", + "documentation": "Cardinality of this attribute constraint, if it constraints a container attribute.", + "is_mandatory": true, + "type": "CARDINALITY" + } + }, + "functions": { + "members": { + "name": "members", + "documentation": "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.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "C_OBJECT" + }, + "is_nullable": true + } + } + }, + "C_DOMAIN_TYPE": { + "name": "C_DOMAIN_TYPE", + "documentation": "Abstract parent type of domain-specific constrainer types, to be defined in external packages.", + "is_abstract": true, + "ancestors": [ + "C_DEFINED_OBJECT" + ], + "functions": { + "standard_equivalent": { + "name": "standard_equivalent", + "documentation": "Standard (i.e. C_OBJECT) form of constraint.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "C_COMPLEX_OBJECT" + } + } + } + }, + "C_REFERENCE_OBJECT": { + "name": "C_REFERENCE_OBJECT", + "documentation": "Abstract parent type of C_OBJECT subtypes that are defined by reference.", + "is_abstract": true, + "ancestors": [ + "C_OBJECT" + ] + }, + "C_PRIMITIVE_OBJECT": { + "name": "C_PRIMITIVE_OBJECT", + "documentation": "Constraint on a primitive type.", + "ancestors": [ + "C_DEFINED_OBJECT" + ], + "properties": { + "item": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "item", + "documentation": "Object actually defining the constraint.", + "is_mandatory": true, + "type": "C_PRIMITIVE" + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value of the type being constrained in item is allowed.", + "post_conditions": { + "Post": "Result = item = Void" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Item_valid": "any_allowed xor item \/= Void" + } + }, + "C_COMPLEX_OBJECT": { + "name": "C_COMPLEX_OBJECT", + "documentation": "Constraint on complex objects, i.e. any object that consists of other object constraints.", + "ancestors": [ + "C_DEFINED_OBJECT" + ], + "properties": { + "attributes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "attributes", + "documentation": "List of constraints on attributes of the reference model type represented by this object.", + "type_def": { + "container_type": "List", + "type": "C_ATTRIBUTE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value of the reference model type being constrained is allowed.", + "post_conditions": { + "Post": "Result = attributes.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Attributes_valid": " any_allowed xor (attributes \/= Void and not attributes.is_empty)" + } + }, + "ARCHETYPE_TERM": { + "name": "ARCHETYPE_TERM", + "documentation": "Representation of any coded entity (term or constraint) in the archetype ontology.", + "properties": { + "code": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "code", + "documentation": "Code of this term. ", + "is_mandatory": true, + "type": "String" + }, + "items": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "items", + "documentation": "Hash of keys (\u201ctext\u201d, \u201cdescription\u201d etc) and corresponding values.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + }, + "functions": { + "keys": { + "name": "keys", + "documentation": "List of all keys used in this term.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + }, + "is_nullable": true + } + }, + "invariants": { + "Code_valid": "not code.is_empty" + } + }, + "ARCHETYPE_ONTOLOGY": { + "name": "ARCHETYPE_ONTOLOGY", + "documentation": "Local ontology of an archetype.", + "properties": { + "term_codes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "term_codes", + "documentation": "List of all term codes in the ontology. Most of these correspond to \u201cat\u201d 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.", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "constraint_codes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint_codes", + "documentation": "List of all term codes in the ontology. These correspond to the \u201cac\u201d codes in an ADL archetype, or equivalently, the CONSTRAINT_REF.reference values in the archetype definition.", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "parent_archetype": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "parent_archetype", + "documentation": "Archetype which owns this terminology.", + "is_mandatory": true, + "type": "ARCHETYPE" + }, + "terminologies_available": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "terminologies_available", + "documentation": "List of terminologies to which term or constraint bindings exist in this terminology.", + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "specialisation_depth": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "specialisation_depth", + "documentation": "Specialisation depth of this archetype. Unspecialised archetypes have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth.", + "is_mandatory": true, + "type": "Integer" + }, + "term_attribute_names": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "term_attribute_names", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + } + }, + "functions": { + "has_language": { + "name": "has_language", + "documentation": "True if terminology \u2018a_terminology\u2019 is present in archetype ontology.", + "parameters": { + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_terminology": { + "name": "has_terminology", + "documentation": "True if terminology `a_terminology' is present in archetype ontology. ", + "parameters": { + "a_terminology_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology_id", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_term_code": { + "name": "has_term_code", + "documentation": "True if term_codes has a_code.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_constraint_code": { + "name": "has_constraint_code", + "documentation": "True if constraint_codes has a_code.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "term_definition": { + "name": "term_definition", + "documentation": "Term definition for a code, in a specified language. ", + "parameters": { + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_language (a_lang)", + "Pre2": "has_term_code (a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "ARCHETYPE_TERM" + } + }, + "constraint_definition": { + "name": "constraint_definition", + "documentation": "Constraint definition for a code, in a specified language.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + }, + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_language (a_lang)", + "Pre_2": "has_constraint_code (a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "ARCHETYPE_TERM" + } + }, + "term_binding": { + "name": "term_binding", + "documentation": "Binding of constraint corresponding to a_code in target external terminology a_terminology_id, as a string, which is usually a formal query expression.", + "parameters": { + "a_terminology": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_term_binding (a_terminology_id, a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "CODE_PHRASE" + } + }, + "constraint_binding": { + "name": "constraint_binding", + "documentation": "Binding of constraint corresponding to a_code in target external terminology a_terminology_id, as a string, which is usually a formal query expression.", + "parameters": { + "a_terminology_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology_id", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + } + }, + "invariants": { + "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" + } + }, + "C_BOOLEAN": { + "name": "C_BOOLEAN", + "documentation": "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.", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "true_valid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "true_valid", + "documentation": "True if the value True is allowed.", + "is_mandatory": true, + "type": "Boolean" + }, + "false_valid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "false_valid", + "documentation": "True if the value False is allowed.", + "is_mandatory": true, + "type": "Boolean" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Boolean" + } + } + }, + "C_STRING": { + "name": "C_STRING", + "documentation": "Constraint on instances of STRING. ", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "pattern": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "pattern", + "documentation": "Regular expression pattern for proposed instances of String to match.", + "type": "String" + }, + "list": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "list", + "documentation": "Set of Strings specifying constraint.", + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "list_open": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "list_open", + "documentation": "True if the list is being used to specify the constraint but is not considered exhaustive.", + "is_mandatory": true, + "type": "Boolean" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "String" + } + }, + "functions": { + "valid_value": { + "name": "valid_value", + "documentation": "True if a_value is valid with respect to constraint expressed in concrete instance of this type. ", + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_INTEGER": { + "name": "C_INTEGER", + "documentation": "Constraint on instances of Integer.", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "list": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "list", + "documentation": "Set of Integers specifying constraint.", + "type_def": { + "container_type": "List", + "type": "Integer" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Range of Integers specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Integer" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Integer" + } + } + }, + "C_REAL": { + "name": "C_REAL", + "documentation": "Constraint on instances of Real.", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "list": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "list", + "documentation": "Set of Reals specifying constraint.", + "type_def": { + "container_type": "List", + "type": "Real" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Range of Real specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Real" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Real" + } + } + }, + "C_TIME": { + "name": "C_TIME", + "documentation": "ISO 8601-compatible constraint on instances of Time. There is no validity flag for \u2018hour\u2019, 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 \u201cHH:??:xx\u201d (time with optional minutes and seconds not allowed).", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "minute_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "minute_validity", + "documentation": "Validity of minute in constrained time.", + "type": "VALIDITY_KIND" + }, + "second_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "second_validity", + "documentation": "Validity of second in constrained time.", + "type": "VALIDITY_KIND" + }, + "millisecond_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "millisecond_validity", + "documentation": "Validity of millisecond in constrained time.", + "type": "VALIDITY_KIND" + }, + "timezone_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "timezone_validity", + "documentation": "Validity of timezone in constrained date.", + "type": "VALIDITY_KIND" + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Interval of Times specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_time" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Iso8601_time" + } + }, + "functions": { + "validity_is_range": { + "name": "validity_is_range", + "documentation": "True if validity is in the form of a range; useful for developers to check which kind of constraint has been set.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_time_constraint_pattern (pattern)", + "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)" + } + }, + "C_DATE": { + "name": "C_DATE", + "documentation": "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 \u2018year\u2019, 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 \u201cYYYY-??-??\u201d (date with optional month and day).", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "day_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "day_validity", + "documentation": "Validity of day in constrained date.", + "type": "VALIDITY_KIND" + }, + "month_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "month_validity", + "documentation": "Validity of month in constrained date.", + "type": "VALIDITY_KIND" + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Interval of Dates specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_date" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Iso8601_date" + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_date_constraint_pattern(pattern)", + "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)" + } + }, + "C_DATE_TIME": { + "name": "C_DATE_TIME", + "documentation": "ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for \u2018year\u2019, 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 \u201cYYYY-MM-DDT??:??:??\u201d (date\/time with optional time) and \u201cYYYY-MMDDTHH:MM:xx\u201d (date\/time, seconds not allowed).", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "month_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "month_validity", + "documentation": "Validity of month in constrained date.", + "type": "VALIDITY_KIND" + }, + "day_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "day_validity", + "documentation": "Validity of day in constrained date.", + "type": "VALIDITY_KIND" + }, + "hour_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "hour_validity", + "documentation": "Validity of hour in constrained time.", + "type": "VALIDITY_KIND" + }, + "minute_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "minute_validity", + "documentation": "Validity of minute in constrained time.", + "type": "VALIDITY_KIND" + }, + "second_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "second_validity", + "documentation": "Validity of second in constrained time.", + "type": "VALIDITY_KIND" + }, + "millisecond_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "millisecond_validity", + "documentation": "Validity of millisecond in constrained time.", + "type": "VALIDITY_KIND" + }, + "timezone_validity": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "timezone_validity", + "documentation": "Validity of timezone in constrained date.", + "type": "VALIDITY_KIND" + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Range of Date_times specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_date_time" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Iso8601_date_time" + } + }, + "functions": { + "validity_is_range": { + "name": "validity_is_range", + "documentation": "True if validity is in the form of a range; useful for developers to check which kind of constraint has been set.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_date_time_constraint_pattern(pattern)", + "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)" + } + }, + "C_DURATION": { + "name": "C_DURATION", + "documentation": "ISO 8601-compatible constraint on instances of Duration. In ISO 8601 terms, constraints might are of the form \u201cPWD\u201d (weeks and\/or days), \u201cPDTHMS\u201d (days, hours, minutes, seconds) and so on.\n\nBoth range and the constraint pattern can be set at the same time, corresponding to the ADL constraint `\"PWD\/|P0W..P50W|\"`.\n\nAs for all of openEHR, two ISO 8601 exceptions are allowed: \n\n* the \u2018W\u2019 (week) designator can be mixed in - the allowed patterns are: `P[Y|y][M|m][D|d][T[H|h][M|m][S|s]]` and `P[W|w]`;\n* the values used in an interval constraint may be negated, i.e. a leading minus (`'-'`) sign may be used.\n", + "ancestors": [ + "C_PRIMITIVE" + ], + "properties": { + "years_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "years_allowed", + "type": "Boolean" + }, + "months_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "months_allowed", + "documentation": "True if months are allowed in the constrained Duration.", + "type": "Boolean" + }, + "weeks_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "weeks_allowed", + "type": "Boolean" + }, + "days_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "days_allowed", + "documentation": "True if days are allowed in the constrained Duration.", + "type": "Boolean" + }, + "hours_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "hours_allowed", + "documentation": "True if hours are allowed in the constrained Duration.", + "type": "Boolean" + }, + "minutes_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "minutes_allowed", + "documentation": "True if minutes are allowed in the constrained Duration.", + "type": "Boolean" + }, + "seconds_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "seconds_allowed", + "type": "Boolean" + }, + "fractional_seconds_allowed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "fractional_seconds_allowed", + "documentation": "True if fractional seconds are allowed in the constrained Duration.", + "type": "Boolean" + }, + "range": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "range", + "documentation": "Range of Durations specifying constraint.", + "type_def": { + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_duration" + ] + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "The value to assume if this item is not included in data, due to being part of an optional structure.", + "type": "Iso8601_duration" + } + } + }, + "C_PRIMITIVE": { + "name": "C_PRIMITIVE", + "documentation": "Parent of types representing constraints on primitive types.", + "is_abstract": true, + "properties": { + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Any" + } + }, + "functions": { + "default_value": { + "name": "default_value", + "documentation": "Generate a default value from this constraint object.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Any" + } + }, + "has_assumed_value": { + "name": "has_assumed_value", + "documentation": "True if there is an assumed value.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_value": { + "name": "valid_value", + "documentation": "True if a_value is valid with respect to constraint expressed in concrete instance of this type.", + "is_abstract": true, + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "Any" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Assumed_value_valid": "has_assumed_value implies valid_value(assumed_value)" + } + } + } +} diff --git a/computable/BMM/openehr_am_2.4.0.bmm.json b/computable/BMM/openehr_am_2.4.0.bmm.json new file mode 100644 index 00000000..1777a2cb --- /dev/null +++ b/computable/BMM/openehr_am_2.4.0.bmm.json @@ -0,0 +1,4625 @@ +{ + "bmm_version": "2.4", + "rm_publisher": "openehr", + "schema_name": "am", + "rm_release": "2.4.0", + "schema_revision": "2.4.0.2", + "schema_lifecycle_state": "stable", + "schema_description": "openEHR Archetype Model", + "schema_author": "Thomas Beale , code-generator", + "includes": { + "openehr_base_1.3.0": { + "id": "openehr_base_1.3.0" + }, + "openehr_lang_1.1.0": { + "id": "openehr_lang_1.1.0" + } + }, + "packages": { + "org.openehr.am.aom2": { + "name": "org.openehr.am.aom2", + "packages": { + "archetype": { + "name": "archetype", + "classes": [ + "ARCHETYPE", + "AUTHORED_ARCHETYPE", + "TEMPLATE", + "OPERATIONAL_TEMPLATE", + "TEMPLATE_OVERLAY", + "ARCHETYPE_HRID" + ] + }, + "constraint_model": { + "name": "constraint_model", + "packages": { + "primitive": { + "name": "primitive", + "classes": [ + "C_BOOLEAN", + "C_STRING", + "C_INTEGER", + "C_REAL", + "C_ORDERED", + "C_TERMINOLOGY_CODE", + "C_TEMPORAL", + "C_TIME", + "C_DATE", + "C_DATE_TIME", + "C_DURATION", + "C_TEMPORAL_DEFINITIONS", + "CONSTRAINT_STATUS" + ] + } + }, + "classes": [ + "ARCHETYPE_CONSTRAINT", + "C_OBJECT", + "C_ATTRIBUTE", + "C_DEFINED_OBJECT", + "C_COMPLEX_OBJECT_PROXY", + "ARCHETYPE_SLOT", + "C_PRIMITIVE_OBJECT", + "SIBLING_ORDER", + "C_ATTRIBUTE_TUPLE", + "C_PRIMITIVE_TUPLE", + "C_SECOND_ORDER", + "C_ARCHETYPE_ROOT", + "C_COMPLEX_OBJECT", + "ARCHETYPE_ID_CONSTRAINT" + ] + }, + "terminology": { + "name": "terminology", + "classes": [ + "ARCHETYPE_TERM", + "TERMINOLOGY_RELATION", + "VALUE_SET", + "ARCHETYPE_TERMINOLOGY" + ] + }, + "definitions": { + "name": "definitions", + "classes": [ + "ADL_CODE_DEFINITIONS" + ] + }, + "rm_overlay": { + "name": "rm_overlay", + "classes": [ + "RM_ATTRIBUTE_VISIBILITY", + "RM_OVERLAY", + "VISIBILITY_TYPE" + ] + }, + "persistence": { + "name": "persistence", + "packages": { + "constraint_model": { + "name": "constraint_model", + "classes": [ + "P_ARCHETYPE_CONSTRAINT", + "P_C_OBJECT", + "P_C_ATTRIBUTE", + "P_C_DEFINED_OBJECT", + "P_C_COMPLEX_OBJECT_PROXY", + "P_ARCHETYPE_SLOT", + "P_C_PRIMITIVE_OBJECT", + "P_C_COMPLEX_OBJECT", + "P_C_ATTRIBUTE_TUPLE", + "P_C_ARCHETYPE_ROOT" + ] + }, + "primitive": { + "name": "primitive", + "classes": [ + "P_C_BOOLEAN", + "P_C_STRING", + "P_C_INTEGER", + "P_C_REAL", + "P_C_ORDERED", + "P_C_TERMINOLOGY_CODE", + "P_C_TEMPORAL", + "P_C_TIME", + "P_C_DATE", + "P_C_DATE_TIME", + "P_C_DURATION" + ] + }, + "archetype": { + "name": "archetype", + "classes": [ + "P_ARCHETYPE", + "P_AUTHORED_ARCHETYPE", + "P_TEMPLATE", + "P_OPERATIONAL_TEMPLATE", + "P_ARCHETYPE_HRID", + "P_AUTHORED_RESOURCE" + ] + }, + "terminology": { + "name": "terminology", + "classes": [ + "P_ARCHETYPE_TERMINOLOGY" + ] + } + } + }, + "profile": { + "name": "profile", + "classes": [ + "AOM_PROFILE", + "AOM_TYPE_MAPPING", + "AOM_PROPERTY_MAPPING" + ] + }, + "rules": { + "name": "rules", + "classes": [ + "EXPR_ARCHETYPE_ID_CONSTRAINT", + "EXPR_ARCHETYPE_REF", + "EXPR_CONSTRAINT" + ] + } + } + } + }, + "class_definitions": { + "ARCHETYPE": { + "name": "ARCHETYPE", + "documentation": "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. \nIt is the parent class of all concrete types of archetype.", + "is_abstract": true, + "properties": { + "parent_archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "parent_archetype_id", + "documentation": "Archetype reference of the specialisation parent 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 may be a full archetype identifier.", + "type": "String" + }, + "archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_id", + "documentation": "Identifier of this archetype.", + "is_mandatory": true, + "type": "ARCHETYPE_HRID" + }, + "is_differential": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_differential", + "documentation": "Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True.", + "is_mandatory": true, + "type": "Boolean" + }, + "definition": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "definition", + "documentation": "Root node of the definition of this archetype.", + "is_mandatory": true, + "type": "C_COMPLEX_OBJECT" + }, + "terminology": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "terminology", + "documentation": "The terminology of the archetype.", + "is_mandatory": true, + "type": "ARCHETYPE_TERMINOLOGY" + }, + "rules": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "rules", + "documentation": "Rules relating to this archetype. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.", + "type_def": { + "container_type": "List", + "type": "STATEMENT_SET" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "rm_overlay": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_overlay", + "type": "RM_OVERLAY" + } + }, + "functions": { + "concept_code": { + "name": "concept_code", + "documentation": "The concept code of the root object of the archetype, also standing for the concept of the archetype as a whole.", + "post_conditions": { + "post-condition": "Result.is_equal (definition.node_id)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "physical_paths": { + "name": "physical_paths", + "documentation": "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. ", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "logical_paths": { + "name": "logical_paths", + "documentation": "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 terminology. ", + "parameters": { + "lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "lang", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "specialisation_depth": { + "name": "specialisation_depth", + "documentation": "Specialisation depth of this archetype; larger than 0 if this archetype has a parent. Derived from terminology.specialisation_depth.", + "post_conditions": { + "post-condition": "Result = terminology.specialisation_depth" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + }, + "is_specialised": { + "name": "is_specialised", + "documentation": "True if this archetype is a specialisation of another. ", + "post_conditions": { + "post-condition": "Result implies parent_archetype_hrid \/= Void" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Invariant_concept_valid": "terminology.has_term_code (concept_code)", + "Invariant_specialisation_validity": "is_specialised implies specialisation_depth > 0" + } + }, + "AUTHORED_ARCHETYPE": { + "name": "AUTHORED_ARCHETYPE", + "documentation": "Root object of a standalone, authored archetype, including all meta-data, description, other identifiers and lifecycle.", + "ancestors": [ + "ARCHETYPE", + "AUTHORED_RESOURCE" + ], + "properties": { + "adl_version": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "adl_version", + "documentation": "ADL version if archetype was read in from an ADL sharable archetype.", + "type": "String" + }, + "build_uid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "build_uid", + "documentation": "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.", + "is_mandatory": true, + "type": "UUID" + }, + "rm_release": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_release", + "documentation": "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.", + "is_mandatory": true, + "type": "String" + }, + "is_generated": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_generated", + "documentation": "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.", + "is_mandatory": true, + "type": "Boolean" + }, + "other_meta_data": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "other_meta_data", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + }, + "invariants": { + "Invariant_adl_version_validity": "valid_version_id (adl_version)", + "Invariant_rm_release": "valid_version_id (rm_release)", + "Description_validity": "description \/= Void" + } + }, + "TEMPLATE": { + "name": "TEMPLATE", + "documentation": "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.", + "ancestors": [ + "AUTHORED_ARCHETYPE" + ], + "properties": { + "overlays": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "overlays", + "documentation": "Overlay archetypes, i.e. partial archetypes that include full definition and terminology, but logically derive all their meta-data from the owning template.", + "type_def": { + "container_type": "List", + "type": "TEMPLATE_OVERLAY" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "invariants": { + "Inv_is_specialised": "is_specialised" + } + }, + "OPERATIONAL_TEMPLATE": { + "name": "OPERATIONAL_TEMPLATE", + "documentation": "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.\n\nAn 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.", + "ancestors": [ + "AUTHORED_ARCHETYPE" + ], + "properties": { + "component_terminologies": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "component_terminologies", + "documentation": "Compendium of flattened terminologies of archetypes referenced from this template, keyed by archetype identifier. This will almost always be present in a template.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERMINOLOGY" + ] + } + }, + "terminology_extracts": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "terminology_extracts", + "documentation": "Compendium of flattened terminology extracts (i.e. from external terminologies) from archetypes referenced from this template, keyed by archetype identifier.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERMINOLOGY" + ] + } + } + }, + "functions": { + "component_terminology": { + "name": "component_terminology", + "parameters": { + "an_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_id", + "type": "String" + } + }, + "post_conditions": { + "Inv_is_specialised": "is_specialised" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "ARCHETYPE_TERMINOLOGY" + } + } + }, + "invariants": { + "Specialisation_validity": "is_specialised" + } + }, + "TEMPLATE_OVERLAY": { + "name": "TEMPLATE_OVERLAY", + "documentation": "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.", + "ancestors": [ + "ARCHETYPE" + ], + "invariants": { + "Inv_is_specialised": "is_specialised" + } + }, + "ARCHETYPE_HRID": { + "name": "ARCHETYPE_HRID", + "documentation": "Human-readable structured identifier (HRID) for an archetype or template.", + "properties": { + "namespace": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "namespace", + "documentation": "Reverse domain name namespace identifier.", + "type": "String" + }, + "rm_publisher": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_publisher", + "documentation": "Name of the Reference Model publisher.", + "is_mandatory": true, + "type": "String" + }, + "rm_package": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_package", + "documentation": "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).", + "is_mandatory": true, + "type": "String" + }, + "rm_class": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_class", + "documentation": "Name of the root class of this archetype.", + "is_mandatory": true, + "type": "String" + }, + "concept_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "concept_id", + "documentation": "The short concept name of the archetype as used in the multi-axial `_archetype_hrid_`.", + "is_mandatory": true, + "type": "String" + }, + "release_version": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "release_version", + "documentation": "The full numeric version of this archetype consisting of 3 parts, e.g. `\"1.8.2\"`.", + "is_mandatory": true, + "type": "String" + }, + "version_status": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "version_status", + "documentation": "The status of the version, i.e.:\n\n* released: (empty string)\n* release_candidate: `\"rc\"`\n* alpha: `\"alpha\"`\n* beta: `\"beta\"`", + "is_mandatory": true, + "type": "VERSION_STATUS" + }, + "build_count": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "build_count", + "documentation": "The build count since last increment of any version part.", + "is_mandatory": true, + "type": "String" + } + }, + "functions": { + "semantic_id": { + "name": "semantic_id", + "documentation": "The 'interface' form of the HRID, i.e. down to the major version.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "physical_id": { + "name": "physical_id", + "documentation": "The 'physical' form of the HRID, i.e. with complete version information specified by `_version_id()_`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "version_id": { + "name": "version_id", + "documentation": "Full version identifier string, based on `_release_version_`, `_version_status_`, and `_build_count_` e.g. `\"1.8.2-rc.4\"`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "major_version": { + "name": "major_version", + "documentation": "Major version of this archetype, extracted from `_release_version_`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "minor_version": { + "name": "minor_version", + "documentation": "Minor version of this archetype, extracted from `_release_version_`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "patch_version": { + "name": "patch_version", + "documentation": "Patch version of this archetype, extracted from `_release_version_`. Equivalent to patch version in patch version in `semver.org` sytem.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + } + }, + "invariants": { + "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)" + } + }, + "ARCHETYPE_CONSTRAINT": { + "name": "ARCHETYPE_CONSTRAINT", + "documentation": "Abstract parent of all constraint model types. Defines conformance and congruence function signatures. ", + "is_abstract": true, + "ancestors": [ + "ADL_CODE_DEFINITIONS" + ], + "properties": { + "parent": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "parent", + "documentation": "Parent node, except in the case of the top of a tree, i.e. root `C_COMPLEX_OBJECT` of an archetype definition.", + "type": "ARCHETYPE_CONSTRAINT" + }, + "soc_parent": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "soc_parent", + "type": "C_SECOND_ORDER" + } + }, + "functions": { + "is_prohibited": { + "name": "is_prohibited", + "documentation": "True if this node is prohibited. Implemented in subtypes.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_path": { + "name": "has_path", + "documentation": "True if the relative path `_a_path_` exists at this node.", + "parameters": { + "a_path": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_path", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "path": { + "name": "path", + "documentation": "Path of this node relative to root of archetype.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of specialised archetype nodes.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "RM conformance checker - a lambda (i.e. function object) that can compute conformance of type-names within the Reference Model on which the current archetype is based. The signature provides two arguments representing respectively, the `_rm_type_name_` of the current node and the `_rm_type_name_` of the node being redefined in a specialisation parent archetype.", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. \n\nTypically used to test if an inherited node locally contains any constraints.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_second_order_constrained": { + "name": "is_second_order_constrained", + "documentation": "True if there is a second order constraint such as a tuple constraint on this node.", + "post_conditions": { + "Post": "soc_parent \/= Void or else (parent \/= Void and then parent.is_second_order_constrained)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_root": { + "name": "is_root", + "documentation": "True if this node is the root of the tree.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_leaf": { + "name": "is_leaf", + "documentation": "True if this node is a terminal node in the tree structure, i.e. having no child nodes.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Post": "Result = soc_parent \/= Void or parent.soc_parent \/= Void" + } + }, + "C_OBJECT": { + "name": "C_OBJECT", + "documentation": "Abstract model of constraint on any kind of object node. ", + "is_abstract": true, + "ancestors": [ + "ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_type_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_type_name", + "documentation": "Reference model type that this node corresponds to. ", + "is_mandatory": true, + "type": "String" + }, + "occurrences": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "occurrences", + "documentation": "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.\nOnly 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.", + "type": "Multiplicity_interval" + }, + "node_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "node_id", + "documentation": "Semantic identifier of this node, used to distinguish sibling nodes. All nodes must have a `_node_id_`; for nodes under a container `C_ATTRIBUTE`. For at-coded archetypes `_node_id_` must be an at-code defined in the archetype terminology and for valid structures all node ids are at-codes. For id-coded archetypes `_node_id_` must be an id-code defined in the archetype terminology and for valid structures all node ids are id-codes.\n\nFor `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.\n\n", + "is_mandatory": true, + "type": "String" + }, + "alternative_ids": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "alternative_ids", + "documentation": "Additional identifiers of this node. openEHR archetypes can carry original ALD2 id-codes in this attribute and it can also carry human readable codes for future use. Alternative ids must be unique within the archetype.", + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "is_deprecated": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_deprecated", + "documentation": "True if this node and by implication all sub-nodes are deprecated for use.", + "type": "Boolean" + }, + "sibling_order": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "sibling_order", + "documentation": "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`.", + "type": "SIBLING_ORDER" + } + }, + "functions": { + "specialisation_depth": { + "name": "specialisation_depth", + "documentation": "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 \u2018.\u2019 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.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + }, + "effective_occurrences": { + "name": "effective_occurrences", + "documentation": "Compute effective occurrences, where no local occurrences constraint set. If the owning `C_ATTRIBUTE._cardinality_` is set, use its upper value, else use RM multiplicity of the owning attribute.\n\nIf local `occurrences` not set, always assume 0 as the lower bound.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Multiplicity_interval" + } + }, + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_OBJECT" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "Reference Model conformance checker agent (lambda).", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. \n\nTypically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "occurrences_conforms_to": { + "name": "occurrences_conforms_to", + "documentation": "True if this node `_occurrences_` conforms to `_other.occurrences_`; `other` is assumed to be in a flat archetype.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "documentation": "`C_OBJECT` from a flat parent archetype.", + "type": "C_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "node_id_conforms_to": { + "name": "node_id_conforms_to", + "documentation": "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.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_OBJECT" + } + }, + "post_conditions": { + "Post": "Result = codes_conformant (node_id, other.node_id)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_prohibited": { + "name": "is_prohibited", + "documentation": "True if this `C_OBJECT` node is prohibited, i.e. if its `_occurrences_` is `0..0`.", + "post_conditions": { + "Post": "Result = occurrences \/= Void and then occurrences.is_prohibited" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_ATTRIBUTE": { + "name": "C_ATTRIBUTE", + "documentation": "Abstract model of constraint on any kind of attribute in a class model.", + "ancestors": [ + "ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_attribute_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_attribute_name", + "documentation": "Reference model attribute within the enclosing type represented by a `C_OBJECT`.", + "is_mandatory": true, + "type": "String" + }, + "existence": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "existence", + "documentation": "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.", + "type": "Multiplicity_interval" + }, + "children": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "children", + "documentation": "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. ", + "type_def": { + "container_type": "List", + "type": "C_OBJECT" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "differential_path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "differential_path", + "documentation": "Path to the parent object of this attribute (i.e. doesn\u2019t 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.", + "type": "String" + }, + "cardinality": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "cardinality", + "documentation": "Cardinality constraint of attribute, if a container attribute.", + "type": "Cardinality" + }, + "is_multiple": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_multiple", + "documentation": "Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute.", + "is_mandatory": true, + "type": "Boolean" + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if there is no effective constraint on the children of the RM attribute to which this `C_ATTRIBUTE` refers.", + "post_conditions": { + "Post": "Result := children.is_empty and not is_prohibited" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_mandatory": { + "name": "is_mandatory", + "documentation": "True if this `C_ATTRIBUTE` has an existence constraint of 1..1, i.e. mandation.", + "post_conditions": { + "Post": "Result = existence \/= Void and then existence.is_mandatory" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "rm_attribute_path": { + "name": "rm_attribute_path", + "documentation": "Path of this attribute with respect to owning `C_OBJECT`, including differential path where applicable.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "is_single": { + "name": "is_single", + "documentation": "True if this node logically represents a single-valued attribute. Evaluated as not `_is_multiple_`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. \n\nTypically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + } + }, + "post_conditions": { + "Post": "Result = existence = Void and ((is_single and other.is_single) or (is_multiple and other.is_multiple and cardinality = Void))" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "ARCHETYPE_CONSTRAINT" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "post_conditions": { + "Post": "Result = existence_conforms_to (other) and ((is_single and other.is_single) or else (is_multiple and cardinality_conforms_to (other)))" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_prohibited": { + "name": "is_prohibited", + "documentation": "True if this `C_ATTRIBUTE` has an existence constraint of `0..0`, i.e. prohibition.", + "post_conditions": { + "Post": "Result = existence \/= Void and then existence.is_prohibited" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_DEFINED_OBJECT": { + "name": "C_DEFINED_OBJECT", + "documentation": "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. ", + "is_abstract": true, + "ancestors": [ + "C_OBJECT" + ], + "properties": { + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Any" + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_value": { + "name": "valid_value", + "documentation": "True if `_a_value_` is valid with respect to constraint expressed in concrete instance of this type.", + "is_abstract": true, + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "Any" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "prototype_value": { + "name": "prototype_value", + "documentation": "Generate a prototype value from this constraint object.", + "is_abstract": true, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Any" + } + }, + "has_default_value": { + "name": "has_default_value", + "documentation": "True if there is an assumed value.\n", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Inv_valid_default_value": "valid_value (default_value)" + } + }, + "C_COMPLEX_OBJECT_PROXY": { + "name": "C_COMPLEX_OBJECT_PROXY", + "documentation": "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. ", + "ancestors": [ + "C_OBJECT" + ], + "properties": { + "target_path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "target_path", + "documentation": "Reference to an object node using archetype path notation.", + "is_mandatory": true, + "type": "String" + } + }, + "functions": { + "use_target_occurrences": { + "name": "use_target_occurrences", + "documentation": "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.", + "post_conditions": { + "Post": "Result = (occurrences = Void)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "occurrences_conforms_to": { + "name": "occurrences_conforms_to", + "documentation": "True if this node occurrences conforms to `_other.occurrences_`; `_other_` is assumed to be in a flat archetype.\n\nIf `_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\n", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "documentation": "`C_OBJECT` from a flat parent archetype.", + "type": "C_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "ARCHETYPE_SLOT": { + "name": "ARCHETYPE_SLOT", + "documentation": "Constraint describing a 'slot' where another archetype can occur. ", + "ancestors": [ + "C_OBJECT" + ], + "properties": { + "includes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "includes", + "documentation": "List of constraints defining other archetypes that could be included at this point. Represented as an `ASSERTION` containing an expression of the form `EXPR_ARCHETYPE_REF matches EXPR_ARCHETYPE_ID_CONSTRAINT`.", + "type_def": { + "container_type": "List", + "type": "ASSERTION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "excludes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "excludes", + "documentation": "List of constraints defining other archetypes that cannot be included at this point. Represented as an `ASSERTION` containing an expression of the form `EXPR_ARCHETYPE_REF matches EXPR_ARCHETYPE_ID_CONSTRAINT`.", + "type_def": { + "container_type": "List", + "type": "ASSERTION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "is_closed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_closed", + "documentation": "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.", + "is_mandatory": true, + "type": "Boolean" + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if no constraints stated, and slot is not closed.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_PRIMITIVE_OBJECT": { + "name": "C_PRIMITIVE_OBJECT", + "documentation": "Parent of types representing constraints on primitive types.\n\nInstances 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.", + "is_abstract": true, + "ancestors": [ + "C_DEFINED_OBJECT" + ], + "properties": { + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Any" + }, + "is_enumerated_type_constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_enumerated_type_constraint", + "documentation": "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.", + "type": "Boolean" + }, + "constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint", + "documentation": "Constraint represented by this object; redefine in descendants.", + "is_mandatory": true, + "type": "Any" + } + }, + "functions": { + "has_assumed_value": { + "name": "has_assumed_value", + "documentation": "True if there is an assumed value.\n", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "constrained_typename": { + "name": "constrained_typename", + "documentation": "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.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_PRIMITIVE_OBJECT" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "Reference Model conformance checker lambda.", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if this node expresses a value constraint that conforms to that of `other`. Effected in descendants.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_PRIMITIVE_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. \n\nTypically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_PRIMITIVE_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if this node expresses the same value constraint as `other`. Effected in descendants.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_PRIMITIVE_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Inv_valid_assumed_value": "valid_value (assumed_value)" + } + }, + "SIBLING_ORDER": { + "name": "SIBLING_ORDER", + "documentation": "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.\n\nMisuse: This type cannot be used on a `C_OBJECT` other than one within a container attribute in a specialised archetype.", + "properties": { + "is_before": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_before", + "documentation": "True if the order relationship is \u2018before\u2019, if False, it is \u2018after\u2019.", + "is_mandatory": true, + "type": "Boolean" + }, + "sibling_node_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "sibling_node_id", + "documentation": "Node identifier of sibling before or after which this node should come.", + "is_mandatory": true, + "type": "String" + } + }, + "functions": { + "is_after": { + "name": "is_after", + "documentation": "True if the order relationship is `_after_`, computed as the negation of `_is_before_`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_ATTRIBUTE_TUPLE": { + "name": "C_ATTRIBUTE_TUPLE", + "documentation": "Object representing a constraint on an attribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like `{units, range}` constraints.", + "ancestors": [ + "C_SECOND_ORDER" + ], + "properties": { + "tuples": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "tuples", + "documentation": "Tuple definitions.", + "type_def": { + "container_type": "List", + "type": "C_PRIMITIVE_TUPLE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "members": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "members", + "documentation": "List of `C_ATTRIBUTEs` forming the definition of the tuple.", + "type_def": { + "container_type": "List", + "type": "C_ATTRIBUTE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_ATTRIBUTE_TUPLE" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "RM conformance checker agent.", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_SECOND_ORDER" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_PRIMITIVE_TUPLE": { + "name": "C_PRIMITIVE_TUPLE", + "documentation": "Class representing a single object tuple instance in a tuple constraint. Each such instance is a vector of object constraints, where each member (each `C_PRIMITIVE_OBJECT`) corresponds to one of the `C_ATTRIBUTEs` referred to by the owning `C_ATTRIBUTE_TUPLE`.", + "ancestors": [ + "C_SECOND_ORDER" + ], + "properties": { + "members": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "members", + "documentation": "Object constraint members of this tuple group.", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "C_PRIMITIVE_OBJECT" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + } + }, + "functions": { + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_PRIMITIVE_TUPLE" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "RM conformance checker agent.", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_SECOND_ORDER" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_SECOND_ORDER": { + "name": "C_SECOND_ORDER", + "documentation": "Abstract parent of classes defining second order constraints.", + "is_abstract": true, + "properties": { + "members": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "members", + "documentation": "Members of this second order constrainer. Normally redefined in descendants.", + "type_def": { + "container_type": "List", + "type": "ARCHETYPE_CONSTRAINT" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_SECOND_ORDER" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "RM conformance checker agent - a lambda (i.e. function object) that can compute conformance of type-names within the Reference Model on which the current archetype is based. The signature provides two arguments representing respectively, the `_rm_type_name_` of the current node and the `_rm_type_name_` of the node being redefined in a specialisation parent archetype.", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.", + "is_abstract": true, + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_SECOND_ORDER" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_ARCHETYPE_ROOT": { + "name": "C_ARCHETYPE_ROOT", + "documentation": "A specialisation of `C_COMPLEX_OBJECT` whose node_id attribute is an archetype identifier rather than the normal internal node code (i.e. at-code/id-code).\n\nUsed 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.\n\nFor 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.\n\nFor 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.\n\nIn all uses within source archetypes and templates, the `_children_` attribute is `Void`.\n\nIn 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.", + "ancestors": [ + "C_COMPLEX_OBJECT" + ], + "properties": { + "archetype_ref": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_ref", + "documentation": "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.", + "is_mandatory": true, + "type": "String" + } + } + }, + "C_COMPLEX_OBJECT": { + "name": "C_COMPLEX_OBJECT", + "documentation": "Constraint on complex objects, i.e. any object that consists of other object constraints.", + "ancestors": [ + "C_DEFINED_OBJECT" + ], + "properties": { + "attributes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "attributes", + "documentation": "List of constraints on attributes of the reference model type represented by this object.", + "type_def": { + "container_type": "List", + "type": "C_ATTRIBUTE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "attribute_tuples": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "attribute_tuples", + "documentation": "List of attribute tuple constraints under this object constraint, if any.", + "type_def": { + "container_type": "List", + "type": "C_ATTRIBUTE_TUPLE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.", + "post_conditions": { + "Post": "Result = attributes.is_empty and not is_prohibited" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_conforms_to": { + "name": "c_conforms_to", + "documentation": "True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. \nTypically used during validation of specialised archetype nodes.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_COMPLEX_OBJECT" + }, + "rmcc": { + "_type": "P_BMM_GENERIC_FUNCTION_PARAMETER", + "name": "rmcc", + "documentation": "Reference Model conformance checker agent (lambda).", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "FUNCTION", + "generic_parameters": [ + "Boolean", + { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "TUPLE2", + "generic_parameters": [ + "String", + "String" + ] + } + ] + } + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_congruent_to": { + "name": "c_congruent_to", + "documentation": "True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. \n\nTypically used to test if an inherited node locally contains any constraints.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_COMPLEX_OBJECT" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "ARCHETYPE_ID_CONSTRAINT": { + "name": "ARCHETYPE_ID_CONSTRAINT", + "documentation": "Constraint expression representing a regex constraint on an archetype identifier.", + "properties": { + "constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint", + "documentation": "Right hand side of the constraint expression, in the form of a `C_STRING`, i.e. string value constrainer.", + "is_mandatory": true, + "type": "C_STRING" + } + } + }, + "C_BOOLEAN": { + "name": "C_BOOLEAN", + "documentation": "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`.", + "ancestors": [ + "C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Boolean constraint - a list of Boolean values.", + "type_def": { + "container_type": "List", + "type": "Boolean" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Assumed Boolean value.", + "type": "Boolean" + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default Boolean value.", + "type": "Boolean" + } + }, + "functions": { + "prototype_value": { + "name": "prototype_value", + "documentation": "Prototype Boolean value.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.", + "post_conditions": { + "Post": "Result = constraint.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_BOOLEAN" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_BOOLEAN" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_STRING": { + "name": "C_STRING", + "documentation": "Constraint on instances of `String`. ", + "ancestors": [ + "C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "String constraint - a list of literal strings and \/ or regular expression strings delimited by the \u2018\/\u2019 character.\n\nTo represent no constraint, use an empty list, or alternatively, a regex 'any' pattern, i.e. `\/.*\/`.", + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default String value.", + "type": "String" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Assumed String value.", + "type": "String" + } + }, + "functions": { + "prototype_value": { + "name": "prototype_value", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + } + }, + "valid_value": { + "name": "valid_value", + "documentation": "True if a_value is valid with respect to constraint expressed in concrete instance of this type. ", + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "any_allowed": { + "name": "any_allowed", + "documentation": "True if `_constraint_` is empty or else contains one String for the regex 'any' pattern.", + "post_conditions": { + "Post": "Result = constraint.is_empty or else constraint.count = 1 and constraint.first.is_equal (Regex_any_string)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_STRING" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_STRING" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_INTEGER": { + "name": "C_INTEGER", + "documentation": "Constraint on instances of Integer.", + "ancestors": [ + "C_ORDERED" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on `Integer`, in the form of one or more `Interval`.\n\nTo represent no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Integer" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Integer" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Real" + } + } + }, + "C_REAL": { + "name": "C_REAL", + "documentation": "Constraint on instances of Real.", + "ancestors": [ + "C_ORDERED" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on `Real`, in the form of one or more `Interval`.\n\nTo represent no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Real" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Real" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Real" + } + } + }, + "C_ORDERED": { + "name": "C_ORDERED", + "documentation": "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.\n\nIn its simplest form, the constraint accessor returns just a single point `Interval` object, representing a single value.\n\nThe next simplest form is a single proper `Interval ` (i.e. normal two-sided or half-open interval). The most complex form is a list of any combination of point and proper intervals.", + "is_abstract": true, + "ancestors": [ + "C_PRIMITIVE_OBJECT" + ], + "generic_parameter_defs": { + "T": { + "name": "T", + "conforms_to_type": "Ordered" + } + }, + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Constraint in the form of a List of Intervals of the parameter type T. Concrete types generated in descendants via template binding.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "T" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY_OPEN", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "T" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY_OPEN", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "T" + } + }, + "functions": { + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.", + "post_conditions": { + "Post": "Result = constraint.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if `_other.any_allowed_` or else for every constraint in the `_constraint_` list there is a constraint in `_other.constraint_` that contains it.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_ORDERED" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_ORDERED" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_TERMINOLOGY_CODE": { + "name": "C_TERMINOLOGY_CODE", + "documentation": "Constrainer type for instances of `Terminology_code`. The constraint attribute can contain:\n\n* a single at-code\n* a single ac-code, representing a value-set that is defined in the archetype terminology\n\nIf there is an assumed value for the ac-code case above, the `_assumed_value_` attribute contains a single at-code, which must come from the list of at-codes defined as the internal value set for the ac-code.\n\nThe `_constraint_status_` attribute and `_constraint_required_()` function together define whether the `_constraint_` is considered formal ('required') or not. In the non-required cases, a data-item matched to this constraint may be any coded term.", + "ancestors": [ + "C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint", + "documentation": "Type of individual constraint - a single string that can either be a local at-code, or a local ac-code signifying a locally defined value set. If an ac-code, assumed_value may contain an at-code from the value set of the ac-code.\n\nUse an empty string for no constraint.", + "is_mandatory": true, + "type": "String" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Assumed Terminology code value.", + "type": "Terminology_code" + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "type": "Terminology_code" + }, + "constraint_status": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint_status", + "documentation": "Constraint status of this terminology constraint. If Void, the meaning is as follows:\n\n* in a top-level archetype, equivalent to `required`;\n* in a specialised (source) archetype, the meaning is to inherit the value from the corresponding node in the parent.\n\nIn the case of a specialised archetype generated by flattening, the value of this field will be:\n\n* Void if it was Void in the parent;\n* otherwise, it will carry the same value as in the parent.", + "type": "CONSTRAINT_STATUS" + } + }, + "functions": { + "constraint_required": { + "name": "constraint_required", + "documentation": "True if `_constraint_status_` is defined and equals `required` OR if Void. I.e. in archetypes where `C_TERMINOLOGY_CODE` instances have no `_constraint_status_`, the `required` status is assumed, which applies to all legacy archetypes.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "effective_constraint_status": { + "name": "effective_constraint_status", + "documentation": "Return the effective integer value of the `_constraint_status_` field if it exists. If it is null, return 0, i.e. `required`.\n\nNOTE: the above logic applies to any `C_TERMINOLOGY_NODE` instance in a specialised archetype that redefines another such instance in the flat parent. I.e. no stated `_constraint_status_` means `required`.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + }, + "value_set_expanded": { + "name": "value_set_expanded", + "documentation": "Effective set of at-code values corresponding to an ac-code for a locally defined value set. Not defined for ac-codes that have no local value set.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + }, + "is_nullable": true + }, + "value_set_substituted": { + "name": "value_set_substituted", + "documentation": "For locally defined value sets within individual code bindings: return the term URI(s) substituted from bindings for local at-codes in `_value_set_expanded_`.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "Uri" + }, + "is_nullable": true + }, + "value_set_resolved": { + "name": "value_set_resolved", + "documentation": "For locally defined value sets within individual code bindings: final set of external codes to which value set is resolved.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "Terminology_code" + }, + "is_nullable": true + }, + "valid_value": { + "name": "valid_value", + "documentation": "True if a `_value_` is valid with respect to constraint expressed in concrete instance of this type. ", + "parameters": { + "a_value": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_value", + "type": "Terminology_code" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "prototype_value": { + "name": "prototype_value", + "documentation": "A generated prototype value from this constraint object.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Terminology_code" + } + }, + "any_allowed": { + "name": "any_allowed", + "documentation": "True if `_constraint_` is empty.", + "post_conditions": { + "Post": "Result := constraint.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`, and `_effective_constraint_status()_` is <= `_other.effective_constraint_status()_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_TERMINOLOGY_CODE" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if `_constraint_` and `_other.constraint_` are both value-set ids, and expand to identical value sets, or else are identical value codes; and `_effective_constraint_status()_` = `_other.effective_constraint_status()_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_TERMINOLOGY_CODE" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_TEMPORAL": { + "name": "C_TEMPORAL", + "documentation": "Purpose Abstract parent of `C_ORDERED` types whose base type is an ISO date\/time type.", + "is_abstract": true, + "ancestors": [ + "C_ORDERED" + ], + "generic_parameter_defs": { + "T": { + "name": "T", + "conforms_to_type": "Temporal" + } + }, + "properties": { + "pattern_constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "pattern_constraint", + "documentation": "Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details.", + "type": "String" + } + }, + "functions": { + "valid_pattern_constraint": { + "name": "valid_pattern_constraint", + "documentation": "True if `_a_pattern_` is a valid constraint. Define in concrete descendants.", + "is_abstract": true, + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint_replacement": { + "name": "valid_pattern_constraint_replacement", + "documentation": "Return True if `_a_pattern_` can be replaced by `_an_other_pattern_` in a specialised constraint. Define in concrete subtypes.", + "is_abstract": true, + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + }, + "an_other_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_other_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "any_allowed": { + "name": "any_allowed", + "documentation": "True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.", + "post_conditions": { + "Post": "Result = precursor and pattern_constraint.is_empty" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_conforms_to": { + "name": "c_value_conforms_to", + "documentation": "True if `precursor()` or else `_other.pattern_constraint_` is empty, or else `_pattern_constraint_` is a valid (narrower) replacement for `_other.pattern_constraint_`.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_ORDERED" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "c_value_congruent_to": { + "name": "c_value_congruent_to", + "documentation": "True if `precursor (other)` and `_pattern_constraint_ ~ _other.pattern_constraint_`, i.e. either both `Void` or else both non-`Void` and identical.", + "parameters": { + "other": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other", + "type": "C_ORDERED" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_TIME": { + "name": "C_TIME", + "documentation": "Constraint on instances representing times in the form either of a set of validity values, or else time ranges based on the `C_ORDERED` list constraint. \n\nThere 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).", + "ancestors": [ + "C_TEMPORAL" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on the assumed primitive `Iso8601_time` type, in the form of one or more `Interval`.\n\nFor a pattern constraint or no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_time" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Iso8601_time" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Iso8601_time" + } + }, + "functions": { + "minute_validity": { + "name": "minute_validity", + "documentation": "Validity of minute in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "second_validity": { + "name": "second_validity", + "documentation": "Validity of second in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "millisecond_validity": { + "name": "millisecond_validity", + "documentation": "Validity of millisecond in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "timezone_validity": { + "name": "timezone_validity", + "documentation": "Validity of timezone in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "valid_pattern_constraint": { + "name": "valid_pattern_constraint", + "documentation": "Return `valid_iso8601_time_constraint_pattern (a_pattern)` ", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint_replacement": { + "name": "valid_pattern_constraint_replacement", + "documentation": "Return `valid_time_constraint_replacements.has(an_other_pattern.as_upper) and then \nvalid_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + }, + "an_other_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_other_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_time_constraint_pattern (pattern)" + } + }, + "C_DATE": { + "name": "C_DATE", + "documentation": "Constraint on instances representing dates in the form either of a set of validity values, or else date ranges based on the `C_ORDERED` list constraint. \n\nThere 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).", + "ancestors": [ + "C_TEMPORAL" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on the assumed primitive `Iso8601_date` type, in the form of one or more `Interval`.\n\nFor a pattern constraint or no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_date" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Iso8601_date" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Iso8601_date" + } + }, + "functions": { + "month_validity": { + "name": "month_validity", + "documentation": "Validity of month in constrained date.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "day_validity": { + "name": "day_validity", + "documentation": "Validity of day in constrained date.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "valid_pattern_constraint": { + "name": "valid_pattern_constraint", + "documentation": "Return `valid_iso8601_date_constraint_pattern (a_pattern)` ", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint_replacement": { + "name": "valid_pattern_constraint_replacement", + "documentation": "Return `valid_date_constraint_replacements.has(an_other_pattern.as_upper) and then \nvalid_date_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + }, + "an_other_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_other_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_date_constraint_pattern(pattern)" + } + }, + "C_DATE_TIME": { + "name": "C_DATE_TIME", + "documentation": "Constraint on instances representing date\/times, i.e. instants in time.\n\nThere 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).", + "ancestors": [ + "C_TEMPORAL" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on the assumed primitive `Iso8601_date_time` type, in the form of one or more `Interval`.\n\nFor a pattern constraint or no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_date_time" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Iso8601_date_time" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Iso8601_date_time" + } + }, + "functions": { + "valid_pattern_constraint": { + "name": "valid_pattern_constraint", + "documentation": "Return `valid_iso8601_date_time_constraint_pattern (a_pattern)` ", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint_replacement": { + "name": "valid_pattern_constraint_replacement", + "documentation": "Return `valid_date_time_constraint_replacements.has(an_other_pattern.as_upper) and then \nvalid_date_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + }, + "an_other_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_other_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "month_validity": { + "name": "month_validity", + "documentation": "Validity of month in constrained date.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "day_validity": { + "name": "day_validity", + "documentation": "Validity of day in constrained date.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "minute_validity": { + "name": "minute_validity", + "documentation": "Validity of minute in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "second_validity": { + "name": "second_validity", + "documentation": "Validity of second in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "millisecond_validity": { + "name": "millisecond_validity", + "documentation": "Validity of millisecond in constrained time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + }, + "timezone_validity": { + "name": "timezone_validity", + "documentation": "Validity of timezone in constrained date\/time.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "VALIDITY_KIND" + } + } + }, + "invariants": { + "Pattern_validity": "pattern \/= Void implies valid_iso8601_date_time_constraint_pattern(pattern)" + } + }, + "C_DURATION": { + "name": "C_DURATION", + "documentation": "Constraint on instances representing duration, which is assumed to have the same parts as the ISO 8601 duration string. Thus, constraints are of the form `\"PWD\"` (weeks and\/or days), `\"PDTHMS\"` (days, hours, minutes, seconds) and so on.\n\nBoth range and the constraint pattern can be set at the same time, corresponding to the ADL constraint `\"PWD\/|P0W..P50W|\"`.\n\nAs for all of openEHR, two ISO 8601 exceptions are allowed: \n\n* the \u2018W\u2019 (week) designator can be mixed in - the allowed patterns are: `P[Y|y][M|m][D|d][T[H|h][M|m][S|s]]` and `P[W|w]`;\n* the values used in an interval constraint may be negated, i.e. a leading minus (`'-'`) sign may be used.\n\n", + "ancestors": [ + "C_TEMPORAL" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "Formal constraint on the assumed primitive `Iso8601_duration` type, in the form of one or more `Interval`.\n\nFor a pattern constraint or no constraint, use an empty list.", + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "Iso8601_duration" + ] + } + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "documentation": "Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.", + "type": "Iso8601_duration" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Iso8601_duration" + } + }, + "functions": { + "years_allowed": { + "name": "years_allowed", + "documentation": "True if years are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "months_allowed": { + "name": "months_allowed", + "documentation": "True if months are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "weeks_allowed": { + "name": "weeks_allowed", + "documentation": "True if weeks are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "days_allowed": { + "name": "days_allowed", + "documentation": "True if days are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "hours_allowed": { + "name": "hours_allowed", + "documentation": "True if hours are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "minutes_allowed": { + "name": "minutes_allowed", + "documentation": "True if minutes are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "seconds_allowed": { + "name": "seconds_allowed", + "documentation": "True if seconds are allowed in the constrained Duration.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint": { + "name": "valid_pattern_constraint", + "documentation": "Return `valid_iso8601_duration_constraint_pattern (a_pattern)` ", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_pattern_constraint_replacement": { + "name": "valid_pattern_constraint_replacement", + "documentation": "Return `valid_duration_constraint_replacement (a_pattern, an_other_pattern)`.", + "parameters": { + "a_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_pattern", + "type": "String" + }, + "an_other_pattern": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "an_other_pattern", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "C_TEMPORAL_DEFINITIONS": { + "name": "C_TEMPORAL_DEFINITIONS", + "documentation": "Definitions related to `C_TEMPORAL` constraints.", + "properties": { + "valid_date_constraint_patterns": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "valid_date_constraint_patterns", + "documentation": "List of allowed date constraints. Contains the values:\n\n```\n\"YYYY-MM-DD\" -- full date required\n\"YYYY-MM-??\" -- day optional\n\"YYYY-MM-XX\" -- day prohibited\n\"YYYY-??-??\" -- any partial or full date\n\"YYYY-??-XX\" -- day prohibited\n\"YYYY-XX-XX\" -- only prohibited\n```", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "valid_date_constraint_replacements": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "valid_date_constraint_replacements", + "documentation": "List of allowed date constraint replacements e.g. in specialised archetype. Contains the values:\n\n----\n\"YYYY-MM-DD\": [],\n\n\"YYYY-MM-??\": [\"YYYY-MM-DD\", \n \"YYYY-MM-XX\"],\n\n\"YYYY-MM-XX\": [],\n\n\"YYYY-??-??\": [\"YYYY-MM-??\",\n \"YYYY-MM-DD\",\n \"YYYY-MM-XX\",\n \"YYYY-??-XX\",\n \"YYYY-XX-XX\"],\n\n\"YYYY-??-XX\": [\"YYYY-MM-XX\", \n \"YYYY-XX-XX\"],\n\n\"YYYY-XX-XX\": []\n----\n\nIn the above, an empty list value indicates no replacements possible.", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "List", + "generic_parameters": [ + "String" + ] + } + } + } + }, + "valid_time_constraint_patterns": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "valid_time_constraint_patterns", + "documentation": "List of allowed time constraints. Contains the values:\n\n```\n\"HH:MM:SS\" -- full time required\n\"HH:MM:??\" -- seconds optional\n\"HH:MM:XX\" -- minutes required, seconds prohibited\n\"HH:??:??\" -- minutes and seconds optional\n\"HH:??:XX\" -- minutes optional, seconds prohibited\n```", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "valid_time_constraint_replacements": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "valid_time_constraint_replacements", + "documentation": "List of allowed time constraint replacements e.g. in specialised archetype. Contains the values:\n\n----\n\"HH:MM:SS\": [],\n\n\"HH:MM:??\": [\"HH:MM:SS\",\n \"HH:MM:XX\"],\n\n\"HH:MM:XX\": [],\n\n\"HH-??-??\": [\"HH:MM:??\",\n \"HH:MM:SS\",\n \"HH:MM:XX\",\n \"HH:??:XX\"],\n\n\"HH-??-XX\": [\"HH:MM:XX\"]\n----\n\nIn the above, an empty list value indicates no replacements possible.", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "List", + "generic_parameters": [ + "String" + ] + } + } + } + }, + "valid_date_time_constraint_patterns": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "valid_date_time_constraint_patterns", + "documentation": "List of allowed date\/time constraints. Contains the values:\n\n```\n\"YYYY-MM-DDTHH:MM:SS\" -- full date\/time required\n\"YYYY-MM-DDTHH:MM:??\" -- seconds optional\n\"YYYY-MM-DDTHH:MM:XX\" -- seconds prohibited\n\"YYYY-MM-DDTHH:??:??\" -- minutes and seconds optional\n\"YYYY-MM-DDTHH:??:XX\" -- minutes optional, seconds prohibited\n\"YYYY-??-??T??:??:??\" -- any date\/time ok\n```", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "valid_date_time_constraint_replacements": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "valid_date_time_constraint_replacements", + "documentation": "List of allowed date\/time constraint replacements e.g. in specialised archetype. Contains the values:\n\n----\n\"YYYY-MM-DDTHH:MM:SS\": [],\n\n\"YYYY-MM-DDTHH:MM:??\": [\"YYYY-MM-DDTHH:MM:SS\",\n \"YYYY-MM-DDTHH:MM:XX\"],\n\n\"YYYY-MM-DDTHH:MM:XX\": [],\n\n\"YYYY-MM-DDTHH:??:??\": [\"YYYY-MM-DDTHH:??:XX\",\n \"YYYY-MM-DDTHH:MM:SS\",\n \"YYYY-MM-DDTHH:MM:??\",\n \"YYYY-MM-DDTHH:MM:XX\"],\n\n\"YYYY-MM-DDTHH:??:XX\": [\"YYYY-MM-DDTHH:MM:XX\"],\n\n\"YYYY-??-??T??:??:??\": [\"YYYY-MM-DDTHH:MM:SS\",\n \"YYYY-MM-DDTHH:MM:??\",\n \"YYYY-MM-DDTHH:MM:XX\",\n \"YYYY-MM-DDTHH:??:??\",\n \"YYYY-MM-DDTHH:??:XX\"]\n----", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "List", + "generic_parameters": [ + "String" + ] + } + } + } + } + }, + "functions": { + "valid_duration_constraint_replacement": { + "name": "valid_duration_constraint_replacement", + "documentation": "True if ISO8601 duration string `_other_dur_` contains every character element in `_a_dur_`. For example: 'PYD' (period with year and days only) conforms to 'PYMD', but doesn't conform to 'PY'.", + "parameters": { + "a_dur": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_dur", + "type": "String" + }, + "other_dur": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "other_dur", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_iso8601_date_constraint_pattern": { + "name": "valid_iso8601_date_constraint_pattern", + "documentation": "True if string literal like `\"yyyy-MM-dd\"` containing `\"XX\"` or `\"??\"` in `MM` or `dd` slots in pattern constraint is in `_valid_date_constraint_patterns_`.", + "parameters": { + "s": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "s", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_iso8601_time_constraint_pattern": { + "name": "valid_iso8601_time_constraint_pattern", + "documentation": "True if string literal like `\"hh:mm:ss[.ssss]\"` containing `\"XX\"` or `\"??\"` in `mm` or `ss` slots in pattern constraint is in `_valid_time_constraint_patterns_`.", + "parameters": { + "s": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "s", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_iso8601_date_time_constraint_pattern": { + "name": "valid_iso8601_date_time_constraint_pattern", + "documentation": "True if string literal in form `\"yyyy-MM-dd hh:mm:ss[.ssss]\"` containing `\"XX\"` or `\"??\"` in variable slots in pattern constraint is in `_valid_date_time_constraint_patterns_`.", + "parameters": { + "s": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "s", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "valid_iso8601_duration_constraint_pattern": { + "name": "valid_iso8601_duration_constraint_pattern", + "documentation": "True if string in form `P[Y|y][M|m][W|w][D|d][T[H|h][M|m][S|s]]` (note: allowing 'W' to be mixed in is an openEHR deviation of ISO 8601).", + "parameters": { + "s": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "s", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "CONSTRAINT_STATUS": { + "_type": "P_BMM_ENUMERATION_INTEGER", + "name": "CONSTRAINT_STATUS", + "documentation": "Status of `_constraint_`, with values allowing for 'soft' constraints, which are effectively different kinds of suggestions.", + "ancestors": [ + "Integer" + ], + "item_names": [ + "required", + "extensible", + "preferred", + "example" + ], + "item_values": [ + 0, + 1, + 2, + 3 + ], + "item_documentations": [ + "Data item is required to formally satisfy `_constraint_`.\n\nEnumeration value = 0.", + "Data item value should satisfy `_constraint_`, i.e. a term in `_constraint_` is to be used if it covers the data item meaning (including more generally); if not, another code may be used, including from another terminology.\n\nEnumeration value = 1.", + "Data item value is by preference one of the codes defined by `_constraint_`, but for local reasons may be another code, including from another terminology.\n\nEnumeration value = 2.", + "The `_constraint_` code or value-set is considered purely as an example, and the data item may have any value." + ] + }, + "ARCHETYPE_TERM": { + "name": "ARCHETYPE_TERM", + "documentation": "Representation of any coded entity (term or constraint) in the archetype ontology.", + "properties": { + "code": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "code", + "documentation": "Code of this term. ", + "is_mandatory": true, + "type": "String" + }, + "text": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "text", + "documentation": "Short term text, typically for display.", + "is_mandatory": true, + "type": "String" + }, + "description": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "description", + "documentation": "Full description text.", + "is_mandatory": true, + "type": "String" + }, + "other_items": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "other_items", + "documentation": "Hash of keys and corresponding values for other items in a term, e.g. provenance.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + } + }, + "TERMINOLOGY_RELATION": { + "name": "TERMINOLOGY_RELATION", + "documentation": "Class whose instances represent any kind of 1:N relationship between a source term and 1-N target terms.", + "is_abstract": true, + "properties": { + "id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "id", + "documentation": "Code of source term of this relation.", + "is_mandatory": true, + "type": "String" + }, + "members": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "members", + "documentation": "List of target terms in this relation.", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + } + } + }, + "VALUE_SET": { + "name": "VALUE_SET", + "documentation": "Representation of a flat value set within the archetype terminology.", + "ancestors": [ + "TERMINOLOGY_RELATION" + ] + }, + "ARCHETYPE_TERMINOLOGY": { + "name": "ARCHETYPE_TERMINOLOGY", + "documentation": "Local terminology of an archetype. This class defines the semantics of the terminology of an archetype.", + "properties": { + "is_differential": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_differential", + "documentation": "True if this terminology only contains terms relating to a differential specialisation of the owning artefact, rather than a complete set.", + "is_mandatory": true, + "type": "Boolean" + }, + "original_language": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "original_language", + "documentation": "Original language of the terminology, as set at artefact creation or parsing time; must be a code in the ISO 639-1 2 character language code-set.\n", + "is_mandatory": true, + "type": "String" + }, + "concept_code": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "concept_code", + "documentation": "Term code defining the meaning of the artefact as a whole, and always used as the at-code (at-coded archetypes) or id-code (id-coded archetypes) on the root node of the artefact. Must be defined in the `_term_definitions_` property.", + "is_mandatory": true, + "type": "String" + }, + "term_definitions": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "term_definitions", + "documentation": "Directory of term definitions as a two-level table. The outer hash keys are language codes, e.g. `\"en\"`, `\"de\"`, while the inner hash keys are term codes, e.g. `\"at0017\"`, `\"at0004\"` (at-coded archetypes) or `\"id17\"`, `\"at4\"` (id-coded archetypes).", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERM" + ] + } + } + } + }, + "term_bindings": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "term_bindings", + "documentation": "Directory of bindings to external terminology codes and value sets, as a two-level table. The outer hash keys are terminology ids, e.g. `\"SNOMED_CT\"`, and the inner hash keys are constraint codes, e.g. `\"at0004\"`, `\"at4\"`, \"ac13\"` or paths. The indexed `Uri` objects represent references to externally defined resources, either terms, ontology concepts, or terminology subsets \/ ref-sets.", + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "Uri" + ] + } + } + } + }, + "owner_archetype": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "owner_archetype", + "documentation": "Archetype that owns this terminology.", + "is_mandatory": true, + "type": "ARCHETYPE" + }, + "value_sets": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "value_sets", + "documentation": "Archetype-local value sets, each keyed by value-set id, i.e. an ac-code.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "VALUE_SET" + ] + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "terminology_extracts": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "terminology_extracts", + "documentation": "Directory of extracts of external terminologies, as a two-level table. The outer hash keys are terminology ids, e.g. `\"SNOMED_CT\"`, while the inner hash keys are term codes or code-phrases from the relevant terminology, e.g. `\"10094842\"`.", + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERM" + ] + } + } + } + } + }, + "functions": { + "specialisation_depth": { + "name": "specialisation_depth", + "documentation": "Specialisation depth of this artefact. Unspecialised artefacts have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth.", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + }, + "node_codes": { + "name": "node_codes", + "documentation": "For at-coded archetypes: list of all at codes in the terminology., i.e. the 'at' codes in an ADL archetype, which are the `_node_id_` values on `C_OBJECT` descendants. For id-coded archetypes: list of all id codes in the terminology., i.e. the 'id' codes in an ADL archetype, which are the `_node_id_` values on `C_OBJECT` descendants.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "value_codes": { + "name": "value_codes", + "documentation": "List of all value term codes in the terminology, i.e. the 'at' codes in an ADL archetype, which are used as possible values on terminological constrainer nodes.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + }, + "is_nullable": true + }, + "value_set_codes": { + "name": "value_set_codes", + "documentation": "List of all value set codes in the terminology defining value sets. These correspond to the 'ac' codes in an ADL archetype.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + }, + "is_nullable": true + }, + "has_language": { + "name": "has_language", + "documentation": "True if language `_a_lang_` is present in archetype terminology. ", + "parameters": { + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_terminology": { + "name": "has_terminology", + "documentation": "True if there are bindings to terminology `_a_terminology_id_` present.", + "parameters": { + "a_terminology_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology_id", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "has_term_code": { + "name": "has_term_code", + "documentation": "True if code `_a_code_` defined in this terminology.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "term_definition": { + "name": "term_definition", + "documentation": "Term definition for a code, in a specified language. ", + "parameters": { + "a_lang": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_lang", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_term-definition (a_lang, a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "ARCHETYPE_TERM" + } + }, + "term_binding": { + "name": "term_binding", + "documentation": "Binding of constraint corresponding to `_a_code_` in target external terminology `_a_terminology_id_`, as a string, which is usually a formal query expression.", + "parameters": { + "a_terminology": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_term_binding (a_terminology_id, a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Uri" + } + }, + "terminologies_available": { + "name": "terminologies_available", + "documentation": "List of terminologies to which term or constraint bindings exist in this terminology, computed from bindings.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + }, + "terminology_extract_term": { + "name": "terminology_extract_term", + "documentation": "Return an `ARCHETYPE_TERM` from specified terminology extract, for specified term code.", + "parameters": { + "a_terminology_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology_id", + "type": "String" + }, + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "pre_conditions": { + "Pre": "has_terminology_extract (a_terminology_id) and has_terminology_extract_code (a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "ARCHETYPE_TERM" + } + }, + "has_terminology_extract": { + "name": "has_terminology_extract", + "documentation": "True if there is a provided terminology extract present.", + "parameters": { + "a_terminology_id": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_terminology_id", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "languages_available": { + "name": "languages_available", + "documentation": "List of languages in which terms in this terminology are available.", + "result": { + "_type": "P_BMM_CONTAINER_TYPE", + "container_type": "List", + "type": "String" + } + } + }, + "invariants": { + "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.terminology = Current" + } + }, + "ADL_CODE_DEFINITIONS": { + "name": "ADL_CODE_DEFINITIONS", + "documentation": "Definitions relating to the internal code system of archetypes.\n\nNOTE: ADL2 was initially released with code system using id-codes (for nodes), at-codes (for values only) and ac-codes (for value sets). As this proved to hinder its widespread use in the openEHR community (due to its impact on existing openEHR RM data), a code system matching the one used in ADL1.4 was introduced as the openEHR primary code system.\n\nopenEHR systems must support at least the at-coded ADL2 archetypes.", + "constants": { + "At_code_leader": { + "name": "At_code_leader", + "documentation": "String leader of ‘identifier’ codes, i.e. codes used to identify at-coded archetype nodes.", + "type": "String", + "value": "\"at\"" + }, + "Id_code_leader": { + "name": "Id_code_leader", + "documentation": "String leader of ‘identifier’ codes, i.e. codes used to identify id-coded archetype nodes.", + "type": "String", + "value": "\"id\"" + }, + "Value_code_leader": { + "name": "Value_code_leader", + "documentation": "String leader of ‘value’ codes, i.e. codes used to identify codes values, including value set members.", + "type": "String", + "value": "\"at\"" + }, + "Value_set_code_leader": { + "name": "Value_set_code_leader", + "documentation": "String leader of ‘value set’ codes, i.e. codes used to identify value sets.", + "type": "String", + "value": "\"ac\"" + }, + "Specialisation_separator": { + "name": "Specialisation_separator", + "documentation": "Character used to separate numeric parts of codes belonging to different specialisation levels.", + "type": "Character", + "value": "'.'" + }, + "Code_regex_pattern": { + "name": "Code_regex_pattern", + "documentation": "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.", + "type": "String", + "value": "\"(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*))*\"" + }, + "Root_code_regex_pattern": { + "name": "Root_code_regex_pattern", + "documentation": "Regex pattern of the root code of any archetype. Corresponds to at-codes of the form `at0000`, `at0000.1`, `at0000.1.1` etc, and id-codes of the form `id1`, `id1.1`, `id1.1.1` etc. For at-coded ADL2 numbering starts with zero (i.e. `at0000`) while the id-coded ADL2 numbering starts with one (i.e. `id1`).", + "type": "String", + "value": "\"^(id1|at0000)(\\.1)*$\"" + }, + "Primitive_node_id": { + "name": "Primitive_node_id", + "documentation": "Code id used for `C_PRIMITIVE_OBJECT` nodes on creation.\n\nNOTE: For id-coded archetypes this is `\"id9999\"`.", + "type": "String", + "value": "\"at9999\"" + } + }, + "functions": { + "codes_conformant": { + "name": "codes_conformant", + "documentation": "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_`?", + "parameters": { + "a_child_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_child_code", + "type": "String" + }, + "a_parent_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_parent_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_adl_code": { + "name": "is_adl_code", + "documentation": "True if `_a_code_` is any kind of ADL archetype local code.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "post_conditions": { + "Post": "Result = is_at_code (a_code) or else is_id_code (a_code) or else is_value_code (a_code) or else is_value_set_code (a_code)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_at_code": { + "name": "is_at_code", + "documentation": "True if `_a_code_` is an ‘at’ code.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "post_conditions": { + "Post": "Result = a_code.starts_with (At_code_leader)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_id_code": { + "name": "is_id_code", + "documentation": "True if `_a_code_` is an 'id' code.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "post_conditions": { + "Post": "Result = a_code.starts_with (Id_code_leader)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_value_code": { + "name": "is_value_code", + "documentation": "True if `_a_code_` is an 'at' code, i.e. a code representing a single terminology item.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "post_conditions": { + "Post": "Result = a_code.starts_with (Value_code_leader)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_value_set_code": { + "name": "is_value_set_code", + "documentation": "True if `_a_code_` is an 'ac' code, i.e. a code referring to a terminology value set.", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "post_conditions": { + "Post": "Result = a_code.starts_with (Value_set_code_leader)" + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "is_redefined_code": { + "name": "is_redefined_code", + "documentation": "A code has been specialised if there is a non-zero code index anywhere above the last index e.g. \n\n* `at0.0.1` -> False\n* `at1.0.1` -> True", + "parameters": { + "a_code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_code", + "type": "String" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + }, + "code_exists_at_level": { + "name": "code_exists_at_level", + "documentation": "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.", + "parameters": { + "a-code": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a-code", + "type": "String" + }, + "a_level": { + "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER", + "name": "a_level", + "type": "Integer" + } + }, + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Boolean" + } + } + } + }, + "RM_ATTRIBUTE_VISIBILITY": { + "name": "RM_ATTRIBUTE_VISIBILITY", + "documentation": "Definition of visibility of an RM attribute within a larger archetype structure.", + "properties": { + "visibility": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "visibility", + "documentation": "Visibility setting of a non-archetyped RM attribute (RM attributes that are constrained or within the archetyped structure are visible by default).", + "type": "VISIBILITY_TYPE" + }, + "alias": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "alias", + "documentation": "Optional alias for the attribute referenced by the path.", + "type": "Terminology_code" + } + }, + "invariants": { + "Inv_alias_validity": "alias \/= Void implies visibility \/= Void" + } + }, + "RM_OVERLAY": { + "name": "RM_OVERLAY", + "documentation": "Container object for archetype statements relating to RM attributes, which may be directly on objects constrained within the archetype, or at deeper non-constrained RM paths from an object or the root.", + "properties": { + "rm_visibility": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "rm_visibility", + "documentation": "Optional structure in which visibility and aliasing of reference model elements can be specified. Key is path to an RM attribute, which is typically formed from a path to an archetyped node concatenated with a further pure RM attribute path; may also refer to a non-archetyped attribute.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "RM_ATTRIBUTE_VISIBILITY" + ] + } + } + } + }, + "VISIBILITY_TYPE": { + "_type": "P_BMM_ENUMERATION_STRING", + "name": "VISIBILITY_TYPE", + "documentation": "Enumeration of visibility settings for model elements.", + "ancestors": [ + "String" + ], + "item_names": [ + "hide", + "show" + ], + "item_documentations": [ + "Indicates to a tool to hide the model element to which this marker is attached.", + "Indicates to a tool to show the model element to which this marker is attached." + ] + }, + "P_ARCHETYPE_CONSTRAINT": { + "name": "P_ARCHETYPE_CONSTRAINT", + "documentation": "Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model. ", + "is_abstract": true + }, + "P_C_OBJECT": { + "name": "P_C_OBJECT", + "documentation": "Abstract model of constraint on any kind of object node. ", + "is_abstract": true, + "ancestors": [ + "P_ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_type_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_type_name", + "documentation": "Reference model type that this node corresponds to. ", + "is_mandatory": true, + "type": "String" + }, + "occurrences": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "occurrences", + "documentation": "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.", + "type": "String" + }, + "node_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "node_id", + "documentation": "Semantic id of this node, used to differentiate sibling nodes of the same type. Each node_id must be defined in the archetype ontology as a term code. \n", + "is_mandatory": true, + "type": "String" + }, + "is_deprecated": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_deprecated", + "type": "Boolean" + } + }, + "functions": { + "specialisation_depth": { + "name": "specialisation_depth", + "result": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "Integer" + } + } + } + }, + "P_C_ATTRIBUTE": { + "name": "P_C_ATTRIBUTE", + "documentation": "Abstract model of constraint on any kind of attribute node.", + "ancestors": [ + "P_ARCHETYPE_CONSTRAINT" + ], + "properties": { + "rm_attribute_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_attribute_name", + "documentation": "Reference model attribute within the enclosing type represented by a C_OBJECT.", + "is_mandatory": true, + "type": "String" + }, + "existence": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "existence", + "documentation": "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).", + "type": "String" + }, + "children": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "children", + "documentation": "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. ", + "type_def": { + "container_type": "List", + "type": "P_C_OBJECT" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "differential_path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "differential_path", + "documentation": "Within a differential specialised archetype, may be set to represent a deep path within the structure to which this constraint and its child constraints apply.", + "type": "String" + }, + "cardinality": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "cardinality", + "documentation": "Cardinality constraint of attribute, if a container attribute.", + "type": "String" + }, + "is_multiple": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_multiple", + "documentation": "Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute.", + "is_mandatory": true, + "type": "Boolean" + } + } + }, + "P_C_DEFINED_OBJECT": { + "name": "P_C_DEFINED_OBJECT", + "documentation": "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. ", + "is_abstract": true, + "ancestors": [ + "P_C_OBJECT" + ], + "properties": { + "is_frozen": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_frozen", + "type": "Boolean" + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "is_mandatory": true, + "type": "Any" + } + } + }, + "P_C_COMPLEX_OBJECT_PROXY": { + "name": "P_C_COMPLEX_OBJECT_PROXY", + "documentation": "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 COJMPLEX_OBJECT_PROXY should always be used; when setting this from a seri- alised 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. ", + "ancestors": [ + "P_C_OBJECT" + ], + "properties": { + "target_path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "target_path", + "documentation": "Reference to an object node using archetype path notation.", + "is_mandatory": true, + "type": "String" + } + } + }, + "P_ARCHETYPE_SLOT": { + "name": "P_ARCHETYPE_SLOT", + "documentation": "Constraint describing a slot' where another archetype can occur. ", + "ancestors": [ + "P_C_OBJECT" + ], + "properties": { + "includes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "includes", + "documentation": "List of constraints defining other archetypes that could be included at this point. ", + "type_def": { + "container_type": "List" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "excludes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "excludes", + "documentation": "List of constraints defining other archetypes that cannot be included at this point. ", + "type_def": { + "container_type": "List" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "is_closed": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_closed", + "is_mandatory": true, + "type": "Boolean" + } + } + }, + "P_C_PRIMITIVE_OBJECT": { + "name": "P_C_PRIMITIVE_OBJECT", + "documentation": "Parent of types representing constraints on primitive types.", + "is_abstract": true, + "ancestors": [ + "P_C_DEFINED_OBJECT" + ], + "properties": { + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "documentation": "Value to be assumed if none sent in data.", + "type": "Any" + }, + "is_enumerated_type_constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_enumerated_type_constraint", + "documentation": "True if this constraint is actually of an enumerated type that conforms to a primitive type, not a primitive.", + "type": "Boolean" + }, + "constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint", + "documentation": "Constraint represented by this object; redefine in descendants.", + "is_mandatory": true, + "type": "Any" + } + } + }, + "P_C_COMPLEX_OBJECT": { + "name": "P_C_COMPLEX_OBJECT", + "documentation": "Constraint on complex objects, i.e. any object that consists of other object constraints.", + "ancestors": [ + "P_C_DEFINED_OBJECT" + ], + "properties": { + "attributes": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "attributes", + "documentation": "List of constraints on attributes of the reference model type represented by this object.", + "type_def": { + "container_type": "List", + "type": "P_C_ATTRIBUTE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "attribute_tuples": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "attribute_tuples", + "documentation": "List of attribute tuple constraints under this object constraint, if any.", + "type_def": { + "container_type": "List", + "type": "P_C_ATTRIBUTE_TUPLE" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + } + }, + "P_C_ATTRIBUTE_TUPLE": { + "name": "P_C_ATTRIBUTE_TUPLE", + "documentation": "Object representing a constraint on an atttribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like {units, range} constraints.", + "properties": { + "members": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "members", + "documentation": "Member attribute constraint objects.", + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + } + }, + "P_C_ARCHETYPE_ROOT": { + "name": "P_C_ARCHETYPE_ROOT", + "ancestors": [ + "P_C_COMPLEX_OBJECT" + ], + "properties": { + "archetype_ref": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_ref", + "is_mandatory": true, + "type": "String" + } + } + }, + "P_C_BOOLEAN": { + "name": "P_C_BOOLEAN", + "documentation": "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.", + "ancestors": [ + "P_C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "type_def": { + "container_type": "List", + "type": "Boolean" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "type": "Boolean" + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "is_mandatory": true, + "type": "Boolean" + } + } + }, + "P_C_STRING": { + "name": "P_C_STRING", + "documentation": "Constraint on instances of STRING. ", + "ancestors": [ + "P_C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "documentation": "String constraint - a list of literal strings and \/ or regular expression strings delimited by the \u2018\/\u2019 character.", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type": "String" + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "is_mandatory": true, + "type": "String" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "type": "String" + } + } + }, + "P_C_INTEGER": { + "name": "P_C_INTEGER", + "documentation": "Constraint on instances of Integer." + }, + "P_C_REAL": { + "name": "P_C_REAL", + "documentation": "Constraint on instances of Real." + }, + "P_C_ORDERED": { + "name": "P_C_ORDERED", + "documentation": "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.\n\nIn its simplest form, the constraint accessor returns just a single point Interval object, representing a single value.\n\nThe next simplest form is a single proper Interval (i.e. normal two-sided or half-open interval). The most complex form is a list of any combination of point and proper intervals.", + "is_abstract": true, + "ancestors": [ + "P_C_PRIMITIVE_OBJECT" + ], + "generic_parameter_defs": { + "T": { + "name": "T", + "conforms_to_type": "Ordered" + } + }, + "properties": { + "constraint": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "constraint", + "is_mandatory": true, + "type_def": { + "container_type": "List", + "type_def": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Interval", + "generic_parameters": [ + "T" + ] + } + }, + "cardinality": { + "lower": 1, + "upper_unbounded": true + } + } + } + }, + "P_C_TERMINOLOGY_CODE": { + "name": "P_C_TERMINOLOGY_CODE", + "documentation": "Constrainer type for instances of TERMINOLOGY_CODE. The primary expression of the constraint is in the property `tuple_constraint', and comes in 3 variations:\n* a single at-code\n* a single ac-code, representing a value-set that is defined in the archetype terminology\n* a list of at- and\/or ac-codes, representing the possibilities of a tuple constraint\nThe last possibility above is enabled by the merge_tuple routine, which enables the constraint of another single-valued C_TERMINOLOGY_CODE to be merged with the current one.", + "ancestors": [ + "P_C_PRIMITIVE_OBJECT" + ], + "properties": { + "constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "constraint", + "is_mandatory": true, + "type": "String" + }, + "assumed_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "assumed_value", + "type": "Terminology_code" + }, + "default_value": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "default_value", + "is_mandatory": true, + "type": "Terminology_code" + } + } + }, + "P_C_TEMPORAL": { + "name": "P_C_TEMPORAL", + "documentation": "Purpose Abstract parent of C_ORDERED types whose base type is an ISO date\/time type.", + "is_abstract": true, + "ancestors": [ + "P_C_ORDERED" + ], + "generic_parameter_defs": { + "T": { + "name": "T", + "conforms_to_type": "Temporal" + } + }, + "properties": { + "pattern_constraint": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "pattern_constraint", + "documentation": "Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details.", + "is_mandatory": true, + "type": "String" + } + } + }, + "P_C_TIME": { + "name": "P_C_TIME", + "documentation": "ISO 8601-compatible constraint on instances of Time in the form either of a set of validity values, or else date ranges based on the C_ORDERED list constraint. There is no validity flag for \u2018hour\u2019, 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 \u201cHH:??:xx\u201d (time with optional minutes and seconds not allowed)." + }, + "P_C_DATE": { + "name": "P_C_DATE", + "documentation": "ISO 8601-compatible constraint on instances of Date in the form either of a set of validity values, or else date ranges based on the C_ORDERED list constraint. There is no validity flag for \u2018year\u2019, 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 \u201cYYYY-??-??\u201d (date with optional month and day)." + }, + "P_C_DATE_TIME": { + "name": "P_C_DATE_TIME", + "documentation": "ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for \u2018year\u2019, 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 \u201cYYYY-MM-DDT??:??:??\u201d (date\/time with optional time) and \u201cYYYY-MMDDTHH:MM:xx\u201d (date\/time, seconds not allowed)." + }, + "P_C_DURATION": { + "name": "P_C_DURATION" + }, + "P_ARCHETYPE": { + "name": "P_ARCHETYPE", + "documentation": "Archetype equivalent to ARCHETYPED class in Common reference model. Defines semantics of identfication, lifecycle, versioning, composition and specialisation.\n\nAn archetype is a modelled as a particular kind of AUTHORED_RESOURCE, and as such, includes descriptive meta-data, language information and revision history. The ARCHETYPE class adds identifying information, a definition - expressed in terms of constraints on instances of an object model, and an ontology.", + "is_abstract": true, + "properties": { + "parent_archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "parent_archetype_id", + "documentation": "Identifier of the specialisation parent of this archetype.", + "type": "String" + }, + "archetype_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_id", + "documentation": "Identifier of this archetype.", + "is_mandatory": true, + "type": "P_ARCHETYPE_HRID" + }, + "is_differential": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_differential", + "documentation": "Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True.", + "is_mandatory": true, + "type": "Boolean" + }, + "definition": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "definition", + "documentation": "Root node of the definition of this archetype.", + "is_mandatory": true, + "type": "P_C_COMPLEX_OBJECT" + }, + "terminology": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "terminology", + "documentation": "The terminology of the archetype.", + "is_mandatory": true, + "type": "P_ARCHETYPE_TERMINOLOGY" + }, + "rules": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "rules", + "documentation": "Rules relating to this archetype. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.", + "type_def": { + "container_type": "List", + "type": "EL_BOOLEAN_EXPRESSION" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + } + } + }, + "P_AUTHORED_ARCHETYPE": { + "name": "P_AUTHORED_ARCHETYPE", + "documentation": "Root object of a standalone, authored archetype, including all meta-data, description, other identifiers and lifecycle.", + "ancestors": [ + "P_ARCHETYPE", + "AUTHORED_RESOURCE", + "P_AUTHORED_RESOURCE" + ], + "properties": { + "adl_version": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "adl_version", + "documentation": "ADL version if archteype was read in from an ADL sharable archetype.", + "type": "String" + }, + "build_uid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "build_uid", + "documentation": "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.", + "is_mandatory": true, + "type": "UID" + }, + "rm_release": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_release", + "documentation": "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.", + "is_mandatory": true, + "type": "String" + }, + "is_generated": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_generated", + "documentation": "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.", + "is_mandatory": true, + "type": "Boolean" + }, + "other_meta_data": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "other_meta_data", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + } + }, + "P_TEMPLATE": { + "name": "P_TEMPLATE", + "documentation": "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.", + "ancestors": [ + "P_AUTHORED_ARCHETYPE" + ] + }, + "P_OPERATIONAL_TEMPLATE": { + "name": "P_OPERATIONAL_TEMPLATE", + "documentation": "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.\n\nAn operational template is used for generating and validating canonical openEHR data, and also as a source artefact for generating other downstream technical artefacts, including XML schemas, APIs and UI form definitions.", + "ancestors": [ + "P_AUTHORED_ARCHETYPE" + ], + "properties": { + "component_terminologies": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "component_terminologies", + "documentation": "Compendium of flattened terminologies of archetypes externally referenced from this archetype, keyed by archetype identifier. This will almost always be present in a template.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "P_ARCHETYPE_TERMINOLOGY" + ] + } + }, + "terminology_extracts": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "terminology_extracts", + "documentation": "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.", + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERM" + ] + } + } + } + } + } + }, + "P_ARCHETYPE_HRID": { + "name": "P_ARCHETYPE_HRID", + "documentation": "Human_readable identifier (HRID) for an archetype or template.", + "properties": { + "namespace": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "namespace", + "documentation": "Reverse domain name namespace identifier.", + "type": "String" + }, + "rm_publisher": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_publisher", + "documentation": "Name of the Reference Model publisher.", + "is_mandatory": true, + "type": "String" + }, + "rm_package": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_package", + "documentation": "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).", + "is_mandatory": true, + "type": "String" + }, + "rm_class": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "rm_class", + "documentation": "Name of the root class of this archetype.", + "is_mandatory": true, + "type": "String" + }, + "concept_id": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "concept_id", + "documentation": "The short concept name of the archetype as used in the multi-axial archetype_hrid.", + "is_mandatory": true, + "type": "String" + }, + "release_version": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "release_version", + "documentation": "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.", + "is_mandatory": true, + "type": "String" + }, + "version_status": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "version_status", + "documentation": "The status of the version, i.e. released, release_candidate etc.", + "is_mandatory": true, + "type": "VERSION_STATUS" + }, + "build_count": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "build_count", + "documentation": "The build count since last increment of any version part.", + "is_mandatory": true, + "type": "String" + } + } + }, + "P_AUTHORED_RESOURCE": { + "name": "P_AUTHORED_RESOURCE", + "documentation": "Abstract idea of an online resource created by a human author. \n", + "is_abstract": true, + "properties": { + "original_language": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "original_language", + "documentation": "Language in which this resource was initially authored. Although there is no language primacy of resources overall, the language of original authoring is required to ensure natural language translations can preserve quality. Language is relevant in both the description and ontology sections. ", + "is_mandatory": true, + "type": "String" + }, + "is_controlled": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_controlled", + "documentation": "True if this resource is under any kind of change control (even file copying), in which case revision history is created. ", + "type": "Boolean" + }, + "translations": { + "_type": "P_BMM_CONTAINER_PROPERTY", + "name": "translations", + "documentation": "List of details for each natural translation made of this resource, keyed by language. For each translation listed here, there must be corresponding sections in all language-dependent parts of the resource. The original_language does not appear in this list.", + "type_def": { + "container_type": "List", + "type": "TRANSLATION_DETAILS" + }, + "cardinality": { + "lower": 0, + "upper_unbounded": true + } + }, + "description": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "description", + "documentation": "Description and lifecycle information of the resource.", + "type": "RESOURCE_DESCRIPTION" + }, + "uid": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "uid", + "documentation": "Unique identifier of the family of archetypes having the same interface identifier (same major version).", + "type": "String" + }, + "annotations": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "annotations", + "documentation": "Annotations on individual items within the resource, keyed by path. The inner table takes the form of a Hash table of String values keyed by String tags.", + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + } + } + } + }, + "P_ARCHETYPE_TERMINOLOGY": { + "name": "P_ARCHETYPE_TERMINOLOGY", + "documentation": "Local ontology of an archetype.", + "properties": { + "is_differential": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "is_differential", + "is_mandatory": true, + "type": "Boolean" + }, + "original_language": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "original_language", + "is_mandatory": true, + "type": "String" + }, + "term_definitions": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "term_definitions", + "documentation": "Directory of term definitions as a two-level \ntable. The outer hash keys are term codes, \ne.g. \"at0004\", and the inner hash key are term \nattribute names, e.g. \"text\", \"description\" etc.", + "is_mandatory": true, + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "ARCHETYPE_TERM" + ] + } + } + } + }, + "term_bindings": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "term_bindings", + "documentation": "Directory of term bindings as a two-level \ntable. The outer hash keys are local term codes, \ne.g. \"at0004\", and the inner hash keys are terminology \ncode phrases, e.g. \"SNOMED(2003)::163034007\" etc.", + "type_def": { + "root_type": "Hash", + "generic_parameter_defs": { + "K": { + "_type": "P_BMM_SIMPLE_TYPE", + "type": "String" + }, + "V": { + "_type": "P_BMM_GENERIC_TYPE", + "root_type": "Hash", + "generic_parameters": [ + "String", + "Uri" + ] + } + } + } + }, + "value_sets": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "value_sets", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "VALUE_SET" + ] + } + } + } + }, + "AOM_PROFILE": { + "name": "AOM_PROFILE", + "documentation": "Profile of common settings relating to use of reference model(s) and terminology for a given archetype developing organisation.", + "properties": { + "profile_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "profile_name", + "documentation": "Name of this profile, usually based on the publisher it pertains to e.g. \"openEHR\", \"CDISC\", etc.", + "is_mandatory": true, + "type": "String" + }, + "archetype_parent_class": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_parent_class", + "documentation": "States a class from the Reference Model that provides archetyping capability in RM data structures. This attribute is optional, and there need be no such class in the RM. Defining it here has the effect in tools that the class tree under which archetypes are arranged contains only RM classes inheriting from this class.", + "type": "String" + }, + "archetype_data_value_parent_class": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_data_value_parent_class", + "documentation": "This attribute defines a base class from the Reference Model whose descendants are considered to be 'logical data types', i.e. of some higher level than the built-in primitive types String, Integer etc. This attribute is optional, even if the RM does have such a class, and is only used to help tooling to provide more intelligent display.", + "type": "String" + }, + "aom_rm_type_mappings": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "aom_rm_type_mappings", + "documentation": "Mappings from AOM built-in types to actual types in RM: whenever the type name is encountered in an archetype, it is mapped to a specific RM type.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "AOM_TYPE_MAPPING" + ] + } + }, + "archetype_visualise_descendants_of": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "archetype_visualise_descendants_of", + "documentation": "If `_archetype_parent_class_` is not set, designate a class whose descendants should be made visible in tree and grid renderings of the archetype definition.", + "type": "String" + }, + "aom_rm_type_substitutions": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "aom_rm_type_substitutions", + "documentation": "Allowed type substitutions: Actual RM type names keyed by AOM built-in types which can substitute for them in an archetype. E.g. `` means that if RM property `TYPE._some_property_` is of type `String`, an `ISO8601_DATE` is allowed at that position in the archetype.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + }, + "aom_lifecycle_mappings": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "aom_lifecycle_mappings", + "documentation": "List of mappings of lifecycle state names used in archetypes to AOM lifecycle state names: \n\n* key = source lifecycle state; \n* value = AOM lifecycle state.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + }, + "rm_primitive_type_equivalences": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "rm_primitive_type_equivalences", + "documentation": "Equivalences of RM primitive types to in-built set of primitive types. Used to determine which AOM `C_PRIMITIVE_OBJECT` descendant is used for a primitive type. Typical entries:\n\n* `value`\t`key`\n* \"Real\"\t\"Double\"\n* \"Integer\"\t\"Integer64\"", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "String" + ] + } + } + } + }, + "AOM_TYPE_MAPPING": { + "name": "AOM_TYPE_MAPPING", + "documentation": "Data object expressing a mapping between two types.", + "properties": { + "source_class_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "source_class_name", + "documentation": "Name of the AOM type being mapped to an RM type.", + "is_mandatory": true, + "type": "String" + }, + "target_class_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "target_class_name", + "documentation": "Name of the RM type in the mapping.", + "is_mandatory": true, + "type": "String" + }, + "property_mappings": { + "_type": "P_BMM_GENERIC_PROPERTY", + "name": "property_mappings", + "documentation": "List of mappings of properties of this type to another type.", + "type_def": { + "root_type": "Hash", + "generic_parameters": [ + "String", + "AOM_PROPERTY_MAPPING" + ] + } + } + } + }, + "AOM_PROPERTY_MAPPING": { + "name": "AOM_PROPERTY_MAPPING", + "documentation": "Data object expressing a mapping between two class properties.", + "properties": { + "source_property_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "source_property_name", + "documentation": "Name of property in source class.", + "is_mandatory": true, + "type": "String" + }, + "target_property_name": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "target_property_name", + "documentation": "Name of property in target class.", + "is_mandatory": true, + "type": "String" + } + } + }, + "EXPR_ARCHETYPE_ID_CONSTRAINT": { + "name": "EXPR_ARCHETYPE_ID_CONSTRAINT", + "documentation": "Expression tree leaf item representing a constraint on an archetype identifier.", + "ancestors": [ + "EXPR_CONSTRAINT" + ], + "properties": { + "item": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "item", + "documentation": "A C_STRING representing a regular expression for matching Archetype identifiers.", + "is_mandatory": true, + "type": "C_STRING" + } + } + }, + "EXPR_ARCHETYPE_REF": { + "name": "EXPR_ARCHETYPE_REF", + "documentation": "Expression tree leaf item representing a reference to a value found in data at a location specified by a path in the archetype definition.\n\n* A path referring to a value in the archetype (paths with a leading \u2018\/\u2019 are in the definition section.\n* Paths with no leading \u2018\/\u2019 are in the outer part of the archetype, e.g. \u201carchetype_id\/value\u201d refers to the String value of the archetype_id attribute of the enclosing archetype.\n", + "ancestors": [ + "EXPR_VALUE_REF" + ], + "properties": { + "path": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "path", + "documentation": "The path to the archetype node.", + "is_mandatory": true, + "type": "String" + }, + "item": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "item", + "is_mandatory": true, + "type": "ARCHETYPE_CONSTRAINT" + } + } + }, + "EXPR_CONSTRAINT": { + "name": "EXPR_CONSTRAINT", + "documentation": "Expression tree leaf item representing a constraint on a primitive type, expressed in the form of a concrete subtype of C_PRIMITIVE_OBJECT.", + "ancestors": [ + "EXPR_LEAF" + ], + "properties": { + "item": { + "_type": "P_BMM_SINGLE_PROPERTY", + "name": "item", + "documentation": "The constraint.", + "is_mandatory": true, + "type": "C_PRIMITIVE_OBJECT" + } + } + } + } +} diff --git a/docs/UML/classes/org.openehr.am.aom14.archetype.adoc b/docs/UML/classes/org.openehr.am.aom14.archetype.adoc index 658d7aae..08e6c79d 100644 --- a/docs/UML/classes/org.openehr.am.aom14.archetype.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.archetype.adoc @@ -24,15 +24,20 @@ h|*1..1* a|The ontology of the archetype. h|*0..1* -|*adl_version*: `String` +|*adl_version*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|ADL version if archetype was read in from an ADL sharable archetype. h|*1..1* |*archetype_id*: `link:/releases/BASE/{base_release}/base_types.html#_archetype_id_class[ARCHETYPE_ID^]` a|Multi-axial identifier of this archetype in archetype space. +h|*0..1 + +(redefined)* +|*uid*: `link:/releases/BASE/{base_release}/base_types.html#_hier_object_id_class[HIER_OBJECT_ID^]` +a|OID identifier of this archetype. + h|*1..1* -|*concept*: `String` +|*concept*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The normative meaning of the archetype as a whole, expressed as a local archetype code, typically “at0000”. h|*0..1* @@ -43,72 +48,68 @@ h|*0..1* |*invariants*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_assertion_class,ASSERTION>>>` a|Invariant statements about this object. Statements are expressed in first order predicate logic, and usually refer to at least two attributes. -h|*0..1 + -(redefined)* -|*uid*: `link:/releases/BASE/{base_release}/base_types.html#_hier_object_id_class[HIER_OBJECT_ID^]` -a|OID identifier of this archetype. h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* |*concept_name* ( + -a_lang: `String[1]` + -): `String` + +a_lang: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` + + __post-condition__: `Result.is_equal (definition.node_id)` a|The concept name of the archetype in language a_lang; corresponds to the term definition of the concept attribute in the archetype ontology. h|*1..1* -|*physical_paths* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*physical_paths* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|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. h|*1..1* |*logical_paths* ( + -lang: `String[1]` + -): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +lang: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|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. h|*1..1* -|*specialisation_depth* (): `Integer` + +|*specialisation_depth* (): `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` + + __post-condition__: `Result = terminology.specialisation_depth` a|Specialisation depth of this archetype; larger than 0 if this archetype has a parent. Derived from terminology.specialisation_depth. h|*1..1* -|*is_specialised* (): `Boolean` + +|*is_specialised* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __post-condition__: `Result implies parent_archetype_id /= Void` a|True if this archetype is a specialisation of another. h|*1..1* -|*is_valid* (): `Boolean` + +|*is_valid* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `not (node_ids_valid and internal_references_valid and constraint_references_valid) implies not Result` a|True if the archetype is valid overall; various tests should be used, including checks on node_ids, internal references, and constraint references. h|*1..1* -|*node_ids_valid* (): `Boolean` +|*node_ids_valid* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if every node_id found on a C_OBJECT node is found in ontology.term_codes. h|*0..1* -|*previous_version* (): `String` +|*previous_version* (): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Version of predecessor archetype of this archetype, if any. h|*1..1* -|*internal_references_valid* (): `Boolean` +|*internal_references_valid* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if every ARCHETYPE_INTERNAL_REF. target_path refers to a legitimate node in the archetype definition. h|*1..1* -|*constraint_references_valid* (): `Boolean` +|*constraint_references_valid* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if every CONSTRAINT_REF.reference found on a C_OBJECT node in the archetype definition is found in ontology.constraint_codes. h|*1..1* -|*short_concept_name* (): `String` +|*short_concept_name* (): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The short concept name of the archetype extracted from the archetype_id. h|*1..1* -|*version* (): `String` +|*version* (): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom14.archetype_constraint.adoc b/docs/UML/classes/org.openehr.am.aom14.archetype_constraint.adoc index e6875f53..f38ad9b7 100644 --- a/docs/UML/classes/org.openehr.am.aom14.archetype_constraint.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.archetype_constraint.adoc @@ -16,22 +16,28 @@ h|*1..1 + (abstract)* |*is_subset_of* ( + other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]` + -): `Boolean` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|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. h|*1..1 + (abstract)* -|*is_valid* (): `Boolean` +|*is_valid* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*1..1* -|*path* (): `String` +|*path* (): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Path of this node relative to root of archetype. h|*1..1* |*has_path* ( + -a_path: `String[1]` + -): `Boolean` +a_path: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the relative path a_path exists at this node. + +h|*Invariants* +2+a|__Post__: `Result = soc_parent /= Void or parent.soc_parent /= Void` + +h| +2+a|__Path_exists__: `path /= Void` |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.archetype_internal_ref.adoc b/docs/UML/classes/org.openehr.am.aom14.archetype_internal_ref.adoc index bba11a0b..034361d9 100644 --- a/docs/UML/classes/org.openehr.am.aom14.archetype_internal_ref.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.archetype_internal_ref.adoc @@ -9,7 +9,7 @@ h|*Description* 2+a|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. +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. h|*Inherit* 2+|`<<_c_reference_object_class,C_REFERENCE_OBJECT>>` @@ -19,7 +19,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*target_path*: `String` +|*target_path*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference to an object node using archetype path notation. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom14.archetype_ontology.adoc b/docs/UML/classes/org.openehr.am.aom14.archetype_ontology.adoc index 30ce605a..3379626f 100644 --- a/docs/UML/classes/org.openehr.am.aom14.archetype_ontology.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.archetype_ontology.adoc @@ -13,11 +13,11 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*term_codes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*term_codes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|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. h|*1..1* -|*constraint_codes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint_codes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|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. h|*1..1* @@ -25,48 +25,49 @@ h|*1..1* a|Archetype which owns this terminology. h|*0..1* -|*terminologies_available*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*terminologies_available*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of terminologies to which term or constraint bindings exist in this terminology. h|*1..1* -|*specialisation_depth*: `Integer` +|*specialisation_depth*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` a|Specialisation depth of this archetype. Unspecialised archetypes have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth. h|*1..1* -|*term_attribute_names*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*term_attribute_names*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a| + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* |*has_language* ( + -a_lang: `String[1]` + -): `Boolean` +a_lang: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if terminology ‘a_terminology’ is present in archetype ontology. h|*1..1* |*has_terminology* ( + -a_terminology_id: `String[1]` + -): `Boolean` +a_terminology_id: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if terminology `a_terminology' is present in archetype ontology. h|*1..1* |*has_term_code* ( + -a_code: `String[1]` + -): `Boolean` +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if term_codes has a_code. h|*1..1* |*has_constraint_code* ( + -a_code: `String[1]` + -): `Boolean` +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if constraint_codes has a_code. h|*1..1* |*term_definition* ( + -a_lang: `String[1]`, + -a_code: `String[1]` + +a_lang: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + ): `<<_archetype_term_class,ARCHETYPE_TERM>>` + + __Pre__: `has_language (a_lang)` + @@ -75,8 +76,8 @@ a|Term definition for a code, in a specified language. h|*1..1* |*constraint_definition* ( + -a_code: `String[1]`, + -a_lang: `String[1]` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_lang: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + ): `<<_archetype_term_class,ARCHETYPE_TERM>>` + + __Pre__: `has_language (a_lang)` + @@ -85,8 +86,8 @@ a|Constraint definition for a code, in a specified language. h|*1..1* |*term_binding* ( + -a_terminology: `String[1]`, + -a_code: `String[1]` + +a_terminology: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_code_phrase_class[CODE_PHRASE^]` + + __Pre__: `has_term_binding (a_terminology_id, a_code)` @@ -94,9 +95,9 @@ a|Binding of constraint corresponding to a_code in target external terminology a h|*1..1* |*constraint_binding* ( + -a_terminology_id: `String[1]`, + -a_code: `String[1]` + -): `String` +a_terminology_id: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Binding of constraint corresponding to a_code in target external terminology a_terminology_id, as a string, which is usually a formal query expression. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom14.archetype_term.adoc b/docs/UML/classes/org.openehr.am.aom14.archetype_term.adoc index 7e11324d..a7a9b2e5 100644 --- a/docs/UML/classes/org.openehr.am.aom14.archetype_term.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.archetype_term.adoc @@ -13,19 +13,19 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*code*: `String` +|*code*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Code of this term. h|*0..1* -|*items*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*items*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a|Hash of keys (“text”, “description” etc) and corresponding values. -Hash of keys ("text", "description" etc) and corresponding values. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*0..1* -|*keys* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*keys* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of all keys used in this term. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom14.assertion.adoc b/docs/UML/classes/org.openehr.am.aom14.assertion.adoc index 6bfc009e..adccee14 100644 --- a/docs/UML/classes/org.openehr.am.aom14.assertion.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.assertion.adoc @@ -13,11 +13,11 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*tag*: `String` +|*tag*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Expression tag, used for differentiating multiple assertions. h|*0..1* -|*string_expression*: `String` +|*string_expression*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|String form of expression, in case an expression evaluator taking String expressions is used for evaluation. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.assertion_variable.adoc b/docs/UML/classes/org.openehr.am.aom14.assertion_variable.adoc index 3d0bc497..b7e0d8b5 100644 --- a/docs/UML/classes/org.openehr.am.aom14.assertion_variable.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.assertion_variable.adoc @@ -13,10 +13,10 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*name*: `String` +|*name*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Name of variable. h|*1..1* -|*definition*: `String` +|*definition*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Formal definition of the variable. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_attribute.adoc b/docs/UML/classes/org.openehr.am.aom14.c_attribute.adoc index 4fb3dc1d..d7aba716 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_attribute.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_attribute.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*rm_attribute_name*: `String` +|*rm_attribute_name*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference model attribute within the enclosing type represented by a C_OBJECT. h|*1..1* @@ -26,12 +26,13 @@ a|Constraint on every attribute, regardless of whether it is singular or of a co h|*0..1* |*children*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_c_object_class,C_OBJECT>>>` a|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. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result := children = Void or else children.is_empty` a|True if any value (i.e. instance) of the reference model attribute represented by this C_ATTIRBUTE is allowed. diff --git a/docs/UML/classes/org.openehr.am.aom14.c_boolean.adoc b/docs/UML/classes/org.openehr.am.aom14.c_boolean.adoc index caac2d2b..158da887 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_boolean.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_boolean.adoc @@ -16,11 +16,11 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*true_valid*: `Boolean` +|*true_valid*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the value True is allowed. h|*1..1* -|*false_valid*: `Boolean` +|*false_valid*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the value False is allowed. h|*0..1 + diff --git a/docs/UML/classes/org.openehr.am.aom14.c_coded_text.adoc b/docs/UML/classes/org.openehr.am.aom14.c_coded_text.adoc index 2c17cceb..3451b373 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_coded_text.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_coded_text.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*terminology*: `String` +|*terminology*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Terminology identifier. h|*0..1* @@ -24,6 +24,6 @@ h|*0..1* a|Optional list of codes from the terminology. No list means any code from the terminology is allowed. h|*0..1* -|*reference*: `String` +|*reference*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_complex_object.adoc b/docs/UML/classes/org.openehr.am.aom14.c_complex_object.adoc index 66b40435..b63a8219 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_complex_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_complex_object.adoc @@ -18,17 +18,18 @@ h|*Attributes* h|*0..1* |*attributes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_c_attribute_class,C_ATTRIBUTE>>>` a|List of constraints on attributes of the reference model type represented by this object. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = attributes.is_empty` a|True if any value of the reference model type being constrained is allowed. h|*Invariants* -2+a|__Attributes_valid__: ` any_allowed xor (attributes /= Void and not attributes.is_empty)` +2+a|__Attributes_valid__: `any_allowed xor (attributes /= Void and not attributes.is_empty)` |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_date.adoc b/docs/UML/classes/org.openehr.am.aom14.c_date.adoc index 0dddda5c..526bc7cf 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_date.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_date.adoc @@ -33,10 +33,13 @@ h|*0..1 + a|The value to assume if this item is not included in data, due to being part of an optional structure. h|*Invariants* -2+a|__Month_validity_optional__: `month_validity = {VALIDITY_KIND}.optional implies (day_validity = {VALIDITY_KIND}.optional or day_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Pattern_validity__: `pattern /= Void implies valid_iso8601_date_constraint_pattern(pattern)` h| -2+a|__Month_validity_disallowed__: `month_validity = {VALIDITY_KIND}.disallowed implies day_validity = {VALIDITY_KIND}.disallowed` +2+a|__Month_validity_optional__: `month_validity = \{VALIDITY_KIND}.optional implies (day_validity = \{VALIDITY_KIND}.optional or day_validity = \{VALIDITY_KIND}.disallowed)` + +h| +2+a|__Month_validity_disallowed__: `month_validity = \{VALIDITY_KIND}.disallowed implies day_validity = \{VALIDITY_KIND}.disallowed` h| 2+a|__Validity_is_range__: `validity_is_range = (range /= Void)` diff --git a/docs/UML/classes/org.openehr.am.aom14.c_date_time.adoc b/docs/UML/classes/org.openehr.am.aom14.c_date_time.adoc index 4337c5b9..330b647c 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_date_time.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_date_time.adoc @@ -51,43 +51,47 @@ h|*0..1 + (redefined)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_date_time_class[Iso8601_date_time^]` a|The value to assume if this item is not included in data, due to being part of an optional structure. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*validity_is_range* (): `Boolean` +|*validity_is_range* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if validity is in the form of a range; useful for developers to check which kind of constraint has been set. h|*Invariants* -2+a|__Month_validity_optional:__: `month_validity = {VALIDITY_KIND}.optional implies (day_validity = {VALIDITY_KIND}.optional or day_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Pattern_validity__: `pattern /= Void implies valid_iso8601_date_time_constraint_pattern(pattern)` + +h| +2+a|__Month_validity_optional:__: `month_validity = \{VALIDITY_KIND}.optional implies (day_validity = \{VALIDITY_KIND}.optional or day_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Month_validity_disallowed__: `month_validity = {VALIDITY_KIND}.disallowed implies day_validity = {VALIDITY_KIND}.disallowed` +2+a|__Month_validity_disallowed__: `month_validity = \{VALIDITY_KIND}.disallowed implies day_validity = \{VALIDITY_KIND}.disallowed` h| -2+a|__Day_validity_optional__: `day_validity = {VALIDITY_KIND}.optional implies (hour_validity = {VALIDITY_KIND}.optional or hour_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Day_validity_optional__: `day_validity = \{VALIDITY_KIND}.optional implies (hour_validity = \{VALIDITY_KIND}.optional or hour_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Day_validity_disallowed__: `day_validity = {VALIDITY_KIND}.disallowed implies hour_validity = {VALIDITY_KIND}.disallowed` +2+a|__Day_validity_disallowed__: `day_validity = \{VALIDITY_KIND}.disallowed implies hour_validity = \{VALIDITY_KIND}.disallowed` h| -2+a|__Hour_validity_optional__: `hour_validity = {VALIDITY_KIND}.optional implies (minute_validity = {VALIDITY_KIND}.optional or minute_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Hour_validity_optional__: `hour_validity = \{VALIDITY_KIND}.optional implies (minute_validity = \{VALIDITY_KIND}.optional or minute_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Hour_validity_disallowed__: `hour_validity = {VALIDITY_KIND}.disallowed implies minute_validity = {VALIDITY_KIND}.disallowed` +2+a|__Hour_validity_disallowed__: `hour_validity = \{VALIDITY_KIND}.disallowed implies minute_validity = \{VALIDITY_KIND}.disallowed` h| -2+a|__Minute_validity_optional__: `minute_validity = {VALIDITY_KIND}.optional implies (second_validity = {VALIDITY_KIND}.optional or second_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Minute_validity_optional__: `minute_validity = \{VALIDITY_KIND}.optional implies (second_validity = \{VALIDITY_KIND}.optional or second_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Minute_validity_disallowed__: `minute_validity = {VALIDITY_KIND}.disallowed implies second_validity = {VALIDITY_KIND}.disallowed` +2+a|__Minute_validity_disallowed__: `minute_validity = \{VALIDITY_KIND}.disallowed implies second_validity = \{VALIDITY_KIND}.disallowed` h| -2+a|__Second_validity_optional__: `second_validity = {VALIDITY_KIND}.optional implies (millisecond_validity = {VALIDITY_KIND}.optional or millisecond_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Second_validity_optional__: `second_validity = \{VALIDITY_KIND}.optional implies (millisecond_validity = \{VALIDITY_KIND}.optional or millisecond_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Second_validity_disallowed__: `second_validity = {VALIDITY_KIND}.disallowed implies millisecond_validity = {VALIDITY_KIND}.disallowed` +2+a|__Second_validity_disallowed__: `second_validity = \{VALIDITY_KIND}.disallowed implies millisecond_validity = \{VALIDITY_KIND}.disallowed` h| 2+a|__Validity_is_range__: `validity_is_range = (range /= Void)` diff --git a/docs/UML/classes/org.openehr.am.aom14.c_defined_object.adoc b/docs/UML/classes/org.openehr.am.aom14.c_defined_object.adoc index 91c7dcaf..3f7d94b8 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_defined_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_defined_object.adoc @@ -18,6 +18,7 @@ h|*Attributes* h|*0..1* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -26,7 +27,7 @@ h|*1..1 + (abstract)* |*valid_value* ( + a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^][1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if a_value is valid with respect to constraint expressed in concrete instance of this type. h|*1..1 + @@ -35,7 +36,7 @@ h|*1..1 + a|Generate a prototype value from this constraint object. h|*1..1* -|*has_assumed_value* (): `Boolean` +|*has_assumed_value* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if there is an assumed value. h|*0..1 + @@ -45,7 +46,7 @@ a|Generate a default value from this constraint object. h|*1..1 + (abstract)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = attributes.is_empty` a|True if any value of the reference model type being constrained is allowed. Redefine in descendants. diff --git a/docs/UML/classes/org.openehr.am.aom14.c_duration.adoc b/docs/UML/classes/org.openehr.am.aom14.c_duration.adoc index d7aab12f..98d3d32f 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_duration.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_duration.adoc @@ -10,7 +10,7 @@ h|*Description* Both range and the constraint pattern can be set at the same time, corresponding to the ADL constraint `"PWD/|P0W..P50W|"`. -As for all of openEHR, two ISO 8601 exceptions are allowed: +As for all of openEHR, two ISO 8601 exceptions are allowed: * the ‘W’ (week) designator can be mixed in - the allowed patterns are: `P[Y|y][M|m][D|d][T[H|h][M|m][S|s]]` and `P[W|w]`; * the values used in an interval constraint may be negated, i.e. a leading minus (`'-'`) sign may be used. @@ -23,35 +23,35 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*years_allowed*: `Boolean` +|*years_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*0..1* -|*months_allowed*: `Boolean` +|*months_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if months are allowed in the constrained Duration. h|*0..1* -|*weeks_allowed*: `Boolean` +|*weeks_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*0..1* -|*days_allowed*: `Boolean` +|*days_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if days are allowed in the constrained Duration. h|*0..1* -|*hours_allowed*: `Boolean` +|*hours_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if hours are allowed in the constrained Duration. h|*0..1* -|*minutes_allowed*: `Boolean` +|*minutes_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if minutes are allowed in the constrained Duration. h|*0..1* -|*seconds_allowed*: `Boolean` +|*seconds_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*0..1* -|*fractional_seconds_allowed*: `Boolean` +|*fractional_seconds_allowed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if fractional seconds are allowed in the constrained Duration. h|*0..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_integer.adoc b/docs/UML/classes/org.openehr.am.aom14.c_integer.adoc index 4ae528c0..3bb40346 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_integer.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_integer.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Set of Integers specifying constraint. h|*0..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_multiple_attribute.adoc b/docs/UML/classes/org.openehr.am.aom14.c_multiple_attribute.adoc index 59c920a9..03d0057c 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_multiple_attribute.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_multiple_attribute.adoc @@ -18,6 +18,7 @@ h|*Attributes* h|*1..1* |*cardinality*: `<<_cardinality_class,CARDINALITY>>` a|Cardinality of this attribute constraint, if it constraints a container attribute. + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_object.adoc b/docs/UML/classes/org.openehr.am.aom14.c_object.adoc index 96a49221..35e3e261 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_object.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*rm_type_name*: `String` +|*rm_type_name*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference model type that this node corresponds to. h|*1..1* @@ -24,7 +24,7 @@ h|*1..1* a|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). h|*1..1* -|*node_id*: `String` -a|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 at-codes. +|*node_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` +a|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 at-codes. For C_PRIMITIVE_OBJECTs, it will have the special value Primitive_node_id. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_primitive.adoc b/docs/UML/classes/org.openehr.am.aom14.c_primitive.adoc index 02baf705..c17fc5bd 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_primitive.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_primitive.adoc @@ -15,6 +15,7 @@ h|*Attributes* h|*0..1* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -26,14 +27,14 @@ a|Generate a default value from this constraint object. h|*1..1 + (abstract)* -|*has_assumed_value* (): `Boolean` +|*has_assumed_value* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if there is an assumed value. h|*1..1 + (abstract)* |*valid_value* ( + a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^][1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if a_value is valid with respect to constraint expressed in concrete instance of this type. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_primitive_object.adoc b/docs/UML/classes/org.openehr.am.aom14.c_primitive_object.adoc index 34a6d7b4..d76edc24 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_primitive_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_primitive_object.adoc @@ -18,13 +18,14 @@ h|*Attributes* h|*1..1* |*item*: `<<_c_primitive_class,C_PRIMITIVE>>` a|Object actually defining the constraint. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = item = Void` a|True if any value of the type being constrained in item is allowed. diff --git a/docs/UML/classes/org.openehr.am.aom14.c_quantity.adoc b/docs/UML/classes/org.openehr.am.aom14.c_quantity.adoc index c29a7a35..12b147cb 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_quantity.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_quantity.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*property*: `String` +|*property*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Name of physical property for Quantities being constrained. h|*0..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_quantity_item.adoc b/docs/UML/classes/org.openehr.am.aom14.c_quantity_item.adoc index 06fb21f3..f3f48fd2 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_quantity_item.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_quantity_item.adoc @@ -17,6 +17,6 @@ h|*1..1* a|Quantity magnitude constraint. h|*0..1* -|*units*: `String` +|*units*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Optional units constraint. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_real.adoc b/docs/UML/classes/org.openehr.am.aom14.c_real.adoc index b5e3ea87..a280c3bc 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_real.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_real.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Set of Reals specifying constraint. h|*0..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.c_string.adoc b/docs/UML/classes/org.openehr.am.aom14.c_string.adoc index 2e72ea8d..bfdd8b61 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_string.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_string.adoc @@ -16,21 +16,22 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*pattern*: `String` +|*pattern*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Regular expression pattern for proposed instances of String to match. h|*0..1* -|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*list*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Set of Strings specifying constraint. h|*1..1* -|*list_open*: `Boolean` +|*list_open*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the list is being used to specify the constraint but is not considered exhaustive. h|*0..1 + (redefined)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The value to assume if this item is not included in data, due to being part of an optional structure. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -38,7 +39,7 @@ h|*Functions* h|*1..1 + (effected)* |*valid_value* ( + -a_value: `String[1]` + -): `Boolean` +a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if a_value is valid with respect to constraint expressed in concrete instance of this type. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.c_time.adoc b/docs/UML/classes/org.openehr.am.aom14.c_time.adoc index fda3c3a3..f35bc8ff 100644 --- a/docs/UML/classes/org.openehr.am.aom14.c_time.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.c_time.adoc @@ -39,23 +39,27 @@ h|*0..1 + (redefined)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_time_class[Iso8601_time^]` a|The value to assume if this item is not included in data, due to being part of an optional structure. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*validity_is_range* (): `Boolean` +|*validity_is_range* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if validity is in the form of a range; useful for developers to check which kind of constraint has been set. h|*Invariants* -2+a|__Minute_validity_optional__: `minute_validity = {VALIDITY_KIND}.optional implies (second_validity = {VALIDITY_KIND}.optional or second_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Pattern_validity__: `pattern /= Void implies valid_iso8601_time_constraint_pattern (pattern)` + +h| +2+a|__Minute_validity_optional__: `minute_validity = \{VALIDITY_KIND}.optional implies (second_validity = \{VALIDITY_KIND}.optional or second_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Minute_validity_disallowed__: `minute_validity = {VALIDITY_KIND}.disallowed implies second_validity = {VALIDITY_KIND}.disallowed` +2+a|__Minute_validity_disallowed__: `minute_validity = \{VALIDITY_KIND}.disallowed implies second_validity = \{VALIDITY_KIND}.disallowed` h| -2+a|__Second_validity_optional__: `second_validity = {VALIDITY_KIND}.optional implies (millisecond_validity = {VALIDITY_KIND}.optional or millisecond_validity = {VALIDITY_KIND}.disallowed)` +2+a|__Second_validity_optional__: `second_validity = \{VALIDITY_KIND}.optional implies (millisecond_validity = \{VALIDITY_KIND}.optional or millisecond_validity = \{VALIDITY_KIND}.disallowed)` h| -2+a|__Second_validity_disallowed__: `second_validity = {VALIDITY_KIND}.disallowed implies millisecond_validity = {VALIDITY_KIND}.disallowed Validity_is_range: validity_is_range = (range /= Void)` +2+a|__Second_validity_disallowed__: `second_validity = \{VALIDITY_KIND}.disallowed implies millisecond_validity = \{VALIDITY_KIND}.disallowed Validity_is_range: validity_is_range = (range /= Void)` |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.cardinality.adoc b/docs/UML/classes/org.openehr.am.aom14.cardinality.adoc index 0adb8733..16fe0ba6 100644 --- a/docs/UML/classes/org.openehr.am.aom14.cardinality.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.cardinality.adoc @@ -17,25 +17,26 @@ h|*1..1* a|The interval of this cardinality. h|*1..1* -|*is_ordered*: `Boolean` +|*is_ordered*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the members of the container attribute to which this cardinality refers are ordered. h|*1..1* -|*is_unique*: `Boolean` +|*is_unique*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the members of the container attribute to which this cardinality refers are unique. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*is_bag* (): `Boolean` +|*is_bag* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership. h|*1..1* -|*is_list* (): `Boolean` +|*is_list* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the semantics of this cardinality represent a list, i.e. ordered, non-unique membership. h|*1..1* -|*is_set* (): `Boolean` +|*is_set* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.expr_item.adoc b/docs/UML/classes/org.openehr.am.aom14.expr_item.adoc index 9e0bd291..4df43a18 100644 --- a/docs/UML/classes/org.openehr.am.aom14.expr_item.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.expr_item.adoc @@ -13,6 +13,6 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*type*: `String` +|*type*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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”. |=== diff --git a/docs/UML/classes/org.openehr.am.aom14.expr_leaf.adoc b/docs/UML/classes/org.openehr.am.aom14.expr_leaf.adoc index 7d48ff59..498ce8cb 100644 --- a/docs/UML/classes/org.openehr.am.aom14.expr_leaf.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.expr_leaf.adoc @@ -21,7 +21,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*reference_type*: `String` +|*reference_type*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.expr_operator.adoc b/docs/UML/classes/org.openehr.am.aom14.expr_operator.adoc index ab003fa2..220d7866 100644 --- a/docs/UML/classes/org.openehr.am.aom14.expr_operator.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.expr_operator.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*precedence_overridden*: `Boolean` +|*precedence_overridden*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|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. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom14.operator_kind.adoc b/docs/UML/classes/org.openehr.am.aom14.operator_kind.adoc index e27f1333..dbcb56d8 100644 --- a/docs/UML/classes/org.openehr.am.aom14.operator_kind.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.operator_kind.adoc @@ -8,7 +8,7 @@ h|*Enumeration* h|*Description* 2+a|Enumeration type for operator types in assertion expressions. -h|*Attributes* +h|*Constants* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom14.ordinal.adoc b/docs/UML/classes/org.openehr.am.aom14.ordinal.adoc index c9e1cc4a..def58281 100644 --- a/docs/UML/classes/org.openehr.am.aom14.ordinal.adoc +++ b/docs/UML/classes/org.openehr.am.aom14.ordinal.adoc @@ -17,6 +17,6 @@ h|*1..1* a|Terminology code providing the Ordinal's symbol. h|*1..1* -|*value*: `Integer` +|*value*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` a|Ordinal value. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.adl_code_definitions.adoc b/docs/UML/classes/org.openehr.am.aom2.adl_code_definitions.adoc index e168dda8..88da0548 100644 --- a/docs/UML/classes/org.openehr.am.aom2.adl_code_definitions.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.adl_code_definitions.adoc @@ -1,9 +1,5 @@ === ADL_CODE_DEFINITIONS Class -ADL2 was initially released with code system using id-codes (for nodes), at-codes (for values only) and ac-codes (for value sets). As this proved to hinder its widespread use in the openEHR community (due to its impact on existing openEHR RM data), a code system matching the one used in ADL1.4 was introduced as the openEHR primary code system. - -openEHR systems must support at least the at-coded ADL2 archetypes. - [cols="^1,3,5"] |=== h|*Class* @@ -12,43 +8,47 @@ h|*Class* h|*Description* 2+a|Definitions relating to the internal code system of archetypes. +NOTE: ADL2 was initially released with code system using id-codes (for nodes), at-codes (for values only) and ac-codes (for value sets). As this proved to hinder its widespread use in the openEHR community (due to its impact on existing openEHR RM data), a code system matching the one used in ADL1.4 was introduced as the openEHR primary code system. + +openEHR systems must support at least the at-coded ADL2 archetypes. + h|*Constants* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*At_code_leader*: `String{nbsp}={nbsp}"at"` +|*At_code_leader*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"at"` a|String leader of ‘identifier’ codes, i.e. codes used to identify at-coded archetype nodes. h|*1..1* -|*Id_code_leader*: `String{nbsp}={nbsp}"id"` +|*Id_code_leader*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"id"` a|String leader of ‘identifier’ codes, i.e. codes used to identify id-coded archetype nodes. h|*1..1* -|*Value_code_leader*: `String{nbsp}={nbsp}"at"` +|*Value_code_leader*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"at"` a|String leader of ‘value’ codes, i.e. codes used to identify codes values, including value set members. h|*1..1* -|*Value_set_code_leader*: `String{nbsp}={nbsp}"ac"` +|*Value_set_code_leader*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"ac"` a|String leader of ‘value set’ codes, i.e. codes used to identify value sets. h|*1..1* -|*Specialisation_separator*: `char{nbsp}={nbsp}'.'` +|*Specialisation_separator*: `link:/releases/BASE/{base_release}/foundation_types.html#_character_class[Character^]{nbsp}={nbsp}'.'` a|Character used to separate numeric parts of codes belonging to different specialisation levels. h|*1..1* -|*Code_regex_pattern*: `String{nbsp}={nbsp}"(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))*"` +|*Code_regex_pattern*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))*"` a|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. h|*1..1* -|*Root_code_regex_pattern*: `String{nbsp}={nbsp}"^(id1|at0000)(\.1)*$"` +|*Root_code_regex_pattern*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"^(id1|at0000)(\.1)*$"` a|Regex pattern of the root code of any archetype. Corresponds to at-codes of the form `at0000`, `at0000.1`, `at0000.1.1` etc, and id-codes of the form `id1`, `id1.1`, `id1.1.1` etc. For at-coded ADL2 numbering starts with zero (i.e. `at0000`) while the id-coded ADL2 numbering starts with one (i.e. `id1`). h|*1..1* -|*Primitive_node_id*: `String{nbsp}={nbsp}"at9999"` +|*Primitive_node_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]{nbsp}={nbsp}"at9999"` a|Code id used for `C_PRIMITIVE_OBJECT` nodes on creation. -NOTE: For id-coded archetypes this is `String{nbsp}={nbsp}"id9999"` +NOTE: For id-coded archetypes this is `"id9999"`. h|*Functions* ^h|*Signature* @@ -56,64 +56,64 @@ h|*Functions* h|*1..1* |*codes_conformant* ( + -a_child_code: `String[1]`, + -a_parent_code: `String[1]` + -): `Boolean` +a_child_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_parent_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|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_`? h|*1..1* |*is_adl_code* ( + -a_code: `String[1]` + -): `Boolean` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = is_at_code (a_code) or else is_id_code (a_code) or else is_value_code (a_code) or else is_value_set_code (a_code)` a|True if `_a_code_` is any kind of ADL archetype local code. h|*1..1* |*is_at_code* ( + -a_code: `String[1]` + -): `Boolean` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = a_code.starts_with (At_code_leader)` -a|True if `_a_code_` is an 'at' code. +a|True if `_a_code_` is an ‘at’ code. h|*1..1* |*is_id_code* ( + -a_code: `String[1]` + -): `Boolean` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = a_code.starts_with (Id_code_leader)` a|True if `_a_code_` is an 'id' code. h|*1..1* |*is_value_code* ( + -a_code: `String[1]` + -): `Boolean` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = a_code.starts_with (Value_code_leader)` -a|True if `_a_code_` is an 'at' code representing a single terminology item. +a|True if `_a_code_` is an 'at' code, i.e. a code representing a single terminology item. h|*1..1* |*is_value_set_code* ( + -a_code: `String[1]` + -): `Boolean` + +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = a_code.starts_with (Value_set_code_leader)` a|True if `_a_code_` is an 'ac' code, i.e. a code referring to a terminology value set. h|*1..1* |*is_redefined_code* ( + -a_code: `String[1]` + -): `Boolean` -a|A code has been specialised if there is a non-zero code index anywhere above the last index e.g. +a_code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|A code has been specialised if there is a non-zero code index anywhere above the last index e.g. * `at0.0.1` -> False * `at1.0.1` -> True h|*1..1* |*code_exists_at_level* ( + -a-code: `String[1]`, + -a_level: `Integer[1]` + -): `Boolean` +a-code: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +a_level: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|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. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.aom_profile.adoc b/docs/UML/classes/org.openehr.am.aom2.aom_profile.adoc index 4ee6bd3d..a76b1bcf 100644 --- a/docs/UML/classes/org.openehr.am.aom2.aom_profile.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.aom_profile.adoc @@ -17,11 +17,11 @@ h|*1..1* a|Name of this profile, usually based on the publisher it pertains to e.g. "openEHR", "CDISC", etc. h|*0..1* -|*archetype_parent_class*: `String` +|*archetype_parent_class*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|States a class from the Reference Model that provides archetyping capability in RM data structures. This attribute is optional, and there need be no such class in the RM. Defining it here has the effect in tools that the class tree under which archetypes are arranged contains only RM classes inheriting from this class. h|*0..1* -|*archetype_data_value_parent_class*: `String` +|*archetype_data_value_parent_class*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|This attribute defines a base class from the Reference Model whose descendants are considered to be 'logical data types', i.e. of some higher level than the built-in primitive types String, Integer etc. This attribute is optional, even if the RM does have such a class, and is only used to help tooling to provide more intelligent display. h|*0..1* @@ -33,18 +33,18 @@ h|*0..1* a|If `_archetype_parent_class_` is not set, designate a class whose descendants should be made visible in tree and grid renderings of the archetype definition. h|*0..1* -|*aom_rm_type_substitutions*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*aom_rm_type_substitutions*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a|Allowed type substitutions: Actual RM type names keyed by AOM built-in types which can substitute for them in an archetype. E.g. `` means that if RM property `TYPE._some_property_` is of type `String`, an `ISO8601_DATE` is allowed at that position in the archetype. h|*0..1* -|*aom_lifecycle_mappings*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` -a|List of mappings of lifecycle state names used in archetypes to AOM lifecycle state names: +|*aom_lifecycle_mappings*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +a|List of mappings of lifecycle state names used in archetypes to AOM lifecycle state names: -* key = source lifecycle state; +* key = source lifecycle state; * value = AOM lifecycle state. h|*0..1* -|*rm_primitive_type_equivalences*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*rm_primitive_type_equivalences*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a|Equivalences of RM primitive types to in-built set of primitive types. Used to determine which AOM `C_PRIMITIVE_OBJECT` descendant is used for a primitive type. Typical entries: * `value` `key` diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype.adoc index c2f8a5c8..5add02e4 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype.adoc @@ -6,7 +6,7 @@ h|*Class* 2+^h|*__ARCHETYPE (abstract)__* h|*Description* -2+a|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. +2+a|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. h|*Attributes* @@ -40,6 +40,7 @@ a|Rules relating to this archetype. Statements are expressed in first order pred h|*0..1* |*rm_overlay*: `<<_rm_overlay_class,RM_OVERLAY>>` a| + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype_constraint.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype_constraint.adoc index 52f4e8c0..1d08bf63 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype_constraint.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype_constraint.adoc @@ -22,6 +22,7 @@ a|Parent node, except in the case of the top of a tree, i.e. root `C_COMPLEX_OBJ h|*0..1* |*soc_parent*: `<<_c_second_order_class,C_SECOND_ORDER>>` a| + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -45,9 +46,9 @@ h|*1..1 + (abstract)* |*c_conforms_to* ( + other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + -): `Boolean` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. .Parameters + @@ -58,8 +59,8 @@ h|*1..1 + (abstract)* |*c_congruent_to* ( + other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]` + -): `Boolean` -a|True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. Typically used to test if an inherited node locally contains any constraints. @@ -76,4 +77,7 @@ a|True if this node is the root of the tree. h|*1..1* |*is_leaf* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if this node is a terminal node in the tree structure, i.e. having no child nodes. + +h|*Invariants* +2+a|__Post__: `Result = soc_parent /= Void or parent.soc_parent /= Void` |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype_hrid.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype_hrid.adoc index 06f1e3c1..6bf21752 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype_hrid.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype_hrid.adoc @@ -48,6 +48,7 @@ a|The status of the version, i.e.: h|*1..1* |*build_count*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The build count since last increment of any version part. + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype_slot.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype_slot.adoc index ce2d5341..0edee25f 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype_slot.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype_slot.adoc @@ -26,6 +26,7 @@ a|List of constraints defining other archetypes that cannot be included at this h|*1..1* |*is_closed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|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. + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype_term.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype_term.adoc index 0e3c2ab3..62fffbfd 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype_term.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype_term.adoc @@ -25,7 +25,6 @@ h|*1..1* a|Full description text. h|*0..1* -|*other_items*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*other_items*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a|Hash of keys and corresponding values for other items in a term, e.g. provenance. -Hash of keys ("text", "description" etc) and corresponding values. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.archetype_terminology.adoc b/docs/UML/classes/org.openehr.am.aom2.archetype_terminology.adoc index 5d8ffe07..3588d555 100644 --- a/docs/UML/classes/org.openehr.am.aom2.archetype_terminology.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.archetype_terminology.adoc @@ -25,11 +25,11 @@ h|*1..1* a|Term code defining the meaning of the artefact as a whole, and always used as the at-code (at-coded archetypes) or id-code (id-coded archetypes) on the root node of the artefact. Must be defined in the `_term_definitions_` property. h|*1..1* -|*term_definitions*: `Hash>>>` +|*term_definitions*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>>` a|Directory of term definitions as a two-level table. The outer hash keys are language codes, e.g. `"en"`, `"de"`, while the inner hash keys are term codes, e.g. `"at0017"`, `"at0004"` (at-coded archetypes) or `"id17"`, `"at4"` (id-coded archetypes). h|*0..1* -|*term_bindings*: `Hash >` +|*term_bindings*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` a|Directory of bindings to external terminology codes and value sets, as a two-level table. The outer hash keys are terminology ids, e.g. `"SNOMED_CT"`, and the inner hash keys are constraint codes, e.g. `"at0004"`, `"at4"`, "ac13"` or paths. The indexed `Uri` objects represent references to externally defined resources, either terms, ontology concepts, or terminology subsets / ref-sets. h|*1..1* @@ -41,8 +41,9 @@ h|*0..1* a|Archetype-local value sets, each keyed by value-set id, i.e. an ac-code. h|*0..1* -|*terminology_extracts*: `Hash>>>` +|*terminology_extracts*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>>` a|Directory of extracts of external terminologies, as a two-level table. The outer hash keys are terminology ids, e.g. `"SNOMED_CT"`, while the inner hash keys are term codes or code-phrases from the relevant terminology, e.g. `"10094842"`. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -74,7 +75,6 @@ h|*1..1* a_terminology_id: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if there are bindings to terminology `_a_terminology_id_` present. -True if terminology `a_terminology' is present in archetype ontology. h|*1..1* |*has_term_code* ( + diff --git a/docs/UML/classes/org.openehr.am.aom2.authored_archetype.adoc b/docs/UML/classes/org.openehr.am.aom2.authored_archetype.adoc index 06ea8400..4bc3bf8a 100644 --- a/docs/UML/classes/org.openehr.am.aom2.authored_archetype.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.authored_archetype.adoc @@ -32,7 +32,7 @@ h|*1..1* a|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. h|*1..1* -|*other_meta_data*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*other_meta_data*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a| h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom2.c_archetype_root.adoc b/docs/UML/classes/org.openehr.am.aom2.c_archetype_root.adoc index 53fa0b2b..c577bb3a 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_archetype_root.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_archetype_root.adoc @@ -8,7 +8,7 @@ h|*Class* h|*Description* 2+a|A specialisation of `C_COMPLEX_OBJECT` whose node_id attribute is an archetype identifier rather than the normal internal node code (i.e. at-code/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. +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. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_attribute.adoc b/docs/UML/classes/org.openehr.am.aom2.c_attribute.adoc index f45faf3a..c79b741b 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_attribute.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_attribute.adoc @@ -38,6 +38,7 @@ a|Cardinality constraint of attribute, if a container attribute. h|*1..1* |*is_multiple*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -69,7 +70,7 @@ other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = existence = Void and ((is_single and other.is_single) or (is_multiple and other.is_multiple and cardinality = Void))` -a|True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. +a|True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. Typically used to test if an inherited node locally contains any constraints. @@ -77,11 +78,11 @@ h|*1..1 + (effected)* |*c_conforms_to* ( + other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = existence_conforms_to (other) and ((is_single and other.is_single) or else (is_multiple and cardinality_conforms_to (other)))` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. h|*1..1 + diff --git a/docs/UML/classes/org.openehr.am.aom2.c_attribute_tuple.adoc b/docs/UML/classes/org.openehr.am.aom2.c_attribute_tuple.adoc index 59d431b5..a8420115 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_attribute_tuple.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_attribute_tuple.adoc @@ -23,6 +23,7 @@ h|*0..1 + (redefined)* |*members*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_c_attribute_class,C_ATTRIBUTE>>>` a|List of `C_ATTRIBUTEs` forming the definition of the tuple. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -31,7 +32,7 @@ h|*1..1 + (effected)* |*c_conforms_to* ( + other: `<<_c_attribute_tuple_class,C_ATTRIBUTE_TUPLE>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_boolean.adoc b/docs/UML/classes/org.openehr.am.aom2.c_boolean.adoc index 8f9737ae..9f5e0ef8 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_boolean.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_boolean.adoc @@ -17,30 +17,31 @@ h|*Attributes* h|*0..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Boolean constraint - a list of Boolean values. h|*0..1 + (redefined)* -|*assumed_value*: `Boolean` +|*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Assumed Boolean value. h|*0..1 + (redefined)* -|*default_value*: `Boolean` +|*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Default Boolean value. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*prototype_value* (): `Boolean` +|*prototype_value* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Prototype Boolean value. h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = constraint.is_empty` a|True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants. @@ -49,13 +50,13 @@ h|*1..1 + (effected)* |*c_value_conforms_to* ( + other: `<<_c_boolean_class,C_BOOLEAN>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`. h|*1..1 + (effected)* |*c_value_congruent_to* ( + other: `<<_c_boolean_class,C_BOOLEAN>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_complex_object.adoc b/docs/UML/classes/org.openehr.am.aom2.c_complex_object.adoc index a84b3627..ad002d4e 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_complex_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_complex_object.adoc @@ -22,24 +22,25 @@ a|List of constraints on attributes of the reference model type represented by t h|*0..1* |*attribute_tuples*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_c_attribute_tuple_class,C_ATTRIBUTE_TUPLE>>>` a|List of attribute tuple constraints under this object constraint, if any. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = attributes.is_empty and not is_prohibited` a|True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants. h|*1..1 + -(effected)* +(redefined)* |*c_conforms_to* ( + other: `<<_c_complex_object_class,C_COMPLEX_OBJECT>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. .Parameters + @@ -47,11 +48,11 @@ Typically used during validation of specialised archetype nodes. `_rmcc_`:: Reference Model conformance checker agent (lambda). h|*1..1 + -(effected)* +(redefined)* |*c_congruent_to* ( + other: `<<_c_complex_object_class,C_COMPLEX_OBJECT>>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. +a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. Typically used to test if an inherited node locally contains any constraints. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_complex_object_proxy.adoc b/docs/UML/classes/org.openehr.am.aom2.c_complex_object_proxy.adoc index 9d3d84e7..699e88ad 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_complex_object_proxy.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_complex_object_proxy.adoc @@ -6,7 +6,7 @@ h|*Class* 2+^h|*C_COMPLEX_OBJECT_PROXY* h|*Description* -2+a|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. +2+a|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. h|*Inherit* 2+|`<<_c_object_class,C_OBJECT>>` @@ -18,6 +18,7 @@ h|*Attributes* h|*1..1* |*target_path*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference to an object node using archetype path notation. + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom2.c_date.adoc b/docs/UML/classes/org.openehr.am.aom2.c_date.adoc index 27c52d7c..12a50d14 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_date.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_date.adoc @@ -6,7 +6,7 @@ h|*Class* 2+^h|*C_DATE* h|*Description* -2+a|Constraint on instances representing dates in the form either of a set of validity values, or else date ranges based on the `C_ORDERED` list constraint. +2+a|Constraint on instances representing dates in the form either of a set of validity values, or else date ranges based on the `C_ORDERED` list constraint. 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). @@ -25,14 +25,15 @@ a|Formal constraint on the assumed primitive `Iso8601_date` type, in the form of For a pattern constraint or no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_date_class[Iso8601_date^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_date_class[Iso8601_date^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -48,17 +49,17 @@ a|Validity of day in constrained date. h|*1..1 + (effected)* |*valid_pattern_constraint* ( + -a_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return `valid_iso8601_date_constraint_pattern (a_pattern)` h|*1..1 + (effected)* |*valid_pattern_constraint_replacement* ( + -a_pattern: `String[1]`, + -an_other_pattern: `String[1]` + -): `Boolean` -a|Return `valid_date_constraint_replacements.has(an_other_pattern.as_upper) and then +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +an_other_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|Return `valid_date_constraint_replacements.has(an_other_pattern.as_upper) and then valid_date_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom2.c_date_time.adoc b/docs/UML/classes/org.openehr.am.aom2.c_date_time.adoc index a8000d20..1e8894c4 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_date_time.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_date_time.adoc @@ -25,14 +25,15 @@ a|Formal constraint on the assumed primitive `Iso8601_date_time` type, in the fo For a pattern constraint or no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_date_time_class[Iso8601_date_time^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_date_time_class[Iso8601_date_time^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -40,17 +41,17 @@ h|*Functions* h|*1..1 + (effected)* |*valid_pattern_constraint* ( + -a_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return `valid_iso8601_date_time_constraint_pattern (a_pattern)` h|*1..1 + (effected)* |*valid_pattern_constraint_replacement* ( + -a_pattern: `String[1]`, + -an_other_pattern: `String[1]` + -): `Boolean` -a|Return `valid_date_time_constraint_replacements.has(an_other_pattern.as_upper) and then +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +an_other_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|Return `valid_date_time_constraint_replacements.has(an_other_pattern.as_upper) and then valid_date_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom2.c_defined_object.adoc b/docs/UML/classes/org.openehr.am.aom2.c_defined_object.adoc index d7bd4683..4298bc9b 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_defined_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_defined_object.adoc @@ -18,6 +18,7 @@ h|*Attributes* h|*0..1* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -31,7 +32,7 @@ h|*1..1 + (abstract)* |*valid_value* ( + a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^][1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_a_value_` is valid with respect to constraint expressed in concrete instance of this type. h|*1..1 + diff --git a/docs/UML/classes/org.openehr.am.aom2.c_duration.adoc b/docs/UML/classes/org.openehr.am.aom2.c_duration.adoc index dd75d0bb..6b88d4cb 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_duration.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_duration.adoc @@ -10,7 +10,7 @@ h|*Description* Both range and the constraint pattern can be set at the same time, corresponding to the ADL constraint `"PWD/|P0W..P50W|"`. -As for all of openEHR, two ISO 8601 exceptions are allowed: +As for all of openEHR, two ISO 8601 exceptions are allowed: * the ‘W’ (week) designator can be mixed in - the allowed patterns are: `P[Y|y][M|m][D|d][T[H|h][M|m][S|s]]` and `P[W|w]`; * the values used in an interval constraint may be negated, i.e. a leading minus (`'-'`) sign may be used. @@ -30,58 +30,59 @@ a|Formal constraint on the assumed primitive `Iso8601_duration` type, in the for For a pattern constraint or no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_duration_class[Iso8601_duration^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_duration_class[Iso8601_duration^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*years_allowed:* (): `Boolean` +|*years_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if years are allowed in the constrained Duration. h|*1..1* -|*months_allowed:* (): `Boolean` +|*months_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if months are allowed in the constrained Duration. h|*1..1* -|*weeks_allowed:* (): `Boolean` +|*weeks_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if weeks are allowed in the constrained Duration. h|*1..1* -|*days_allowed* (): `Boolean` +|*days_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if days are allowed in the constrained Duration. h|*1..1* -|*hours_allowed* (): `Boolean` +|*hours_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if hours are allowed in the constrained Duration. h|*1..1* -|*minutes_allowed* (): `Boolean` +|*minutes_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if minutes are allowed in the constrained Duration. h|*1..1* -|*seconds_allowed* (): `Boolean` +|*seconds_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if seconds are allowed in the constrained Duration. h|*1..1 + (effected)* |*valid_pattern_constraint* ( + -a_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return `valid_iso8601_duration_constraint_pattern (a_pattern)` h|*1..1 + (effected)* |*valid_pattern_constraint_replacement* ( + -a_pattern: `String[1]`, + -an_other_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +an_other_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return `valid_duration_constraint_replacement (a_pattern, an_other_pattern)`. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_integer.adoc b/docs/UML/classes/org.openehr.am.aom2.c_integer.adoc index 7bc14dae..0babea30 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_integer.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_integer.adoc @@ -23,12 +23,12 @@ a|Formal constraint on `Integer`, in the form of one or more `Interval` To represent no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_real_class[Real^]` a|Value to be assumed if none sent in data. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_object.adoc b/docs/UML/classes/org.openehr.am.aom2.c_object.adoc index 8676081e..c2eaa779 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_object.adoc @@ -30,8 +30,8 @@ a|Semantic identifier of this node, used to distinguish sibling nodes. All nodes 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. -h|*0..** -|*alternative_ids*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` +h|*0..1* +|*alternative_ids*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Additional identifiers of this node. openEHR archetypes can carry original ALD2 id-codes in this attribute and it can also carry human readable codes for future use. Alternative ids must be unique within the archetype. h|*0..1* @@ -41,6 +41,7 @@ a|True if this node and by implication all sub-nodes are deprecated for use. h|*0..1* |*sibling_order*: `<<_sibling_order_class,SIBLING_ORDER>>` a|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`. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -59,9 +60,9 @@ h|*1..1 + (effected)* |*c_conforms_to* ( + other: `<<_c_object_class,C_OBJECT>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. .Parameters + @@ -73,7 +74,7 @@ h|*1..1 + |*c_congruent_to* ( + other: `<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. +a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. Typically used to test if an inherited node locally contains any constraints. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_ordered.adoc b/docs/UML/classes/org.openehr.am.aom2.c_ordered.adoc index c01069f7..6983e73a 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_ordered.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_ordered.adoc @@ -21,7 +21,7 @@ h|*Attributes* h|*0..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]>` a|Constraint in the form of a List of Intervals of the parameter type T. Concrete types generated in descendants via template binding. h|*0..1 + @@ -33,13 +33,14 @@ h|*0..1 + (redefined)* |*assumed_value*: `T` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = constraint.is_empty` a|True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants. @@ -48,13 +49,13 @@ h|*1..1 + (effected)* |*c_value_conforms_to* ( + other: `<<_c_ordered_class,C_ORDERED>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_other.any_allowed_` or else for every constraint in the `_constraint_` list there is a constraint in `_other.constraint_` that contains it. h|*1..1 + (effected)* |*c_value_congruent_to* ( + other: `<<_c_ordered_class,C_ORDERED>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_primitive_object.adoc b/docs/UML/classes/org.openehr.am.aom2.c_primitive_object.adoc index 03b8b04a..98a0b955 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_primitive_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_primitive_object.adoc @@ -28,6 +28,7 @@ a|True if this object represents a constraint on an enumerated type from the ref h|*1..1* |*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_any_class[Any^]` a|Constraint represented by this object; redefine in descendants. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -41,12 +42,12 @@ h|*1..1* a|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. h|*1..1 + -(effected)* +(redefined)* |*c_conforms_to* ( + other: `<<_c_primitive_object_class,C_PRIMITIVE_OBJECT>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. +a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. .Parameters + @@ -61,11 +62,11 @@ other: `<<_c_primitive_object_class,C_PRIMITIVE_OBJECT>>[1]` + a|True if this node expresses a value constraint that conforms to that of `other`. Effected in descendants. h|*1..1 + -(effected)* +(redefined)* |*c_congruent_to* ( + other: `<<_c_primitive_object_class,C_PRIMITIVE_OBJECT>>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` -a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. +a|True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. Typically used to test if an inherited node locally contains any constraints. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_primitive_tuple.adoc b/docs/UML/classes/org.openehr.am.aom2.c_primitive_tuple.adoc index 38751fad..10e42169 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_primitive_tuple.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_primitive_tuple.adoc @@ -19,6 +19,7 @@ h|*1..1 + (redefined)* |*members*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_c_primitive_object_class,C_PRIMITIVE_OBJECT>>>` a|Object constraint members of this tuple group. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -27,7 +28,7 @@ h|*1..1 + (effected)* |*c_conforms_to* ( + other: `<<_c_primitive_tuple_class,C_PRIMITIVE_TUPLE>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_real.adoc b/docs/UML/classes/org.openehr.am.aom2.c_real.adoc index 2548fc49..6fb6add7 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_real.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_real.adoc @@ -23,12 +23,12 @@ a|Formal constraint on `Real`, in the form of one or more `Interval`. To represent no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_real_class[Real^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_real_class[Real^]` a|Value to be assumed if none sent in data. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_second_order.adoc b/docs/UML/classes/org.openehr.am.aom2.c_second_order.adoc index 4905a6c6..075a3612 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_second_order.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_second_order.adoc @@ -15,6 +15,7 @@ h|*Attributes* h|*0..1* |*members*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<<<_archetype_constraint_class,ARCHETYPE_CONSTRAINT>>>` a|Members of this second order constrainer. Normally redefined in descendants. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -23,7 +24,7 @@ h|*1..1 + (abstract)* |*c_conforms_to* ( + other: `<<_c_second_order_class,C_SECOND_ORDER>>[1]`, + -rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + +rmcc: `link:/releases/BASE/{base_release}/foundation_types.html#_function_class[FUNCTION^]>[1]` + ): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes. diff --git a/docs/UML/classes/org.openehr.am.aom2.c_string.adoc b/docs/UML/classes/org.openehr.am.aom2.c_string.adoc index 6e37a299..4e2c7a43 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_string.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_string.adoc @@ -17,10 +17,10 @@ h|*Attributes* h|*0..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|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. `/.*/`. +To represent no constraint, use an empty list, or alternatively, a regex 'any' pattern, i.e. `/.*/`. h|*0..1 + (redefined)* @@ -29,27 +29,28 @@ a|Default String value. h|*0..1 + (redefined)* -|*assumed_value*: `String` +|*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Assumed String value. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1 + (effected)* -|*prototype_value* (): `String` +|*prototype_value* (): `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| h|*1..1 + (effected)* |*valid_value* ( + -a_value: `String[1]` + -): `Boolean` +a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if a_value is valid with respect to constraint expressed in concrete instance of this type. h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = constraint.is_empty or else constraint.count = 1 and constraint.first.is_equal (Regex_any_string)` a|True if `_constraint_` is empty or else contains one String for the regex 'any' pattern. @@ -58,13 +59,13 @@ h|*1..1 + (effected)* |*c_value_conforms_to* ( + other: `<<_c_string_class,C_STRING>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`. h|*1..1 + (effected)* |*c_value_congruent_to* ( + other: `<<_c_string_class,C_STRING>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_temporal.adoc b/docs/UML/classes/org.openehr.am.aom2.c_temporal.adoc index c4e4d243..5c8e0e04 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_temporal.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_temporal.adoc @@ -16,8 +16,9 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*pattern_constraint*: `String` +|*pattern_constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -25,36 +26,36 @@ h|*Functions* h|*1..1 + (abstract)* |*valid_pattern_constraint* ( + -a_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_a_pattern_` is a valid constraint. Define in concrete descendants. h|*1..1 + (abstract)* |*valid_pattern_constraint_replacement* ( + -a_pattern: `String[1]`, + -an_other_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +an_other_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return True if `_a_pattern_` can be replaced by `_an_other_pattern_` in a specialised constraint. Define in concrete subtypes. h|*1..1 + -(effected)* -|*any_allowed* (): `Boolean` + +(redefined)* +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result = precursor and pattern_constraint.is_empty` a|True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants. h|*1..1 + -(effected)* +(redefined)* |*c_value_conforms_to* ( + other: `<<_c_ordered_class,C_ORDERED>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `precursor()` or else `_other.pattern_constraint_` is empty, or else `_pattern_constraint_` is a valid (narrower) replacement for `_other.pattern_constraint_`. h|*1..1 + -(effected)* +(redefined)* |*c_value_congruent_to* ( + other: `<<_c_ordered_class,C_ORDERED>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `precursor (other)` and `_pattern_constraint_ ~ _other.pattern_constraint_`, i.e. either both `Void` or else both non-`Void` and identical. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_temporal_definitions.adoc b/docs/UML/classes/org.openehr.am.aom2.c_temporal_definitions.adoc index a2a8cd31..50efe5ec 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_temporal_definitions.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_temporal_definitions.adoc @@ -13,7 +13,7 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*valid_date_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*valid_date_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of allowed date constraints. Contains the values: ``` @@ -26,7 +26,7 @@ a|List of allowed date constraints. Contains the values: ``` h|*1..1* -|*valid_date_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^], link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]>` +|*valid_date_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` a|List of allowed date constraint replacements e.g. in specialised archetype. Contains the values: ---- @@ -52,7 +52,7 @@ a|List of allowed date constraint replacements e.g. in specialised archetype. Co In the above, an empty list value indicates no replacements possible. h|*1..1* -|*valid_time_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*valid_time_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of allowed time constraints. Contains the values: ``` @@ -64,7 +64,7 @@ a|List of allowed time constraints. Contains the values: ``` h|*1..1* -|*valid_time_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^], link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]>` +|*valid_time_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` a|List of allowed time constraint replacements e.g. in specialised archetype. Contains the values: ---- @@ -86,7 +86,7 @@ a|List of allowed time constraint replacements e.g. in specialised archetype. Co In the above, an empty list value indicates no replacements possible. h|*1..1* -|*valid_date_time_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*valid_date_time_constraint_patterns*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of allowed date/time constraints. Contains the values: ``` @@ -99,7 +99,7 @@ a|List of allowed date/time constraints. Contains the values: ``` h|*1..1* -|*valid_date_time_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^], link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]>` +|*valid_date_time_constraint_replacements*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` a|List of allowed date/time constraint replacements e.g. in specialised archetype. Contains the values: ---- @@ -123,38 +123,39 @@ a|List of allowed date/time constraint replacements e.g. in specialised archetyp "YYYY-MM-DDTHH:??:??", "YYYY-MM-DDTHH:??:XX"] ---- + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* |*valid_duration_constraint_replacement* ( + -a_dur: `String[1]`, + -other_dur: `String[1]` + -): `Boolean` +a_dur: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +other_dur: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if ISO8601 duration string `_other_dur_` contains every character element in `_a_dur_`. For example: 'PYD' (period with year and days only) conforms to 'PYMD', but doesn't conform to 'PY'. h|*1..1* |*valid_iso8601_date_constraint_pattern* ( + -s: `String[1]` + -): `Boolean` +s: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if string literal like `"yyyy-MM-dd"` containing `"XX"` or `"??"` in `MM` or `dd` slots in pattern constraint is in `_valid_date_constraint_patterns_`. h|*1..1* |*valid_iso8601_time_constraint_pattern* ( + -s: `String[1]` + -): `Boolean` +s: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if string literal like `"hh:mm:ss[.ssss]"` containing `"XX"` or `"??"` in `mm` or `ss` slots in pattern constraint is in `_valid_time_constraint_patterns_`. h|*1..1* |*valid_iso8601_date_time_constraint_pattern* ( + -s: `String[1]` + -): `Boolean` +s: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if string literal in form `"yyyy-MM-dd hh:mm:ss[.ssss]"` containing `"XX"` or `"??"` in variable slots in pattern constraint is in `_valid_date_time_constraint_patterns_`. h|*1..1* |*valid_iso8601_duration_constraint_pattern* ( + -s: `String[1]` + -): `Boolean` +s: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if string in form `P[Y|y][M|m][W|w][D|d][T[H|h][M|m][S|s]]` (note: allowing 'W' to be mixed in is an openEHR deviation of ISO 8601). |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_terminology_code.adoc b/docs/UML/classes/org.openehr.am.aom2.c_terminology_code.adoc index ff1613e8..38903c0a 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_terminology_code.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_terminology_code.adoc @@ -22,21 +22,9 @@ h|*Attributes* ^h|*Signature* ^h|*Meaning* -h|*0..1* -|*constraint_status*: `<<_constraint_status_enumeration,CONSTRAINT_STATUS>>` -a|Constraint status of this terminology constraint. If Void, the meaning is as follows: - -* in a top-level archetype, equivalent to `required`; -* in a specialised (source) archetype, the meaning is to inherit the value from the corresponding node in the parent. - -In the case of a specialised archetype generated by flattening, the value of this field will be: - -* Void if it was Void in the parent; -* otherwise, it will carry the same value as in the parent. - h|*1..1 + (redefined)* -|*constraint*: `String` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Type of individual constraint - a single string that can either be a local at-code, or a local ac-code signifying a locally defined value set. If an ac-code, assumed_value may contain an at-code from the value set of the ac-code. Use an empty string for no constraint. @@ -50,22 +38,35 @@ h|*0..1 + (redefined)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_terminology_code_class[Terminology_code^]` a| + +h|*0..1* +|*constraint_status*: `<<_constraint_status_enumeration,CONSTRAINT_STATUS>>` +a|Constraint status of this terminology constraint. If Void, the meaning is as follows: + +* in a top-level archetype, equivalent to `required`; +* in a specialised (source) archetype, the meaning is to inherit the value from the corresponding node in the parent. + +In the case of a specialised archetype generated by flattening, the value of this field will be: + +* Void if it was Void in the parent; +* otherwise, it will carry the same value as in the parent. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*constraint_required* (): `Boolean` +|*constraint_required* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_constraint_status_` is defined and equals `required` OR if Void. I.e. in archetypes where `C_TERMINOLOGY_CODE` instances have no `_constraint_status_`, the `required` status is assumed, which applies to all legacy archetypes. h|*1..1* -|*effective_constraint_status* (): `Integer` +|*effective_constraint_status* (): `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` a|Return the effective integer value of the `_constraint_status_` field if it exists. If it is null, return 0, i.e. `required`. NOTE: the above logic applies to any `C_TERMINOLOGY_NODE` instance in a specialised archetype that redefines another such instance in the flat parent. I.e. no stated `_constraint_status_` means `required`. h|*0..1* -|*value_set_expanded* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*value_set_expanded* (): `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Effective set of at-code values corresponding to an ac-code for a locally defined value set. Not defined for ac-codes that have no local value set. h|*0..1* @@ -80,7 +81,7 @@ h|*1..1 + (effected)* |*valid_value* ( + a_value: `link:/releases/BASE/{base_release}/foundation_types.html#_terminology_code_class[Terminology_code^][1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if a `_value_` is valid with respect to constraint expressed in concrete instance of this type. h|*1..1 + @@ -90,7 +91,7 @@ a|A generated prototype value from this constraint object. h|*1..1 + (effected)* -|*any_allowed* (): `Boolean` + +|*any_allowed* (): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` + + __Post__: `Result := constraint.is_empty` a|True if `_constraint_` is empty. @@ -99,13 +100,13 @@ h|*1..1 + (effected)* |*c_value_conforms_to* ( + other: `<<_c_terminology_code_class,C_TERMINOLOGY_CODE>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`, and `_effective_constraint_status()_` is \<= `_other.effective_constraint_status()_`. h|*1..1 + (effected)* |*c_value_congruent_to* ( + other: `<<_c_terminology_code_class,C_TERMINOLOGY_CODE>>[1]` + -): `Boolean` +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if `_constraint_` and `_other.constraint_` are both value-set ids, and expand to identical value sets, or else are identical value codes; and `_effective_constraint_status()_` = `_other.effective_constraint_status()_`. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.c_time.adoc b/docs/UML/classes/org.openehr.am.aom2.c_time.adoc index b3f01dda..a816a191 100644 --- a/docs/UML/classes/org.openehr.am.aom2.c_time.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.c_time.adoc @@ -6,7 +6,7 @@ h|*Class* 2+^h|*C_TIME* h|*Description* -2+a|Constraint on instances representing times in the form either of a set of validity values, or else time ranges based on the `C_ORDERED` list constraint. +2+a|Constraint on instances representing times in the form either of a set of validity values, or else time ranges based on the `C_ORDERED` list constraint. 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). @@ -25,14 +25,15 @@ a|Formal constraint on the assumed primitive `Iso8601_time` type, in the form of For a pattern constraint or no constraint, use an empty list. h|*0..1 + -(redefined)* +(effected)* |*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_time_class[Iso8601_time^]` a|Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes. h|*0..1 + -(redefined)* +(effected)* |*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_iso8601_time_class[Iso8601_time^]` a|Value to be assumed if none sent in data. + h|*Functions* ^h|*Signature* ^h|*Meaning* @@ -56,17 +57,17 @@ a|Validity of timezone in constrained time. h|*1..1 + (effected)* |*valid_pattern_constraint* ( + -a_pattern: `String[1]` + -): `Boolean` +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Return `valid_iso8601_time_constraint_pattern (a_pattern)` h|*1..1 + (effected)* |*valid_pattern_constraint_replacement* ( + -a_pattern: `String[1]`, + -an_other_pattern: `String[1]` + -): `Boolean` -a|Return `valid_time_constraint_replacements.has(an_other_pattern.as_upper) and then +a_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]`, + +an_other_pattern: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` +a|Return `valid_time_constraint_replacements.has(an_other_pattern.as_upper) and then valid_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`. h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom2.constraint_status.adoc b/docs/UML/classes/org.openehr.am.aom2.constraint_status.adoc index 9f9b6ed6..259b9016 100644 --- a/docs/UML/classes/org.openehr.am.aom2.constraint_status.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.constraint_status.adoc @@ -8,29 +8,29 @@ h|*Enumeration* h|*Description* 2+a|Status of `_constraint_`, with values allowing for 'soft' constraints, which are effectively different kinds of suggestions. -h|*Attributes* +h|*Constants* ^h|*Signature* ^h|*Meaning* h| -|required +|*required*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]{nbsp}={nbsp}0` a|Data item is required to formally satisfy `_constraint_`. Enumeration value = 0. h| -|extensible +|*extensible*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]{nbsp}={nbsp}1` a|Data item value should satisfy `_constraint_`, i.e. a term in `_constraint_` is to be used if it covers the data item meaning (including more generally); if not, another code may be used, including from another terminology. Enumeration value = 1. h| -|preferred +|*preferred*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]{nbsp}={nbsp}2` a|Data item value is by preference one of the codes defined by `_constraint_`, but for local reasons may be another code, including from another terminology. Enumeration value = 2. h| -|example +|*example*: `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]{nbsp}={nbsp}3` a|The `_constraint_` code or value-set is considered purely as an example, and the data item may have any value. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.operational_template.adoc b/docs/UML/classes/org.openehr.am.aom2.operational_template.adoc index 83da43be..8279985c 100644 --- a/docs/UML/classes/org.openehr.am.aom2.operational_template.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.operational_template.adoc @@ -18,20 +18,23 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*component_terminologies*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` +|*component_terminologies*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` a|Compendium of flattened terminologies of archetypes referenced from this template, keyed by archetype identifier. This will almost always be present in a template. h|*0..1* -|*terminology_extracts*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` +|*terminology_extracts*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` a|Compendium of flattened terminology extracts (i.e. from external terminologies) from archetypes referenced from this template, keyed by archetype identifier. + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* |*component_terminology* ( + -an_id: `String[1]` + -): `<<_archetype_terminology_class,ARCHETYPE_TERMINOLOGY>>` +an_id: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^][1]` + +): `<<_archetype_terminology_class,ARCHETYPE_TERMINOLOGY>>` + + + +__Inv_is_specialised__: `is_specialised` a| h|*Invariants* diff --git a/docs/UML/classes/org.openehr.am.aom2.p_archetype.adoc b/docs/UML/classes/org.openehr.am.aom2.p_archetype.adoc index c73265fc..91c3e13b 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_archetype.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_archetype.adoc @@ -15,7 +15,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*parent_archetype_id*: `String` +|*parent_archetype_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Identifier of the specialisation parent of this archetype. h|*1..1* @@ -23,7 +23,7 @@ h|*1..1* a|Identifier of this archetype. h|*1..1* -|*is_differential*: `Boolean` +|*is_differential*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom2.p_archetype_hrid.adoc b/docs/UML/classes/org.openehr.am.aom2.p_archetype_hrid.adoc index d60a5ae2..88f24b54 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_archetype_hrid.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_archetype_hrid.adoc @@ -13,27 +13,27 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*namespace*: `String` +|*namespace*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reverse domain name namespace identifier. h|*1..1* -|*rm_publisher*: `String` +|*rm_publisher*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Name of the Reference Model publisher. h|*1..1* -|*rm_package*: `String` +|*rm_package*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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). h|*1..1* -|*rm_class*: `String` +|*rm_class*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Name of the root class of this archetype. h|*1..1* -|*concept_id*: `String` +|*concept_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The short concept name of the archetype as used in the multi-axial archetype_hrid. h|*1..1* -|*release_version*: `String` +|*release_version*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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. h|*1..1* @@ -41,6 +41,6 @@ h|*1..1* a|The status of the version, i.e. released, release_candidate etc. h|*1..1* -|*build_count*: `String` +|*build_count*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|The build count since last increment of any version part. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_archetype_slot.adoc b/docs/UML/classes/org.openehr.am.aom2.p_archetype_slot.adoc index d931cac9..ece4ca65 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_archetype_slot.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_archetype_slot.adoc @@ -16,14 +16,14 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*includes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<@@>` +|*includes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of constraints defining other archetypes that could be included at this point. h|*0..1* -|*excludes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]<@@>` +|*excludes*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|List of constraints defining other archetypes that cannot be included at this point. h|*1..1* -|*is_closed*: `Boolean` +|*is_closed*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_archetype_terminology.adoc b/docs/UML/classes/org.openehr.am.aom2.p_archetype_terminology.adoc index 045e0543..097f3700 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_archetype_terminology.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_archetype_terminology.adoc @@ -13,28 +13,28 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*is_differential*: `Boolean` +|*is_differential*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*1..1* -|*original_language*: `String` +|*original_language*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| h|*1..1* -|*term_definitions*: `Hash>>>` -a|Directory of term definitions as a two-level -table. The outer hash keys are term codes, -e.g. "at0004", and the inner hash key are term +|*term_definitions*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>>` +a|Directory of term definitions as a two-level +table. The outer hash keys are term codes, +e.g. "at0004", and the inner hash key are term attribute names, e.g. "text", "description" etc. h|*0..1* -|*term_bindings*: `Hash >` -a|Directory of term bindings as a two-level -table. The outer hash keys are local term codes, -e.g. "at0004", and the inner hash keys are terminology +|*term_bindings*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` +a|Directory of term bindings as a two-level +table. The outer hash keys are local term codes, +e.g. "at0004", and the inner hash keys are terminology code phrases, e.g. "SNOMED(2003)::163034007" etc. h|*0..1* -|*value_sets*: `Hash>>` +|*value_sets*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_authored_archetype.adoc b/docs/UML/classes/org.openehr.am.aom2.p_authored_archetype.adoc index a2fb1f0c..72a862e6 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_authored_archetype.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_authored_archetype.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*adl_version*: `String` +|*adl_version*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|ADL version if archteype was read in from an ADL sharable archetype. h|*1..1* @@ -24,14 +24,14 @@ h|*1..1* a|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. h|*1..1* -|*rm_release*: `String` +|*rm_release*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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. h|*1..1* -|*is_generated*: `Boolean` +|*is_generated*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|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. h|*1..1* -|*other_meta_data*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` +|*other_meta_data*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_authored_resource.adoc b/docs/UML/classes/org.openehr.am.aom2.p_authored_resource.adoc index 9cf9023a..e1917e23 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_authored_resource.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_authored_resource.adoc @@ -13,11 +13,11 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*original_language*: `String` +|*original_language*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Language in which this resource was initially authored. Although there is no language primacy of resources overall, the language of original authoring is required to ensure natural language translations can preserve quality. Language is relevant in both the description and ontology sections. h|*0..1* -|*is_controlled*: `Boolean` +|*is_controlled*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if this resource is under any kind of change control (even file copying), in which case revision history is created. h|*0..1* @@ -29,10 +29,10 @@ h|*0..1* a|Description and lifecycle information of the resource. h|*0..1* -|*uid*: `String` +|*uid*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Unique identifier of the family of archetypes having the same interface identifier (same major version). h|*0..1* -|*annotations*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` +|*annotations*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>` a|Annotations on individual items within the resource, keyed by path. The inner table takes the form of a Hash table of String values keyed by String tags. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_archetype_root.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_archetype_root.adoc index de24b3c5..c95cf773 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_archetype_root.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_archetype_root.adoc @@ -5,9 +5,6 @@ h|*Class* 2+^h|*P_C_ARCHETYPE_ROOT* -h|*Description* -2+a| - h|*Inherit* 2+|`<<_p_c_complex_object_class,P_C_COMPLEX_OBJECT>>` @@ -16,6 +13,6 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*archetype_ref*: `String` +|*archetype_ref*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_attribute.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_attribute.adoc index be49d55d..d42e25dc 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_attribute.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_attribute.adoc @@ -16,11 +16,11 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*rm_attribute_name*: `String` +|*rm_attribute_name*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference model attribute within the enclosing type represented by a C_OBJECT. h|*0..1* -|*existence*: `String` +|*existence*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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). h|*0..1* @@ -28,14 +28,14 @@ h|*0..1* a|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. h|*0..1* -|*differential_path*: `String` +|*differential_path*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Within a differential specialised archetype, may be set to represent a deep path within the structure to which this constraint and its child constraints apply. h|*0..1* -|*cardinality*: `String` +|*cardinality*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Cardinality constraint of attribute, if a container attribute. h|*1..1* -|*is_multiple*: `Boolean` +|*is_multiple*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_attribute_tuple.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_attribute_tuple.adoc index c657f807..5519386e 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_attribute_tuple.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_attribute_tuple.adoc @@ -6,13 +6,13 @@ h|*Class* 2+^h|*P_C_ATTRIBUTE_TUPLE* h|*Description* -2+a|Object representing a constraint on an atttribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like {units, range} constraints. +2+a|Object representing a constraint on an atttribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like \{units, range} constraints. h|*Attributes* ^h|*Signature* ^h|*Meaning* h|*0..1* -|*members*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*members*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|Member attribute constraint objects. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_boolean.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_boolean.adoc index 6cd29e98..32de8f09 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_boolean.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_boolean.adoc @@ -17,16 +17,16 @@ h|*Attributes* h|*0..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a| h|*0..1 + (redefined)* -|*assumed_value*: `Boolean` +|*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*1..1 + (redefined)* -|*default_value*: `Boolean` +|*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_complex_object_proxy.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_complex_object_proxy.adoc index a738e12e..1007100e 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_complex_object_proxy.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_complex_object_proxy.adoc @@ -6,7 +6,7 @@ h|*Class* 2+^h|*P_C_COMPLEX_OBJECT_PROXY* h|*Description* -2+a|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 COJMPLEX_OBJECT_PROXY should always be used; when setting this from a seri- alised 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. +2+a|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 COJMPLEX_OBJECT_PROXY should always be used; when setting this from a seri- alised 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. h|*Inherit* 2+|`<<_p_c_object_class,P_C_OBJECT>>` @@ -16,6 +16,6 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*target_path*: `String` +|*target_path*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference to an object node using archetype path notation. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_defined_object.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_defined_object.adoc index 4858b96b..e948d379 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_defined_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_defined_object.adoc @@ -16,7 +16,7 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*is_frozen*: `Boolean` +|*is_frozen*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_duration.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_duration.adoc index 4a282f84..9ab5b3eb 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_duration.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_duration.adoc @@ -5,7 +5,4 @@ h|*Class* 2+^h|*P_C_DURATION* -h|*Description* -2+a| - |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_object.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_object.adoc index f8082621..d2df6cca 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_object.adoc @@ -16,25 +16,26 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*rm_type_name*: `String` +|*rm_type_name*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Reference model type that this node corresponds to. h|*0..1* -|*occurrences*: `String` +|*occurrences*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|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. h|*1..1* -|*node_id*: `String` +|*node_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Semantic id of this node, used to differentiate sibling nodes of the same type. Each node_id must be defined in the archetype ontology as a term code. h|*0..1* -|*is_deprecated*: `Boolean` +|*is_deprecated*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a| + h|*Functions* ^h|*Signature* ^h|*Meaning* h|*1..1* -|*specialisation_depth* (): `Integer` +|*specialisation_depth* (): `link:/releases/BASE/{base_release}/foundation_types.html#_integer_class[Integer^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_ordered.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_ordered.adoc index 850cdf89..34677aea 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_ordered.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_ordered.adoc @@ -21,6 +21,6 @@ h|*Attributes* h|*1..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]>` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_primitive_object.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_primitive_object.adoc index c8b2e4e7..c7701ad4 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_primitive_object.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_primitive_object.adoc @@ -20,7 +20,7 @@ h|*0..1* a|Value to be assumed if none sent in data. h|*0..1* -|*is_enumerated_type_constraint*: `Boolean` +|*is_enumerated_type_constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_boolean_class[Boolean^]` a|True if this constraint is actually of an enumerated type that conforms to a primitive type, not a primitive. h|*1..1* diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_string.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_string.adoc index 355a5d14..6acd89fb 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_string.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_string.adoc @@ -17,16 +17,16 @@ h|*Attributes* h|*1..1 + (redefined)* -|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_list_class[List^]` a|String constraint - a list of literal strings and / or regular expression strings delimited by the ‘/’ character. h|*1..1 + (redefined)* -|*default_value*: `String` +|*default_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| h|*0..1 + (redefined)* -|*assumed_value*: `String` +|*assumed_value*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_temporal.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_temporal.adoc index da27ff22..c4d17a59 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_temporal.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_temporal.adoc @@ -16,6 +16,6 @@ h|*Attributes* ^h|*Meaning* h|*1..1* -|*pattern_constraint*: `String` +|*pattern_constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.p_c_terminology_code.adoc b/docs/UML/classes/org.openehr.am.aom2.p_c_terminology_code.adoc index b036f9a6..fb76d455 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_c_terminology_code.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_c_terminology_code.adoc @@ -21,7 +21,7 @@ h|*Attributes* h|*1..1 + (redefined)* -|*constraint*: `String` +|*constraint*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a| h|*0..1 + diff --git a/docs/UML/classes/org.openehr.am.aom2.p_operational_template.adoc b/docs/UML/classes/org.openehr.am.aom2.p_operational_template.adoc index b8bc59d6..49d0148d 100644 --- a/docs/UML/classes/org.openehr.am.aom2.p_operational_template.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.p_operational_template.adoc @@ -18,10 +18,10 @@ h|*Attributes* ^h|*Meaning* h|*0..1* -|*component_terminologies*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` +|*component_terminologies*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>` a|Compendium of flattened terminologies of archetypes externally referenced from this archetype, keyed by archetype identifier. This will almost always be present in a template. h|*0..1* -|*terminology_extracts*: `Hash>>>` +|*terminology_extracts*: `link:/releases/BASE/{base_release}/foundation_types.html#_hash_class[Hash^]>>>` a|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. |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.rm_attribute_visibility.adoc b/docs/UML/classes/org.openehr.am.aom2.rm_attribute_visibility.adoc index 96a2f46c..aff20567 100644 --- a/docs/UML/classes/org.openehr.am.aom2.rm_attribute_visibility.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.rm_attribute_visibility.adoc @@ -19,4 +19,7 @@ a|Visibility setting of a non-archetyped RM attribute (RM attributes that are co h|*0..1* |*alias*: `link:/releases/BASE/{base_release}/foundation_types.html#_terminology_code_class[Terminology_code^]` a|Optional alias for the attribute referenced by the path. + +h|*Invariants* +2+a|__Inv_alias_validity__: `alias /= Void implies visibility /= Void` |=== diff --git a/docs/UML/classes/org.openehr.am.aom2.sibling_order.adoc b/docs/UML/classes/org.openehr.am.aom2.sibling_order.adoc index f61d8974..11fb5ccc 100644 --- a/docs/UML/classes/org.openehr.am.aom2.sibling_order.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.sibling_order.adoc @@ -21,6 +21,7 @@ a|True if the order relationship is ‘before’, if False, it is ‘after’. h|*1..1* |*sibling_node_id*: `link:/releases/BASE/{base_release}/foundation_types.html#_string_class[String^]` a|Node identifier of sibling before or after which this node should come. + h|*Functions* ^h|*Signature* ^h|*Meaning* diff --git a/docs/UML/classes/org.openehr.am.aom2.t.adoc b/docs/UML/classes/org.openehr.am.aom2.t.adoc deleted file mode 100644 index 2aab6245..00000000 --- a/docs/UML/classes/org.openehr.am.aom2.t.adoc +++ /dev/null @@ -1,11 +0,0 @@ -=== T Class - -[cols="^1,3,5"] -|=== -h|*Class* -2+^h|*T* - -h|*Description* -2+a| - -|=== diff --git a/docs/UML/classes/org.openehr.am.aom2.visibility_type.adoc b/docs/UML/classes/org.openehr.am.aom2.visibility_type.adoc index ad706af3..b573900a 100644 --- a/docs/UML/classes/org.openehr.am.aom2.visibility_type.adoc +++ b/docs/UML/classes/org.openehr.am.aom2.visibility_type.adoc @@ -8,7 +8,7 @@ h|*Enumeration* h|*Description* 2+a|Enumeration of visibility settings for model elements. -h|*Attributes* +h|*Constants* ^h|*Signature* ^h|*Meaning*