bmm_version = <"2.4"> rm_publisher = <"openehr"> schema_name = <"lang"> rm_release = <"1.1.0"> schema_revision = <"1.1.0.2"> schema_lifecycle_state = <"stable"> schema_description = <"lang"> schema_author = <"Thomas Beale , code-generator"> includes = < ["openehr_base_1.3.0"] = < id = <"openehr_base_1.3.0"> > > packages = < ["org.openehr.lang.bmm3"] = < name = <"org.openehr.lang.bmm3"> classes = <"BMM_DEFINITIONS", ...> packages = < ["model_access"] = < name = <"model_access"> classes = <"BMM_MODEL_ACCESS", "BMM_SCHEMA_DESCRIPTOR", "BMM_SCHEMA", "BMM_INCLUDE_SPEC", "BMM_SCHEMA_METADATA_KEY", "BMM_SCHEMA_STATE"> > ["core"] = < name = <"core"> classes = <"BMM_MODEL_ELEMENT", "BMM_FORMAL_ELEMENT"> packages = < ["entity"] = < name = <"entity"> classes = <"BMM_CLASS", "BMM_CONTAINER_TYPE", "BMM_EFFECTIVE_TYPE", "BMM_MODEL_TYPE", "BMM_GENERIC_CLASS", "BMM_GENERIC_TYPE", "BMM_PARAMETER_TYPE", "BMM_TUPLE_TYPE", "BMM_TYPE", "BMM_SIMPLE_CLASS", "BMM_SIMPLE_TYPE", "BMM_UNITARY_TYPE", "BMM_INDEXED_CONTAINER_TYPE", "BMM_SIGNATURE", "BMM_MODULE", "BMM_STATUS_TYPE", "BMM_BUILTIN_TYPE", "BMM_PROCEDURE_TYPE", "BMM_FUNCTION_TYPE", "BMM_ROUTINE_TYPE", "BMM_PROPERTY_TYPE", "BMM_ENTITY_METATYPE"> packages = < ["range_constrained"] = < name = <"range_constrained"> classes = <"BMM_VALUE_SET_SPEC", "BMM_ENUMERATION", "BMM_ENUMERATION_INTEGER", "BMM_ENUMERATION_STRING"> > > > ["feature"] = < name = <"feature"> classes = <"BMM_CONSTANT", "BMM_CONTAINER_PROPERTY", "BMM_FUNCTION", "BMM_LOCAL", "BMM_OPERATOR", "BMM_PROPERTY", "BMM_ROUTINE", "BMM_PARAMETER", "BMM_VARIABLE", "BMM_PROCEDURE", "BMM_UNITARY_PROPERTY", "BMM_INDEXED_CONTAINER_PROPERTY", "BMM_INSTANTIABLE_FEATURE", "BMM_RESULT", "BMM_FEATURE_EXTENSION", "BMM_ROUTINE_DEFINITION", "BMM_EXTERNAL_ROUTINE", "BMM_FEATURE_GROUP", "BMM_VISIBILITY", "BMM_FEATURE", "BMM_SELF", "BMM_WRITABLE_VARIABLE", "BMM_READONLY_VARIABLE", "BMM_SINGLETON", "BMM_STATIC", "BMM_LOCAL_ROUTINE", "BMM_OPERATOR_POSITION", "BMM_PARAMETER_DIRECTION"> > ["literal_value"] = < name = <"literal_value"> classes = <"BMM_INTEGER_VALUE", "BMM_STRING_VALUE", "BMM_LITERAL_VALUE", "BMM_BOOLEAN_VALUE", "BMM_PRIMITIVE_VALUE", "BMM_CONTAINER_VALUE", "BMM_UNITARY_VALUE", "BMM_INDEXED_CONTAINER_VALUE", "BMM_INTERVAL_VALUE"> > ["model"] = < name = <"model"> classes = <"BMM_MODEL", "BMM_MODEL_METADATA", "BMM_PACKAGE", "BMM_PACKAGE_CONTAINER"> > > > ["expression"] = < name = <"expression"> classes = <"EL_BINARY_OPERATOR", "EL_EXPRESSION", "EL_LITERAL", "EL_OPERATOR", "EL_UNARY_OPERATOR", "EL_PROPERTY_REF", "EL_PREDICATE", "EL_DEFINED", "EL_FUNCTION_CALL", "EL_AGENT_CALL", "EL_AGENT", "EL_TUPLE_ITEM", "EL_PROCEDURE_AGENT", "EL_TUPLE", "EL_FUNCTION_AGENT", "EL_ATTACHED", "EL_VALUE_GENERATOR", "EL_BOOLEAN_EXPRESSION", "EL_TYPE_REF", "EL_FEATURE_REF", "EL_CONDITIONAL_EXPRESSION", "EL_CONDITION_CHAIN", "EL_CONSTRAINED", "EL_CASE_TABLE", "EL_CASE", "EL_DECISION_TABLE", "EL_DECISION_BRANCH", "EL_VARIABLE", "EL_TERMINAL", "EL_SIMPLE", "EL_STATIC_REF", "EL_WRITABLE_VARIABLE", "EL_READONLY_VARIABLE"> > ["statement"] = < name = <"statement"> classes = <"BMM_ACTION_DECISION_TABLE", "BMM_ACTION_TABLE", "BMM_ASSIGNMENT", "BMM_ASSERTION", "BMM_PROCEDURE_CALL", "BMM_STATEMENT_ITEM", "BMM_STATEMENT", "BMM_STATEMENT_BLOCK", "BMM_SIMPLE_STATEMENT", "BMM_DECLARATION"> > > > > class_definitions = < ["BMM_DEFINITIONS"] = < name = <"BMM_DEFINITIONS"> documentation = <"Definitions used by all BMM packages."> ancestors = <"BASIC_DEFINITIONS", ...> constants = < ["Bmm_internal_version"] = < name = <"Bmm_internal_version"> documentation = <"Current internal version of BMM meta-model, used to determine if a given schema can be processed by a given implementation of the model."> type = <"String"> > ["Schema_name_delimiter"] = < name = <"Schema_name_delimiter"> documentation = <"Delimiter used to separate schema id from package path in a fully qualified path."> type = <"String"> value = <"\"::\""> > ["Package_name_delimiter"] = < name = <"Package_name_delimiter"> documentation = <"Delimiter used to separate package names in a package path."> type = <"String"> value = <"\".\""> > ["Bmm_schema_file_extension"] = < name = <"Bmm_schema_file_extension"> documentation = <"Extension used for BMM files."> type = <"String"> value = <"\".bmm\""> > ["Type_delimiter"] = < name = <"Type_delimiter"> documentation = <"Appears between a name and a type in a declaration or type signature."> type = <"Character"> value = <"':'"> > ["Generic_left_delimiter"] = < name = <"Generic_left_delimiter"> documentation = <"Left delimiter for generic class and generic type names, as used in `List`."> type = <"Character"> value = <"'<'"> > ["Generic_right_delimiter"] = < name = <"Generic_right_delimiter"> documentation = <"Right delimiter for generic class and generic type names, as used in `List`."> type = <"Character"> value = <"'>'"> > ["Generic_separator"] = < name = <"Generic_separator"> documentation = <"Separator used in Generic types."> type = <"Character"> value = <"','"> > ["Generic_constraint_delimiter"] = < name = <"Generic_constraint_delimiter"> documentation = <"Delimiter between formal type parameter and constraint type, as used in `Sortable`."> type = <"Character"> value = <"':'"> > ["Tuple_left_delim"] = < name = <"Tuple_left_delim"> documentation = <"Left delimiter of a Tuple type and also instance. Example: * `[Integer, String]` - a tuple type; * `[3, \"Quixote\"]` - a tuple."> type = <"Character"> value = <"'['"> > ["Tuple_right_delim"] = < name = <"Tuple_right_delim"> documentation = <"Right delimiter of a Tuple type and also instance."> type = <"Character"> value = <"']'"> > ["Tuple_separator"] = < name = <"Tuple_separator"> documentation = <"Separator used in Tuple types and instances."> type = <"Character"> value = <"','"> > ["Constraint_left_delim"] = < name = <"Constraint_left_delim"> documentation = <"Left delimiter used in serial form of instance constrained enumeration."> type = <"Character"> value = <"'«'"> > ["Constraint_right_delim"] = < name = <"Constraint_right_delim"> documentation = <"Right delimiter used in serial form of instance constrained enumeration."> type = <"Character"> value = <"'»'"> > ["Metadata_bmm_version"] = < name = <"Metadata_bmm_version"> documentation = <"Attribute name of logical attribute 'bmm_version' in .bmm schema file."> type = <"String"> value = <"\"bmm_version\""> > ["Metadata_schema_name"] = < name = <"Metadata_schema_name"> documentation = <"Attribute name of logical attribute 'schema_name' in .bmm schema file."> type = <"String"> value = <"\"schema_name\""> > ["Metadata_rm_publisher"] = < name = <"Metadata_rm_publisher"> documentation = <"Attribute name of logical attribute 'rm_publisher' in .bmm schema file."> type = <"String"> value = <"\"rm_publisher\""> > ["Metadata_rm_release"] = < name = <"Metadata_rm_release"> documentation = <"Attribute name of logical attribute 'rm_release' in .bmm schema file."> type = <"String"> value = <"\"rm_release\""> > ["Metadata_schema_revision"] = < name = <"Metadata_schema_revision"> documentation = <"Attribute name of logical attribute 'schema_revision' in .bmm schema file."> type = <"String"> value = <"\"schema_revision\""> > ["Metadata_schema_lifecycle_state"] = < name = <"Metadata_schema_lifecycle_state"> documentation = <"Attribute name of logical attribute 'schema_lifecycle_state' in .bmm schema file."> type = <"String"> value = <"\"schema_lifecycle_state\""> > ["Metadata_schema_description"] = < name = <"Metadata_schema_description"> documentation = <"Attribute name of logical attribute 'schema_description' in .bmm schema file."> type = <"String"> value = <"\"schema_description\""> > ["Metadata_schema_path"] = < name = <"Metadata_schema_path"> documentation = <"Path of schema file."> type = <"String"> value = <"\"schema_path\""> > > functions = < ["Any_class"] = < name = <"Any_class"> documentation = <"built-in class definition corresponding to the top `Any' class."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_CLASS"> > > ["Any_type"] = < name = <"Any_type"> documentation = <"Built-in type definition corresponding to the top `Any' type."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_TYPE"> > > ["create_schema_id"] = < name = <"create_schema_id"> documentation = <"Create schema id, formed from: `a_model_publisher '-' a_schema_name '-' a_model_release` e.g. `openehr_rm_1.0.3`, `openehr_test_1.0.1`, `iso_13606_1_2008_2.1.2`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > parameters = < ["a_model_publisher"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_model_publisher"> type = <"Any"> > ["a_schema_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_schema_name"> type = <"Any"> > ["a_model_release"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_model_release"> type = <"String"> > > > > > ["BMM_MODEL_ACCESS"] = < name = <"BMM_MODEL_ACCESS"> documentation = <"Access to BMM models that have been loaded and validated from one or more schema sets."> properties = < ["schema_directories"] = (P_BMM_CONTAINER_PROPERTY) < name = <"schema_directories"> documentation = <"List of directories where all the schemas loaded here are found."> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> > ["all_schemas"] = (P_BMM_GENERIC_PROPERTY) < name = <"all_schemas"> documentation = <"All schemas found and loaded from `_schema_directory_`. Keyed by `_schema_id_`."> type_def = < generic_parameters = <"String", "BMM_SCHEMA_DESCRIPTOR"> root_type = <"Hash"> > > ["bmm_models"] = (P_BMM_GENERIC_PROPERTY) < name = <"bmm_models"> documentation = <"Top-level (root) models in use, keyed by `_model_id_`."> type_def = < generic_parameters = <"String", "BMM_MODEL"> root_type = <"Hash"> > > ["matching_bmm_models"] = (P_BMM_GENERIC_PROPERTY) < name = <"matching_bmm_models"> documentation = <"Validated models, keyed by `_model_id()_` and any shorter forms of id, with some or no versioning information. For example, the keys `\"openEHR_EHR_1.0.4\"`, `\"openEHR_EHR_1.0\"`, `\"openEHR_EHR_1\"`, and `\"openEHR_EHR\"` will all match the `\"openEHR_EHR_1.0.4\"` model, assuming it is the most recent version available."> type_def = < generic_parameters = <"String", "BMM_MODEL"> root_type = <"Hash"> > > > functions = < ["initialise_with_load_list"] = < name = <"initialise_with_load_list"> documentation = <"Initialise with a specific schema load list, usually a sub-set of schemas that will be found in a specified directories `_a_schema_dirs_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > parameters = < ["a_schema_dirs"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) < name = <"a_schema_dirs"> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=1|> > ["a_schema_load_list"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) < name = <"a_schema_load_list"> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> is_nullable = > > > ["initialise_all"] = < name = <"initialise_all"> documentation = <"Load all schemas found in a specified directories `_a_schema_dirs_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > parameters = < ["a_schema_dirs"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) < name = <"a_schema_dirs"> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=1|> > > > ["reload_schemas"] = < name = <"reload_schemas"> documentation = <"Reload BMM schemas."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > > ["bmm_model"] = < name = <"bmm_model"> documentation = <"Return model containing the model key which is a `_model_id_` or any shorter form e.g. model id minus the version. If a shorter key is used, the `BMM_MODEL` with the most recent version will be selected. Uses `_matching_bmm_models_` table to find matches if partial version information is supplied in key."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_MODEL"> > parameters = < ["a_model_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_model_key"> type = <"String"> > > > ["has_bmm_model"] = < name = <"has_bmm_model"> documentation = <"True if a model for a `_model_key_` is available. A model key is a `_model_id_` or any shorter form e.g. model id minus the version. If a shorter key is used, the Result s True if a `BMM_MODEL` with any version exists."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_model_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_model_key"> type = <"String"> > > > > > ["BMM_SCHEMA_DESCRIPTOR"] = < name = <"BMM_SCHEMA_DESCRIPTOR"> documentation = <"Descriptor for a BMM schema. Contains a meta-data table of attributes obtained from a mini-ODIN parse of the schema file."> is_abstract = properties = < ["bmm_schema"] = (P_BMM_SINGLE_PROPERTY) < name = <"bmm_schema"> documentation = <"Persistent form of model."> type = <"BMM_SCHEMA"> > ["bmm_model"] = (P_BMM_SINGLE_PROPERTY) < name = <"bmm_model"> documentation = <"Computable form of model."> type = <"BMM_MODEL"> > ["schema_id"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_id"> documentation = <"Schema id, formed by `{BMM_DEFINITIONS}.create_schema_id( meta_data.item({BMM_DEFINITIONS}.Metadata_model_publisher), meta_data.item({BMM_DEFINITIONS}.Metadata_schema_name), meta_data.item({BMM_DEFINITIONS}.Metadata_model_release)` e.g. `openehr_rm_1.0.3`, `openehr_test_1.0.1`, `iso_13606_1_2008_2.1.2`."> is_mandatory = type = <"String"> > ["meta_data"] = (P_BMM_GENERIC_PROPERTY) < name = <"meta_data"> documentation = <"Table of `{key, value}` of schema meta-data, keys are string values defined by `{BMM_DEFINITIONS}.Metadata_*` constants."> is_mandatory = type_def = < generic_parameters = <"String", "String"> root_type = <"Hash"> > > ["includes"] = (P_BMM_CONTAINER_PROPERTY) < name = <"includes"> documentation = <"Identifiers of schemas included by this schema."> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> > > functions = < ["is_top_level"] = < name = <"is_top_level"> documentation = <"True if this is a top-level schema, i.e. is the root schema of a 'model'. True if `_bmm_schema_ /= Void and then _bmm_schema.model_name_ /= Void`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["is_bmm_compatible"] = < name = <"is_bmm_compatible"> documentation = <"True if the BMM version found in the schema (or assumed, if none) is compatible with that in this software."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["load"] = < name = <"load"> documentation = <"Load schema into in-memory form, i.e. a `P_BMM_SCHEMA` instance, if structurally valid. If successful, `_p_schema_` will be set."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > > ["validate_merged"] = < name = <"validate_merged"> documentation = <"Validate loaded schema and report errors."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > > ["validate_includes"] = < name = <"validate_includes"> documentation = <"Validate includes list for this schema, to see if each mentioned schema exists in `_all_schemas_` list."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > parameters = < ["all_schemas_list"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) < name = <"all_schemas_list"> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> is_nullable = > > > ["create_model"] = < name = <"create_model"> documentation = <"Create `schema`, i.e. the `BMM_MODEL` from one `P_BMM_SCHEMA` schema."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > > > > ["BMM_SCHEMA"] = < name = <"BMM_SCHEMA"> documentation = <"Abstract parent of any persistable form of a BMM model, e.g. `P_BMM_SCHEMA`."> ancestors = <"BMM_MODEL_METADATA", ...> is_abstract = properties = < ["bmm_version"] = (P_BMM_SINGLE_PROPERTY) < name = <"bmm_version"> documentation = <"Version of BMM model, enabling schema evolution reasoning. Persisted attribute."> is_mandatory = type = <"String"> > ["includes"] = (P_BMM_GENERIC_PROPERTY) < name = <"includes"> documentation = <"Inclusion list of any form of BMM model, in the form of a hash of individual include specifications, each of which at least specifies the id of another schema, and may specify a namespace via which types from the included schemas are known in this schema. Persisted attribute."> type_def = < generic_parameters = <"String", "BMM_INCLUDE_SPEC"> root_type = <"Hash"> > > ["bmm_model"] = (P_BMM_SINGLE_PROPERTY) < name = <"bmm_model"> documentation = <"Generated by `_create_bmm_model_` from persisted elements."> type = <"BMM_MODEL"> > ["state"] = (P_BMM_SINGLE_PROPERTY) < name = <"state"> documentation = <"Current processing state."> is_mandatory = type = <"BMM_SCHEMA_STATE"> > ["model_name"] = (P_BMM_SINGLE_PROPERTY) < name = <"model_name"> documentation = <"Name of this model, if this schema is a model root point. Not set for sub-schemas that are not considered models on their own."> type = <"String"> > ["schema_name"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_name"> documentation = <"Name of model expressed in schema; a 'schema' usually contains all of the packages of one 'model' of a publisher. A publisher with more than one model can have multiple schemas. "> is_mandatory = type = <"String"> > ["schema_revision"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_revision"> documentation = <"Revision of schema."> is_mandatory = type = <"String"> > ["schema_lifecycle_state"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_lifecycle_state"> documentation = <"Schema development lifecycle state. "> is_mandatory = type = <"String"> > ["schema_author"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_author"> documentation = <"Primary author of schema. "> is_mandatory = type = <"String"> > ["schema_description"] = (P_BMM_SINGLE_PROPERTY) < name = <"schema_description"> documentation = <"Description of schema. "> is_mandatory = type = <"String"> > ["schema_contributors"] = (P_BMM_CONTAINER_PROPERTY) < name = <"schema_contributors"> documentation = <"Contributing authors of schema. "> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> > > functions = < ["validate_created"] = < name = <"validate_created"> documentation = <"Do some basic validation post initial creation * check that package structure is regular: ** only top-level packages can have qualified names ** no top-level package name can be a direct parent or child of another (child package must be declared under the parent) * check that all classes are mentioned in the package structure * check that all models refer to valid packages"> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > pre_conditions = < ["Pre_state"] = <"state = State_created"> > post_conditions = < ["Post_state"] = <"passed implies state = State_validated_created"> > > ["load_finalise"] = < name = <"load_finalise"> documentation = <"Finalisation work: * convert packages to canonical form, i.e. full hierarchy with no packages with names like aa.bb.cc * set up include processing list"> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > pre_conditions = < ["Pre_state"] = <"state = State_validated_created"> > post_conditions = < ["Post_state"] = <"state = State_includes_processed or state = State_includes_pending"> > > ["merge"] = < name = <"merge"> documentation = <"Merge in class and package definitions from `_other_`, except where the current schema already has a definition for the given type or package."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > parameters = < ["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"other"> type = <"BMM_SCHEMA"> > > pre_conditions = < ["Pre_state"] = <"state = State_includes_pending"> ["Pre_other_valid"] = <"includes_to_process.has (included_schema.schema_id)"> > > ["validate"] = < name = <"validate"> documentation = <"Main validation prior to generation of `_bmm_model_`."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > > ["create_bmm_model"] = < name = <"create_bmm_model"> documentation = <"Populate `_bmm_model_` from schema."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > pre_conditions = < ["Pre_state"] = <"state = P_BMM_PACKAGE_STATE.State_includes_processed"> > > ["read_to_validate"] = < name = <"read_to_validate"> documentation = <"True when validation may be commenced."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_state"] = <"state = State_includes_processed"> > > ["schema_id"] = < name = <"schema_id"> documentation = <"Identifier of this schema, used for stating inclusions and identifying files. Formed as: `{BMM_DEFINITIONS}.create_schema_id ( _rm_publisher_, _schema_name_, _rm_release_)` E.g. `\"openehr_rm_ehr_1.0.4\"`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_INCLUDE_SPEC"] = < name = <"BMM_INCLUDE_SPEC"> documentation = <"Schema inclusion structure."> properties = < ["id"] = (P_BMM_SINGLE_PROPERTY) < name = <"id"> documentation = <"Full identifier of the included schema, e.g. `\"openehr_primitive_types_1.0.2\"`."> is_mandatory = type = <"String"> > > > ["BMM_SCHEMA_METADATA_KEY"] = (P_BMM_ENUMERATION_STRING) < name = <"BMM_SCHEMA_METADATA_KEY"> ancestors = <"String", ...> item_names = <"bmm_version", "model_publisher", "schema_name", "model_release", "schema_revision", "schema_lifecycle_state", "schema_description", "schema_path"> item_documentations = <"", "", "", "", "", "", "", ""> > ["BMM_SCHEMA_STATE"] = (P_BMM_ENUMERATION_STRING) < name = <"BMM_SCHEMA_STATE"> documentation = <"Enumeration of processing states of a `BMM_SCHEMA` used by creation and validation routines in `BMM_SCHEMA`."> ancestors = <"String", ...> item_names = <"State_created", "State_validated_created", "State_includes_pending", "State_includes_processed"> item_documentations = <"Initial state directly after instantiation of schema.", "Initial validation pass after instantiation.", "State of schema processing if there are still included schemas to process.", "State when all included schemas have been processed."> > ["BMM_MODEL_ELEMENT"] = < name = <"BMM_MODEL_ELEMENT"> documentation = <"Abstract meta-type of BMM declared model elements. A _declaration_ is a an element of a model within a context, which defines the _scope_ of the element. Thus, a class definition and its property and routine definitions are model elements, but Types are not, since they are derived from model elements."> is_abstract = properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of this model element."> is_mandatory = type = <"String"> > ["documentation"] = (P_BMM_GENERIC_PROPERTY) < name = <"documentation"> documentation = <"Optional documentation of this element, as a keyed list. It is strongly recommended to use the following key /type combinations for the relevant purposes: * `\"purpose\": String` * `\"keywords\": List` * `\"use\": String` * `\"misuse\": String` * `\"references\": String` Other keys and value types may be freely added."> type_def = < generic_parameters = <"String", "Any"> root_type = <"Hash"> > > ["scope"] = (P_BMM_SINGLE_PROPERTY) < name = <"scope"> documentation = <"Model element within which an element is declared."> is_mandatory = type = <"BMM_MODEL_ELEMENT"> > ["extensions"] = (P_BMM_GENERIC_PROPERTY) < name = <"extensions"> documentation = <"Optional meta-data of this element, as a keyed list. May be used to extend the meta-model."> type_def = < generic_parameters = <"String", "Any"> root_type = <"Hash"> > > > functions = < ["is_root_scope"] = < name = <"is_root_scope"> documentation = <"True if this model element is the root of a model structure hierarchy."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_result"] = <"Result = (scope = self)"> > > > > ["BMM_FORMAL_ELEMENT"] = < name = <"BMM_FORMAL_ELEMENT"> documentation = <"A formal element having a name, type and a type-based signature."> ancestors = <"BMM_MODEL_ELEMENT", ...> is_abstract = properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Declared or inferred static type of the entity."> is_mandatory = type = <"BMM_TYPE"> > ["is_nullable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_nullable"> documentation = <"True if this element can be null (Void) at execution time. May be interpreted as optionality in subtypes.."> type = <"Boolean"> default = > > functions = < ["signature"] = < name = <"signature"> documentation = <"Formal signature of this element, in the form: `name [arg1_name: T_arg1, ...][:T_value]` Specific implementations in descendants."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIGNATURE"> > > ["is_boolean"] = < name = <"is_boolean"> documentation = <"True if `_type_` is notionally Boolean (i.e. a `BMM_SIMPLE_TYPE` with `_type_name()_` = `'Boolean'`)."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_result"] = <"Result = type().equal( {BMM_MODEL}.boolean_type_definition())"> > > > > ["BMM_CLASS"] = < name = <"BMM_CLASS"> documentation = <"Meta-type corresponding a class definition in an object model. Inheritance is specified by the `_ancestors_` attribute, which contains a list of _types_ rather than classes. Inheritance is thus understood in BMM as a stated relationship between classes. The equivalent relationship between types is conformance. NOTE: unlike UML, the `_name_` is just the root name, even if the class is generic. Use `_type_name()_` to obtain the qualified type name."> ancestors = <"BMM_MODULE", ...> is_abstract = properties = < ["ancestors"] = (P_BMM_GENERIC_PROPERTY) < name = <"ancestors"> documentation = <"List of immediate inheritance parents."> type_def = < generic_parameters = <"String", "BMM_MODEL_TYPE"> root_type = <"Hash"> > > ["package"] = (P_BMM_SINGLE_PROPERTY) < name = <"package"> documentation = <"Package this class belongs to."> is_mandatory = type = <"BMM_PACKAGE"> > ["properties"] = (P_BMM_GENERIC_PROPERTY) < name = <"properties"> documentation = <"Properties defined in this class (subset of `_features_`)."> type_def = < generic_parameters = <"String", "BMM_PROPERTY"> root_type = <"Hash"> > > ["source_schema_id"] = (P_BMM_SINGLE_PROPERTY) < name = <"source_schema_id"> documentation = <"Reference to original source schema defining this class. Useful for UI tools to determine which original schema file to open for a given class for manual editing."> is_mandatory = type = <"String"> > ["immediate_descendants"] = (P_BMM_CONTAINER_PROPERTY) < name = <"immediate_descendants"> documentation = <"List of computed references to base classes of immediate inheritance descendants, derived when members of `_ancestors_` are attached at creation time."> type_def = < container_type = <"List"> type = <"BMM_CLASS"> > cardinality = <|>=0|> > ["is_override"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_override"> documentation = <"True if this definition overrides a class of the same name in an included schema."> is_mandatory = type = <"Boolean"> > ["static_properties"] = (P_BMM_GENERIC_PROPERTY) < name = <"static_properties"> documentation = <"Static properties defined in this class (subset of `_features_`)."> type_def = < generic_parameters = <"String", "BMM_STATIC"> root_type = <"Hash"> > > ["functions"] = (P_BMM_GENERIC_PROPERTY) < name = <"functions"> documentation = <"Functions defined in this class (subset of `_features_`)."> type_def = < generic_parameters = <"String", "BMM_FUNCTION"> root_type = <"Hash"> > > ["procedures"] = (P_BMM_GENERIC_PROPERTY) < name = <"procedures"> documentation = <"Procedures defined in this class (subset of `_features_`)."> type_def = < generic_parameters = <"String", "BMM_PROCEDURE"> root_type = <"Hash"> > > ["is_primitive"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_primitive"> documentation = <"True if this class represents a type considered to be primitive in the type system, i.e. any typically built-in or standard library type such as `String`, `Date`, `Hash` etc."> type = <"Boolean"> default = > ["is_abstract"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_abstract"> documentation = <"True if this class is marked as abstract, i.e. direct instances cannot be created from its direct type."> type = <"Boolean"> default = > ["invariants"] = (P_BMM_CONTAINER_PROPERTY) < name = <"invariants"> type_def = < container_type = <"List"> type = <"BMM_ASSERTION"> > cardinality = <|>=0|> > ["creators"] = (P_BMM_GENERIC_PROPERTY) < name = <"creators"> documentation = <"Subset of `_procedures_` that may be used to initialise a new instance of an object, and whose execution will guarantee that class invariants are satisfied."> type_def = < generic_parameters = <"String", "BMM_PROCEDURE"> root_type = <"Hash"> > > ["converters"] = (P_BMM_GENERIC_PROPERTY) < name = <"converters"> documentation = <"Subset of `_creators_` that create a new instance from a single argument of another type."> type_def = < generic_parameters = <"String", "BMM_PROCEDURE"> root_type = <"Hash"> > > ["features"] = (P_BMM_CONTAINER_PROPERTY) < name = <"features"> documentation = <"Features of this module."> type_def = < container_type = <"List"> type = <"BMM_FEATURE"> > cardinality = <|>=0|> > > functions = < ["type"] = < name = <"type"> documentation = <"Generate a type object that represents the type for which this class is the definer."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_MODEL_TYPE"> > > ["all_ancestors"] = < name = <"all_ancestors"> documentation = <"List of all inheritance parent class names, recursively."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["all_descendants"] = < name = <"all_descendants"> documentation = <"Compute all descendants by following `_immediate_descendants_`."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["suppliers"] = < name = <"suppliers"> documentation = <"List of names of immediate supplier classes, including concrete generic parameters, concrete descendants of abstract statically defined types, and inherited suppliers. (Where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway). This list includes primitive types. "> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["suppliers_non_primitive"] = < name = <"suppliers_non_primitive"> documentation = <"Same as `suppliers` minus primitive types, as defined in input schema."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["supplier_closure"] = < name = <"supplier_closure"> documentation = <"List of names of all classes in full supplier closure, including concrete generic parameters; (where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway). This list includes primitive types."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["package_path"] = < name = <"package_path"> documentation = <"Fully qualified package name, of form: `package.package`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["class_path"] = < name = <"class_path"> documentation = <"Fully qualified class name, of form: `package.package.CLASS` with package path in lower-case and class in original case. "> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"True if this class is designated a primitive type within the overall type system of the schema. Set from schema."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"True if this class is abstract in its model. Value provided from an underlying data property set at creation or construction time."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["features"] = < name = <"features"> documentation = <"List of all feature definitions introduced in this class."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> > is_nullable = > ["flat_features"] = < name = <"flat_features"> documentation = <"Consolidated list of all feature definitions from this class and all inheritance ancestors."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> > is_nullable = > ["flat_properties"] = < name = <"flat_properties"> documentation = <"List of all properties due to current and ancestor classes, keyed by property name."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"BMM_PROPERTY"> > is_nullable = > > invariants = < ["Inv_constructors"] = <"for_all p in creators : procedures.has(p)"> ["Inv_converters"] = <"for_all p in converters : creators.has(p) and p.arity() = 1"> > > ["BMM_CONTAINER_TYPE"] = < name = <"BMM_CONTAINER_TYPE"> documentation = <"Meta-type that specifies linear containers with a generic parameter corresponding to the type of contained item, and whose container type is a generic type such as `List`, `Set` etc."> ancestors = <"BMM_TYPE", ...> properties = < ["container_class"] = (P_BMM_SINGLE_PROPERTY) < name = <"container_class"> documentation = <"The type of the container. This converts to the `_root_type_` in `BMM_GENERIC_TYPE`."> is_mandatory = type = <"BMM_GENERIC_CLASS"> > ["item_type"] = (P_BMM_SINGLE_PROPERTY) < name = <"item_type"> documentation = <"The container item type."> is_mandatory = type = <"BMM_UNITARY_TYPE"> > ["is_ordered"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_ordered"> documentation = <"True indicates that order of the items in the container attribute is considered significant and must be preserved, e.g. across sessions, serialisation, deserialisation etc. Otherwise known as 'list' semantics."> type = <"Boolean"> default = > ["is_unique"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_unique"> documentation = <"True indicates that only unique instances of items in the container are allowed. Otherwise known as 'set' semantics."> type = <"Boolean"> default = > > functions = < ["type_name"] = < name = <"type_name"> documentation = <"Return full type name, e.g. `List`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"True if the container class is abstract."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_is_abstract"] = <"Result = container_type.is_abstract"> > > ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Flattened list of type names of `_item_type_`, i.e. `_item_type.flattened_type_list_()`."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > post_conditions = < ["Post_result"] = <"Result = item_type.flattened_type_list"> > > ["unitary_type"] = < name = <"unitary_type"> documentation = <"Return `_item_type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_UNITARY_TYPE"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"True if `_item_type_` is primitive."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_validity"] = <"Result = base_class.is_primitive"> ["Post_result"] = <"Result = item_type.is_primitive"> > > ["effective_type"] = < name = <"effective_type"> documentation = <"Return `_item_type.effective_type_()`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_EFFECTIVE_TYPE"> > > > > ["BMM_EFFECTIVE_TYPE"] = < name = <"BMM_EFFECTIVE_TYPE"> documentation = <"Meta-type for a concrete, unitary type that can be used as an actual parameter type in a generic type declaration."> ancestors = <"BMM_UNITARY_TYPE", ...> is_abstract = functions = < ["effective_type"] = < name = <"effective_type"> documentation = <"Result = self."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_EFFECTIVE_TYPE"> > > ["type_base_name"] = < name = <"type_base_name"> documentation = <"Name of base generator type, i.e. excluding any generic parts if present."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_MODEL_TYPE"] = < name = <"BMM_MODEL_TYPE"> documentation = <"A type that is defined by a class (or classes) in the model."> ancestors = <"BMM_EFFECTIVE_TYPE", ...> is_abstract = properties = < ["value_constraint"] = (P_BMM_SINGLE_PROPERTY) < name = <"value_constraint"> type = <"BMM_VALUE_SET_SPEC"> > ["base_class"] = (P_BMM_SINGLE_PROPERTY) < name = <"base_class"> documentation = <"Base class of this type."> is_mandatory = type = <"BMM_CLASS"> > > functions = < ["type_base_name"] = < name = <"type_base_name"> documentation = <"Result = `_base_class.name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"Result = `_base_class.is_primitive_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_validity"] = <"Result = base_class.is_primitive"> > > > > ["BMM_GENERIC_CLASS"] = < name = <"BMM_GENERIC_CLASS"> documentation = <"Definition of a generic class in an object model."> ancestors = <"BMM_CLASS", ...> properties = < ["generic_parameters"] = (P_BMM_GENERIC_PROPERTY) < name = <"generic_parameters"> documentation = <"List of formal generic parameters, keyed by name. These are defined either directly on this class or by the inclusion of an ancestor class which is generic."> is_mandatory = type_def = < generic_parameters = <"String", "BMM_PARAMETER_TYPE"> root_type = <"Hash"> > > > functions = < ["suppliers"] = < name = <"suppliers"> documentation = <"Add suppliers from generic parameters."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["type"] = < name = <"type"> documentation = <"Generate a fully open `BMM_GENERIC_TYPE` instance that corresponds to this class definition"> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_GENERIC_TYPE"> > > ["generic_parameter_conformance_type"] = < name = <"generic_parameter_conformance_type"> documentation = <"For a generic class, type to which generic parameter `a_name` conforms e.g. if this class is `Interval ` then the Result will be the single type `Comparable`. For an unconstrained type `T`, the Result will be `Any`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > parameters = < ["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_name"> type = <"String"> > > > > > ["BMM_GENERIC_TYPE"] = < name = <"BMM_GENERIC_TYPE"> documentation = <"Meta-type based on a non-container generic class, e.g. `Packet
`."> ancestors = <"BMM_MODEL_TYPE", ...> properties = < ["generic_parameters"] = (P_BMM_CONTAINER_PROPERTY) < name = <"generic_parameters"> documentation = <"Generic parameters of the `_root_type_` in this type specifier. The order must match the order of the owning class's formal generic parameter declarations, and the types may be defined types or formal parameter types."> is_mandatory = type_def = < container_type = <"List"> type = <"BMM_UNITARY_TYPE"> > cardinality = <|>=1|> > ["base_class"] = (P_BMM_SINGLE_PROPERTY) < name = <"base_class"> documentation = <"Defining generic class of this type."> is_mandatory = type = <"BMM_GENERIC_CLASS"> > > functions = < ["type_name"] = < name = <"type_name"> documentation = <"Return the full name of the type including generic parameters, e.g. `DV_INTERVAL`, `TABLE,String>`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["type_signature"] = < name = <"type_signature"> documentation = <"Signature form of the type, which for generics includes generic parameter constrainer types E.g. `Interval`. "> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"True if `_base_class.is_abstract_` or if any (non-open) parameter type is abstract."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Result is `_base_class.name_` followed by names of all generic parameter type names, which may be open or closed."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > ["is_partially_closed"] = < name = <"is_partially_closed"> documentation = <"Returns True if there is any substituted generic parameter."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["effective_base_class"] = < name = <"effective_base_class"> documentation = <"Effective underlying class for this type, abstracting away any container type."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_GENERIC_CLASS"> > > ["is_open"] = < name = <"is_open"> documentation = <"True if all generic parameters from ancestor generic types have been substituted in this type."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > > > ["BMM_PARAMETER_TYPE"] = < name = <"BMM_PARAMETER_TYPE"> documentation = <"Definition of a generic parameter in a class definition of a generic type."> ancestors = <"BMM_UNITARY_TYPE", ...> properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of the parameter, e.g. 'T' etc. The name is limited to 1 character and upper-case."> is_mandatory = type = <"String"> > ["type_constraint"] = (P_BMM_SINGLE_PROPERTY) < name = <"type_constraint"> documentation = <"Optional conformance constraint that must be the name of a defined type."> type = <"BMM_EFFECTIVE_TYPE"> > ["inheritance_precursor"] = (P_BMM_SINGLE_PROPERTY) < name = <"inheritance_precursor"> documentation = <"If set, is the corresponding generic parameter definition in an ancestor class."> type = <"BMM_PARAMETER_TYPE"> > > functions = < ["flattened_conforms_to_type"] = < name = <"flattened_conforms_to_type"> documentation = <"Result is either `_conforms_to_type_` or `_inheritance_precursor.flattened_conforms_to_type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_EFFECTIVE_TYPE"> > > ["type_signature"] = < name = <"type_signature"> documentation = <"Signature form of the open type, including constrainer type if there is one, e.g. `T:Ordered`. "> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"Result = `False` - generic parameters are understood by definition to be non-primitive."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_validity"] = <"Result = base_class.is_primitive"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"Result = `False` - generic parameters are understood by definition to be non-abstract."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["type_name"] = < name = <"type_name"> documentation = <"Return `_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Result is either `_flattened_conforms_to_type.flattened_type_list_` or the `Any` type."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > ["effective_type"] = < name = <"effective_type"> documentation = <"Generate ultimate conformance type, which is either `_flattened_conforms_to_type_` or if not set, `'Any'`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_EFFECTIVE_TYPE"> > > > invariants = < ["Inv_generic_name"] = <"name.count = 1 and name.is_upper"> > > ["BMM_TUPLE_TYPE"] = < name = <"BMM_TUPLE_TYPE"> documentation = <"Built-in meta-type representing the type of a tuple, i.e. an array of any number of other types. This includes both container and unitary types, since tuple instances represent concrete objects. Note that both open and closed generic parameters are allowed, as with any generic type, but open generic parameters are only valid within the scope of a generic class."> ancestors = <"BMM_BUILTIN_TYPE", ...> properties = < ["item_types"] = (P_BMM_GENERIC_PROPERTY) < name = <"item_types"> documentation = <"List of types of the items of the tuple, keyed by purpose in the tuple."> is_mandatory = type_def = < generic_parameters = <"String", "BMM_TYPE"> root_type = <"Hash"> > > > constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Tuple\""> > > functions = < ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Return the logical set (i.e. unique types) from the merge of `_flattened_type_list_()` called on each member of `_item_types_`."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > > > ["BMM_TYPE"] = < name = <"BMM_TYPE"> documentation = <"Abstract idea of specifying a type in some context. This is not the same as 'defining' a class. A type specification is essentially a reference of some kind, that defines the type of an attribute, or function result or argument. It may include generic parameters that might or might not be bound. See subtypes."> is_abstract = functions = < ["type_name"] = < name = <"type_name"> documentation = <"Formal string form of the type as per UML."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["type_signature"] = < name = <"type_signature"> documentation = <"Signature form of the type name, which for generics includes generic parameter constrainer types E.g. `Interval`. Defaults to the value of `_type_name()_`. "> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"If true, indicates a type based on an abstract class, i.e. a type that cannot be directly instantiated."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"If True, indicates that a type based solely on primitive classes."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["unitary_type"] = < name = <"unitary_type"> documentation = <"Type with any container abstracted away; may be a formal generic type."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_UNITARY_TYPE"> > > ["effective_type"] = < name = <"effective_type"> documentation = <"Type with any container abstracted away, and any formal parameter replaced by its effective constraint type."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_EFFECTIVE_TYPE"> > > ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Completely flattened list of type names, flattening out all generic parameters."> is_abstract = result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > > > ["BMM_SIMPLE_CLASS"] = < name = <"BMM_SIMPLE_CLASS"> documentation = <"Definition of a simple class, i.e. a class that has no generic parameters and is 1:1 with the type it generates."> ancestors = <"BMM_CLASS", ...> functions = < ["type"] = < name = <"type"> documentation = <"Generate a type object that represents the type of this class. Can only be an instance of `BMM_SIMPLE_TYPE` or a descendant."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_TYPE"> > > > > ["BMM_SIMPLE_TYPE"] = < name = <"BMM_SIMPLE_TYPE"> documentation = <"Type reference to a single type i.e. not generic or container type."> ancestors = <"BMM_MODEL_TYPE", ...> properties = < ["base_class"] = (P_BMM_SINGLE_PROPERTY) < name = <"base_class"> documentation = <"Defining class of this type."> is_mandatory = type = <"BMM_SIMPLE_CLASS"> > > functions = < ["type_name"] = < name = <"type_name"> documentation = <"Result is `_base_class.name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["is_abstract"] = < name = <"is_abstract"> documentation = <"Result is `_base_class.is_abstract_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Result is `_base_class.name_` ."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > ["effective_base_class"] = < name = <"effective_base_class"> documentation = <"Main design class for this type, from which properties etc can be extracted."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_CLASS"> > > > > ["BMM_UNITARY_TYPE"] = < name = <"BMM_UNITARY_TYPE"> documentation = <"Parent of meta-types that may be used as the type of any instantiated object that is not a container object."> ancestors = <"BMM_TYPE", ...> is_abstract = functions = < ["unitary_type"] = < name = <"unitary_type"> documentation = <"Result = self."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_UNITARY_TYPE"> > > > > ["BMM_INDEXED_CONTAINER_TYPE"] = < name = <"BMM_INDEXED_CONTAINER_TYPE"> documentation = <"Meta-type of linear container type that indexes the contained items in the manner of a standard Hash table, map or dictionary."> ancestors = <"BMM_CONTAINER_TYPE", ...> properties = < ["index_type"] = (P_BMM_SINGLE_PROPERTY) < name = <"index_type"> documentation = <"Type of the element index, typically `String` or `Integer`, but may be a numeric type or indeed any type from which a hash value can be derived."> is_mandatory = type = <"BMM_SIMPLE_TYPE"> > > functions = < ["type_name"] = < name = <"type_name"> documentation = <"Return full type name, e.g. `HashMap`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_SIGNATURE"] = < name = <"BMM_SIGNATURE"> documentation = <"Built-in meta-type that expresses the type structure of any referenceable element of a model. Consists of potential `_arguments_` and `_result_`, with constraints in descendants determining the exact form."> ancestors = <"BMM_BUILTIN_TYPE", ...> properties = < ["result_type"] = (P_BMM_SINGLE_PROPERTY) < name = <"result_type"> documentation = <"Result type of signature."> is_mandatory = type = <"BMM_TYPE"> > > constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Signature\""> > > functions = < ["flattened_type_list"] = < name = <"flattened_type_list"> documentation = <"Return the logical set (i.e. unique items) consisting of `_argument_types.flattened_type_list_()` and `_result_type.flattened_type_list_()`."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > > > > ["BMM_MODULE"] = < name = <"BMM_MODULE"> documentation = <"Meta-type defining a generalised module concept. Descendants define actual structure and contents."> ancestors = <"BMM_MODEL_ELEMENT", ...> is_abstract = properties = < ["scope"] = (P_BMM_SINGLE_PROPERTY) < name = <"scope"> documentation = <"Model within which module is defined."> is_mandatory = type = <"BMM_MODEL"> > ["feature_groups"] = (P_BMM_CONTAINER_PROPERTY) < name = <"feature_groups"> documentation = <"List of feature groups in this class."> type_def = < container_type = <"List"> type = <"BMM_FEATURE_GROUP"> > cardinality = <|>=0|> > ["features"] = (P_BMM_CONTAINER_PROPERTY) < name = <"features"> documentation = <"Features of this module."> type_def = < container_type = <"List"> type = <"BMM_FORMAL_ELEMENT"> > cardinality = <|>=0|> > > > ["BMM_STATUS_TYPE"] = < name = <"BMM_STATUS_TYPE"> documentation = <"Built-in meta-type representing action status, e.g. result of a call invocation."> ancestors = <"BMM_BUILTIN_TYPE", ...> constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Status\""> > > > ["BMM_BUILTIN_TYPE"] = < name = <"BMM_BUILTIN_TYPE"> documentation = <"Parent of built-in types, which are treated as being primitive and non-abstract."> ancestors = <"BMM_EFFECTIVE_TYPE", ...> is_abstract = constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in typename)."> type = <"String"> > > functions = < ["is_abstract"] = < name = <"is_abstract"> documentation = <"Return False."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["is_primitive"] = < name = <"is_primitive"> documentation = <"Return True."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > > ["type_base_name"] = < name = <"type_base_name"> documentation = <"Return `_base_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["type_name"] = < name = <"type_name"> documentation = <"Return `_base_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_PROCEDURE_TYPE"] = < name = <"BMM_PROCEDURE_TYPE"> documentation = <"Form of routine specific to procedure object signatures, with `_result_type_` being the special Status meta-type"> ancestors = <"BMM_ROUTINE_TYPE", ...> properties = < ["result_type"] = (P_BMM_SINGLE_PROPERTY) < name = <"result_type"> documentation = <"Result type of a procedure."> type = <"BMM_STATUS_TYPE"> > > constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Procedure\""> > > > ["BMM_FUNCTION_TYPE"] = < name = <"BMM_FUNCTION_TYPE"> documentation = <"Meta-type for function object signatures."> ancestors = <"BMM_ROUTINE_TYPE", ...> constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Function\""> > > > ["BMM_ROUTINE_TYPE"] = < name = <"BMM_ROUTINE_TYPE"> documentation = <"Meta-type for routine objects."> ancestors = <"BMM_SIGNATURE", ...> properties = < ["argument_types"] = (P_BMM_SINGLE_PROPERTY) < name = <"argument_types"> documentation = <"Type of arguments in the signature, if any; represented as a type-tuple (list of arbitrary types)."> type = <"BMM_TUPLE_TYPE"> > > constants = < ["base_name"] = < name = <"base_name"> documentation = <"Base name (built-in)."> type = <"String"> value = <"\"Routine\""> > > > ["BMM_PROPERTY_TYPE"] = < name = <"BMM_PROPERTY_TYPE"> documentation = <"Meta-type for property and variable signatures."> ancestors = <"BMM_SIGNATURE", ...> > ["BMM_ENTITY_METATYPE"] = (P_BMM_ENUMERATION_STRING) < name = <"BMM_ENTITY_METATYPE"> ancestors = <"String", ...> item_names = <"Entity_metatype_simple", "Entity_metatype_generic", "Entity_metatype_generic_parameter", "Entity_metatype_range_constrained", "Entity_metatype_enumeration", "Entity_metatype_container"> item_documentations = <"", "", "", "", "", ""> > ["BMM_VALUE_SET_SPEC"] = < name = <"BMM_VALUE_SET_SPEC"> documentation = <"Definition of a range-constrained class whose value range is defined by reference to a 'value set' within an external resource, e.g. a reference data service."> properties = < ["resource_id"] = (P_BMM_SINGLE_PROPERTY) < name = <"resource_id"> documentation = <"Identifier of a resource (typically available as a service) that contains legal values of a specific type. This is typically a URI but need not be."> is_mandatory = type = <"String"> > ["value_set_id"] = (P_BMM_SINGLE_PROPERTY) < name = <"value_set_id"> documentation = <"Identifier of a value set within the resource identified by `_resource_id_`, which specifies the set of legal values of a type. This might be a URI, but need not be."> is_mandatory = type = <"String"> > > > ["BMM_ENUMERATION"] = < name = <"BMM_ENUMERATION"> documentation = <"Definition of an enumeration class, understood as a class whose value range is constrained extensionally, i.e. by an explicit enumeration of named singleton instances. Only one inheritance ancestor is allowed in order to provide the base type to which the range constraint is applied. The common notion of a set of literals with no explicit defined values is represented as the degenerate subtype `BMM_ENUMERATION_INTEGER`, whose values are 0, 1, ..."> ancestors = <"BMM_SIMPLE_CLASS", ...> properties = < ["item_names"] = (P_BMM_CONTAINER_PROPERTY) < name = <"item_names"> documentation = <"The list of names of the enumeration. If no values are supplied, the integer values 0, 1, 2, ... are assumed."> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> > ["item_values"] = (P_BMM_CONTAINER_PROPERTY) < name = <"item_values"> documentation = <"Optional list of specific values. Must be 1:1 with `_item_names_` list."> type_def = < container_type = <"List"> type = <"BMM_PRIMITIVE_VALUE"> > cardinality = <|>=0|> > > functions = < ["name_map"] = < name = <"name_map"> documentation = <"Map of `_item_names_` to `_item_values_` (stringified)."> result = (P_BMM_GENERIC_TYPE) < generic_parameters = <"String", "String"> root_type = <"Hash"> > > > > ["BMM_ENUMERATION_INTEGER"] = < name = <"BMM_ENUMERATION_INTEGER"> documentation = <"Integer-based enumeration meta-type."> ancestors = <"BMM_ENUMERATION", ...> properties = < ["item_values"] = (P_BMM_CONTAINER_PROPERTY) < name = <"item_values"> documentation = <"Optional list of specific values. Must be 1:1 with `_item_names_` list."> type_def = < container_type = <"List"> type = <"BMM_INTEGER_VALUE"> > cardinality = <|>=0|> > > > ["BMM_ENUMERATION_STRING"] = < name = <"BMM_ENUMERATION_STRING"> documentation = <"String-based enumeration meta-type."> ancestors = <"BMM_ENUMERATION", ...> properties = < ["item_values"] = (P_BMM_CONTAINER_PROPERTY) < name = <"item_values"> documentation = <"Optional list of specific values. Must be 1:1 with `_item_names_` list."> type_def = < container_type = <"List"> type = <"BMM_STRING_VALUE"> > cardinality = <|>=0|> > > > ["BMM_CONSTANT"] = < name = <"BMM_CONSTANT"> documentation = <"An immutable, static value-returning element scoped to a class. The `_value_` is the result of the evaluation of the `_generator_`, which may be as simple as a literal value, or may be any expression, including a function call."> ancestors = <"BMM_STATIC", ...> properties = < ["generator"] = (P_BMM_SINGLE_PROPERTY) < name = <"generator"> documentation = <"Literal value of the constant."> is_mandatory = type = <"BMM_LITERAL_VALUE"> > > invariants = < ["Inv_not_nullable"] = <"is_nullable = False"> > > ["BMM_CONTAINER_PROPERTY"] = < name = <"BMM_CONTAINER_PROPERTY"> documentation = <"Meta-type of for properties of linear container type, such as List etc."> ancestors = <"BMM_PROPERTY", ...> properties = < ["cardinality"] = (P_BMM_SINGLE_PROPERTY) < name = <"cardinality"> documentation = <"Cardinality of this container."> type = <"Multiplicity_interval"> > ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Declared or inferred static type of the entity."> is_mandatory = type = <"BMM_CONTAINER_TYPE"> > > functions = < ["display_name"] = < name = <"display_name"> documentation = <"Name of this property in form `name: ContainerTypeName<>`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_FUNCTION"] = < name = <"BMM_FUNCTION"> documentation = <"A formal element with signature of the form: `name ({arg:TArg}*):TResult`. A function is a computed (rather than data) element, generally assumed to be non-state-changing."> ancestors = <"BMM_ROUTINE", ...> properties = < ["operator_definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"operator_definition"> documentation = <"Optional details enabling a function to be represented as an operator in a syntactic representation."> type = <"BMM_OPERATOR"> > ["result"] = (P_BMM_SINGLE_PROPERTY) < name = <"result"> documentation = <"Automatically created Result variable, usable in body and post-condition."> is_mandatory = type = <"BMM_RESULT"> > > invariants = < ["Operator_validity"] = <"operator_def /= Void implies arity in |1..2|"> ["Inv_signature_has_result"] = <"signature().result /= Void"> ["Inv_result_type"] = <"type = Result.type"> > > ["BMM_LOCAL"] = < name = <"BMM_LOCAL"> documentation = <"A routine local variable (writable)."> ancestors = <"BMM_WRITABLE_VARIABLE", ...> > ["BMM_OPERATOR"] = < name = <"BMM_OPERATOR"> documentation = <"Definition of a symbolic operator associated with a function."> properties = < ["position"] = (P_BMM_SINGLE_PROPERTY) < name = <"position"> documentation = <"Position of operator in syntactic representation."> is_mandatory = type = <"BMM_OPERATOR_POSITION"> > ["symbols"] = (P_BMM_CONTAINER_PROPERTY) < name = <"symbols"> documentation = <"Set of `String` symbols that may be used to represent this operator in a textual representation of a BMM model."> is_mandatory = type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=1|> > ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Formal name of the operator, e.g. 'minus' etc."> is_mandatory = type = <"String"> > > > ["BMM_PROPERTY"] = < name = <"BMM_PROPERTY"> documentation = <"Meta-type of a writable property definition within a class definition of an object model. The `_is_composition_` attribute indicates whether the property has sub-part or an association semantics with respect to the owning class."> ancestors = <"BMM_INSTANTIABLE_FEATURE", ...> is_abstract = properties = < ["is_im_runtime"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_im_runtime"> documentation = <"True if this property is marked with info model `_im_runtime_` property."> type = <"Boolean"> default = > ["is_im_infrastructure"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_im_infrastructure"> documentation = <"True if this property was marked with info model `_im_infrastructure_` flag."> type = <"Boolean"> default = > ["is_composition"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_composition"> documentation = <"True if this property instance is a compositional sub-part of the owning class instance. Equivalent to 'composition' in UML associations (but missing from UML properties without associations) and also 'cascade-delete' semantics in ER schemas."> type = <"Boolean"> default = > > functions = < ["existence"] = < name = <"existence"> documentation = <"Interval form of `0..1`, `1..1` etc, derived from `_is_nullable_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Multiplicity_interval"> > > ["display_name"] = < name = <"display_name"> documentation = <"Name of this property to display in UI."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > invariants = < ["Inv_signature_no_args"] = <"signature().arguments = Void"> > > ["BMM_ROUTINE"] = < name = <"BMM_ROUTINE"> documentation = <"A feature defining a routine, scoped to a class."> ancestors = <"BMM_FEATURE", ...> is_abstract = properties = < ["parameters"] = (P_BMM_CONTAINER_PROPERTY) < name = <"parameters"> documentation = <"Formal parameters of the routine."> type_def = < container_type = <"List"> type = <"BMM_PARAMETER"> > cardinality = <|>=0|> > ["pre_conditions"] = (P_BMM_CONTAINER_PROPERTY) < name = <"pre_conditions"> documentation = <"Boolean conditions that must evaluate to True for the routine to execute correctly, May be used to generate exceptions if included in run-time build. A False pre-condition implies an error in the passed parameters."> type_def = < container_type = <"List"> type = <"BMM_ASSERTION"> > cardinality = <|>=0|> > ["post_conditions"] = (P_BMM_CONTAINER_PROPERTY) < name = <"post_conditions"> documentation = <"Boolean conditions that will evaluate to True if the routine executed correctly, May be used to generate exceptions if included in run-time build. A False post-condition implies an error (i.e. bug) in routine code."> type_def = < container_type = <"List"> type = <"BMM_ASSERTION"> > cardinality = <|>=0|> > ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Body of a routine, i.e. executable program."> type = <"BMM_ROUTINE_DEFINITION"> > > functions = < ["arity"] = < name = <"arity"> documentation = <"Return number of arguments of this routine."> result = (P_BMM_SIMPLE_TYPE) < type = <"Integer"> > > > > ["BMM_PARAMETER"] = < name = <"BMM_PARAMETER"> documentation = <"A routine parameter variable (read-only)."> ancestors = <"BMM_READONLY_VARIABLE", ...> properties = < ["direction"] = (P_BMM_SINGLE_PROPERTY) < name = <"direction"> documentation = <"Optional read/write direction of the parameter. If none-supplied, the parameter is treated as `in`, i.e. readable."> type = <"BMM_PARAMETER_DIRECTION"> > > > ["BMM_VARIABLE"] = < name = <"BMM_VARIABLE"> documentation = <"A routine-scoped formal element."> ancestors = <"BMM_FORMAL_ELEMENT", ...> is_abstract = properties = < ["scope"] = (P_BMM_SINGLE_PROPERTY) < name = <"scope"> documentation = <"Routine within which variable is defined."> is_mandatory = type = <"BMM_ROUTINE"> > > > ["BMM_PROCEDURE"] = < name = <"BMM_PROCEDURE"> documentation = <"A formal element with signature of the form: `name ({arg:TArg}*):TStatus`, where `TStatus` is the built-in type `BMM_STATUS_TYPE`.. A procedure is a computed (rather than data) element, generally assumed to be state-changing, and is usually called in the form `name ({arg:TArg}*)`."> ancestors = <"BMM_ROUTINE", ...> properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Declared or inferred static type of the entity."> is_mandatory = type = <"BMM_STATUS_TYPE"> > > functions = < ["signature"] = < name = <"signature"> documentation = <"Formal signature of this element, in the form: `name [arg1_name: T_arg1, ...][:T_value]` Specific implementations in descendants."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_PROCEDURE_TYPE"> > > > invariants = < ["Inv_signature_no_result"] = <"signature().result = Void"> > > ["BMM_UNITARY_PROPERTY"] = < name = <"BMM_UNITARY_PROPERTY"> documentation = <"Meta-type of for properties of unitary type."> ancestors = <"BMM_PROPERTY", ...> properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Declared or inferred static type of the entity."> is_mandatory = type = <"BMM_UNITARY_TYPE"> > > > ["BMM_INDEXED_CONTAINER_PROPERTY"] = < name = <"BMM_INDEXED_CONTAINER_PROPERTY"> documentation = <"Meta-type of for properties of linear container type, such as `Hash` etc."> ancestors = <"BMM_CONTAINER_PROPERTY", ...> properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Declared or inferred static type of the entity."> is_mandatory = type = <"BMM_INDEXED_CONTAINER_TYPE"> > > functions = < ["display_name"] = < name = <"display_name"> documentation = <"Name of this property in form `name: ContainerTypeName`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_INSTANTIABLE_FEATURE"] = < name = <"BMM_INSTANTIABLE_FEATURE"> documentation = <"Meta-type representing instantiable features, i.e. features that are created as value objects."> ancestors = <"BMM_FEATURE", ...> is_abstract = > ["BMM_RESULT"] = < name = <"BMM_RESULT"> documentation = <"Automatically declared variable representing result of a Function call (writable)."> ancestors = <"BMM_WRITABLE_VARIABLE", ...> properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of this model element."> is_mandatory = type = <"String"> default = <"\"Result\""> > > > ["BMM_FEATURE_EXTENSION"] = < name = <"BMM_FEATURE_EXTENSION"> documentation = <"Abstract parent of feature extensions."> is_abstract = > ["BMM_ROUTINE_DEFINITION"] = < name = <"BMM_ROUTINE_DEFINITION"> documentation = <"Abstract ancestor of routine body meta-types."> is_abstract = > ["BMM_EXTERNAL_ROUTINE"] = < name = <"BMM_EXTERNAL_ROUTINE"> documentation = <"External routine meta-type, containing sufficient meta-data to enable a routine in an external library to be called."> ancestors = <"BMM_ROUTINE_DEFINITION", ...> properties = < ["meta_data"] = (P_BMM_GENERIC_PROPERTY) < name = <"meta_data"> documentation = <"External call general meta-data, including target routine name, type mapping etc."> is_mandatory = type_def = < generic_parameters = <"String", "String"> root_type = <"Hash"> > > ["argument_mapping"] = (P_BMM_GENERIC_PROPERTY) < name = <"argument_mapping"> documentation = <"Optional argument-mapping meta-data."> type_def = < generic_parameters = <"String", "String"> root_type = <"Hash"> > > > > ["BMM_FEATURE_GROUP"] = < name = <"BMM_FEATURE_GROUP"> documentation = <"A logical group of features, with a name and set of properties that applies to the group. "> properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of this feature group; defaults to 'feature'."> is_mandatory = type = <"String"> default = <"\"feature\""> > ["properties"] = (P_BMM_GENERIC_PROPERTY) < name = <"properties"> documentation = <"Set of properties of this group, represented as name/value pairs. These are understood to apply logically to all of the features contained within the group."> is_mandatory = type_def = < generic_parameters = <"String", "String"> root_type = <"Hash"> > > ["features"] = (P_BMM_CONTAINER_PROPERTY) < name = <"features"> documentation = <"Set of features in this group."> type_def = < container_type = <"List"> type = <"BMM_FEATURE"> > cardinality = <|>=0|> > ["visibility"] = (P_BMM_SINGLE_PROPERTY) < name = <"visibility"> documentation = <"Optional visibility to apply to all features in this group."> type = <"BMM_VISIBILITY"> > > > ["BMM_VISIBILITY"] = < name = <"BMM_VISIBILITY"> documentation = <"Abstract parent of visibility representation. TODO: define schemes; probably need to support C++/Java scheme as well as better type-based schemes."> is_abstract = > ["BMM_FEATURE"] = < name = <"BMM_FEATURE"> documentation = <"A module-scoped formal element."> ancestors = <"BMM_FORMAL_ELEMENT", ...> is_abstract = properties = < ["is_synthesised_generic"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_synthesised_generic"> documentation = <"True if this feature was synthesised due to generic substitution in an inherited type, or further constraining of a formal generic parameter."> type = <"Boolean"> default = > ["feature_extensions"] = (P_BMM_CONTAINER_PROPERTY) < name = <"feature_extensions"> documentation = <"Extensions to feature-level meta-types."> type_def = < container_type = <"List"> type = <"BMM_FEATURE_EXTENSION"> > cardinality = <|>=0|> > ["group"] = (P_BMM_SINGLE_PROPERTY) < name = <"group"> documentation = <"Group containing this feature."> is_mandatory = type = <"BMM_FEATURE_GROUP"> > ["scope"] = (P_BMM_SINGLE_PROPERTY) < name = <"scope"> documentation = <"Model element within which an element is declared."> is_mandatory = type = <"BMM_CLASS"> > > > ["BMM_SELF"] = < name = <"BMM_SELF"> documentation = <"Meta-type for an automatically created variable referencing the current instance. Typically called 'self' or 'this' in programming languages. Read-only."> ancestors = <"BMM_READONLY_VARIABLE", ...> properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of this model element."> is_mandatory = type = <"String"> default = <"\"Self\""> > > > ["BMM_WRITABLE_VARIABLE"] = < name = <"BMM_WRITABLE_VARIABLE"> documentation = <"Meta-type for writable variables, including the special variable `Result`."> ancestors = <"BMM_VARIABLE", ...> is_abstract = > ["BMM_READONLY_VARIABLE"] = < name = <"BMM_READONLY_VARIABLE"> documentation = <"Meta-type for writable variables, including routine parameters and the special variable `Self`."> ancestors = <"BMM_VARIABLE", ...> is_abstract = > ["BMM_SINGLETON"] = < name = <"BMM_SINGLETON"> documentation = <"Meta-type for static value properties computed once by a function invocation."> ancestors = <"BMM_STATIC", ...> properties = < ["generator"] = (P_BMM_SINGLE_PROPERTY) < name = <"generator"> documentation = <"Generator of the value of this static property."> is_mandatory = type = <"BMM_ROUTINE_DEFINITION"> > > > ["BMM_STATIC"] = < name = <"BMM_STATIC"> documentation = <"Meta-type for static (i.e. read-only) properties."> ancestors = <"BMM_INSTANTIABLE_FEATURE", ...> is_abstract = > ["BMM_LOCAL_ROUTINE"] = < name = <"BMM_LOCAL_ROUTINE"> documentation = <"Meta-type for locally declared routine body."> ancestors = <"BMM_ROUTINE_DEFINITION", ...> properties = < ["locals"] = (P_BMM_CONTAINER_PROPERTY) < name = <"locals"> documentation = <"Local variables of the routine, if there is a body defined."> type_def = < container_type = <"List"> type = <"BMM_LOCAL"> > cardinality = <|>=0|> > ["body"] = (P_BMM_SINGLE_PROPERTY) < name = <"body"> documentation = <"Body of routine declaration."> is_mandatory = type = <"BMM_STATEMENT_BLOCK"> > > > ["BMM_OPERATOR_POSITION"] = (P_BMM_ENUMERATION_STRING) < name = <"BMM_OPERATOR_POSITION"> documentation = <"Enumeration of possible position of operator in a syntactic representation for operators associated with 1- and 2- degree functions."> ancestors = <"String", ...> item_names = <"prefix", "infix"> item_documentations = <"Prefix operator position: operator comes before operand.", "Infix operator position: operator comes between left and right operands."> > ["BMM_PARAMETER_DIRECTION"] = (P_BMM_ENUMERATION_STRING) < name = <"BMM_PARAMETER_DIRECTION"> documentation = <"Enumeration of parameter read/write direction values."> ancestors = <"String", ...> item_names = <"in", "out", "in_out"> item_documentations = <"Parameter is an input parameter, and treated as readonly by the receiving routine.", "Parameter is an output parameter, and treated as a reference to an entity writeable by the receiving routine.", "Parameter is an input and output parameter, and treated as a reference to an entity readable and writeable by the receiving routine."> > ["BMM_INTEGER_VALUE"] = < name = <"BMM_INTEGER_VALUE"> documentation = <"Meta-type for a literal Integer value, for which `_type_` is fixed to the `BMM_TYPE` representing `Integer` and `_value_` is of type `Integer`."> ancestors = <"BMM_PRIMITIVE_VALUE", ...> properties = < ["value"] = (P_BMM_SINGLE_PROPERTY) < name = <"value"> documentation = <"Native Integer value."> is_mandatory = type = <"Integer"> > > > ["BMM_STRING_VALUE"] = < name = <"BMM_STRING_VALUE"> documentation = <"Meta-type for a literal String value, for which `_type_` is fixed to the `BMM_TYPE` representing `String` and `_value_` is of type `String`."> ancestors = <"BMM_PRIMITIVE_VALUE", ...> properties = < ["value"] = (P_BMM_SINGLE_PROPERTY) < name = <"value"> documentation = <"Native String value."> is_mandatory = type = <"String"> > > > ["BMM_LITERAL_VALUE"] = < name = <"BMM_LITERAL_VALUE"> documentation = <"Meta-type for literal instance values declared in a model. Instance values may be inline values of primitive types in the usual fashion or complex objects in syntax form, e.g. JSON."> is_abstract = generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"BMM_TYPE"> > > properties = < ["value_literal"] = (P_BMM_SINGLE_PROPERTY) < name = <"value_literal"> documentation = <"A serial representation of the value."> is_mandatory = type = <"String"> > ["value"] = (P_BMM_SINGLE_PROPERTY) < name = <"value"> documentation = <"A native representation of the value, possibly derived by deserialising `_value_literal_`."> type = <"Any"> > ["syntax"] = (P_BMM_SINGLE_PROPERTY) < name = <"syntax"> documentation = <"Optional specification of formalism of the `_value_literal_` attribute for complex values. Value may be any of `json | json5 | yawl | xml | odin | rdf` or another value agreed by the user community. If not set, `json` is assumed."> type = <"String"> > ["type"] = (P_BMM_SINGLE_PROPERTY_OPEN) < name = <"type"> documentation = <"Concrete type of this literal."> is_mandatory = type = <"T"> > > > ["BMM_BOOLEAN_VALUE"] = < name = <"BMM_BOOLEAN_VALUE"> documentation = <"Meta-type for a literal Boolean value, for which `_type_` is fixed to the `BMM_TYPE` representing `Boolean` and `_value_` is of type `Boolean`."> ancestors = <"BMM_PRIMITIVE_VALUE", ...> properties = < ["value"] = (P_BMM_SINGLE_PROPERTY) < name = <"value"> documentation = <"Native Boolean value."> is_mandatory = type = <"Boolean"> > > > ["BMM_PRIMITIVE_VALUE"] = < name = <"BMM_PRIMITIVE_VALUE"> documentation = <"Meta-type for literals whose concrete type is a primitive type."> ancestors = <"BMM_UNITARY_VALUE", ...> properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Concrete type of this literal."> is_mandatory = type = <"BMM_SIMPLE_TYPE"> > > > ["BMM_CONTAINER_VALUE"] = < name = <"BMM_CONTAINER_VALUE"> documentation = <"Meta-type for literals whose concrete type is a linear container type, i.e. array, list or set."> ancestors = <"BMM_LITERAL_VALUE", ...> > ["BMM_UNITARY_VALUE"] = < name = <"BMM_UNITARY_VALUE"> documentation = <"Meta-type for literals whose concrete type is a unitary type in the BMM sense."> ancestors = <"BMM_LITERAL_VALUE", ...> is_abstract = generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"BMM_UNITARY_TYPE"> > > > ["BMM_INDEXED_CONTAINER_VALUE"] = < name = <"BMM_INDEXED_CONTAINER_VALUE"> documentation = <"Meta-type for literals whose concrete type is an indexed container, i.e. Hash table, Map etc."> ancestors = <"BMM_LITERAL_VALUE", ...> > ["BMM_INTERVAL_VALUE"] = < name = <"BMM_INTERVAL_VALUE"> documentation = <"Meta-type for literal intervals of type `Interval`."> ancestors = <"BMM_LITERAL_VALUE", ...> > ["BMM_MODEL"] = < name = <"BMM_MODEL"> documentation = <"Definition of the root of a BMM model (along with what is inherited from `BMM_SCHEMA_CORE`)."> ancestors = <"BMM_PACKAGE_CONTAINER", "BMM_MODEL_METADATA"> properties = < ["class_definitions"] = (P_BMM_GENERIC_PROPERTY) < name = <"class_definitions"> documentation = <"All classes in this model, keyed by type name."> type_def = < generic_parameters = <"String", "BMM_CLASS"> root_type = <"Hash"> > > ["used_models"] = (P_BMM_CONTAINER_PROPERTY) < name = <"used_models"> documentation = <"List of other models 'used' (i.e. 'imported' by this model). Classes in the current model may refer to classes in a used model by specifying the other class's `_scope_` meta-attribute."> type_def = < container_type = <"List"> type = <"BMM_MODEL"> > cardinality = <|>=0|> > ["modules"] = (P_BMM_GENERIC_PROPERTY) < name = <"modules"> documentation = <"All classes in this model, keyed by type name."> type_def = < generic_parameters = <"String", "BMM_MODULE"> root_type = <"Hash"> > > > functions = < ["model_id"] = < name = <"model_id"> documentation = <"Identifier of this model, lower-case, formed from: `__` E.g. `\"openehr_ehr_1.0.4\"`."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > ["class_definition"] = < name = <"class_definition"> documentation = <"Retrieve the class definition corresponding to `_a_type_name_` (which may contain a generic part)."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_CLASS"> > parameters = < ["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_name"> type = <"String"> > > > ["type_definition"] = < name = <"type_definition"> documentation = <"Retrieve the class definition corresponding to `_a_type_name_`. If it contains a generic part, this will be removed if it is a fully open generic name, otherwise it will remain intact, i.e. if it is an effective generic name that identifies a `BMM_GENERIC_CLASS_EFFECTIVE`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_CLASS"> > > ["has_class_definition"] = < name = <"has_class_definition"> documentation = <"True if `_a_class_name_` has a class definition in the model."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_class_name"> type = <"String"> > > > ["has_type_definition"] = < name = <"has_type_definition"> documentation = <"True if `_a_type_name_` is already concretely known in the system, including if it is generic, which may be open, partially open or closed."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_type_name"> type = <"String"> > > > ["enumeration_definition"] = < name = <"enumeration_definition"> documentation = <"Retrieve the enumeration definition corresponding to `_a_type_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_ENUMERATION"> > parameters = < ["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_name"> type = <"String"> > > > ["primitive_types"] = < name = <"primitive_types"> documentation = <"List of keys in `_class_definitions_` of items marked as primitive types."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["enumeration_types"] = < name = <"enumeration_types"> documentation = <"List of keys in `_class_definitions_` of items that are enumeration types."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > is_nullable = > ["property_definition"] = < name = <"property_definition"> documentation = <"Retrieve the property definition for `_a_prop_name_` in flattened class corresponding to `_a_type_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_PROPERTY"> > > ["ms_conformant_property_type"] = < name = <"ms_conformant_property_type"> documentation = <"True if `_a_ms_property_type_` is a valid 'MS' dynamic type for `_a_property_` in BMM type `_a_bmm_type_name_`. 'MS' conformance means 'model-semantic' conformance, which abstracts away container types like `List<>`, `Set<>` etc and compares the dynamic type with the relation target type in the UML sense, i.e. regardless of whether there is single or multiple containment."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_bmm_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_bmm_type_name"> type = <"String"> > ["a_bmm_property_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_bmm_property_name"> type = <"String"> > ["a_ms_property_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_ms_property_name"> type = <"String"> > > > ["property_definition_at_path"] = < name = <"property_definition_at_path"> documentation = <"Retrieve the property definition for `_a_property_path_` in flattened class corresponding to `_a_type_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_PROPERTY"> > > ["class_definition_at_path"] = < name = <"class_definition_at_path"> documentation = <"Retrieve the class definition for the class that owns the terminal attribute in `a_prop_path` in flattened class corresponding to `a_type_name`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_CLASS"> > parameters = < ["a_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_type_name"> type = <"String"> > ["a_prop_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_prop_path"> type = <"String"> > > > ["all_ancestor_classes"] = < name = <"all_ancestor_classes"> documentation = <"Return all ancestor types of `_a_class_name_` up to root class (usually `Any`, `Object` or something similar). Does not include current class. Returns empty list if none."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > parameters = < ["a_class"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_class"> type = <"String"> > > is_nullable = > ["is_descendant_of"] = < name = <"is_descendant_of"> documentation = <"True if `_a_class_name_` is a descendant in the model of `_a_parent_class_name_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_class_name"> type = <"String"> > ["a_parent_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_parent_class_name"> type = <"String"> > > > ["type_conforms_to"] = < name = <"type_conforms_to"> documentation = <"Check conformance of `_a_desc_type_` to `_an_anc_type_`; the types may be generic, and may contain open generic parameters like 'T' etc. These are replaced with their appropriate constrainer types, or Any during the conformance testing process. Conformance is found if: * [base class test] types are non-generic, and either type names are identical, or else `_a_desc_type_` has `_an_anc_type_` in its ancestors; * both types are generic and pass base class test; number of generic params matches, and each generic parameter type, after 'open parameter' substitution, recursively passes; `_type_name_conforms_to_` test * descendant type is generic and ancestor type is not, and they pass base classes test."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_desc_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_desc_type"> type = <"String"> > ["an_anc_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"an_anc_type"> type = <"String"> > > > ["subtypes"] = < name = <"subtypes"> documentation = <"Generate type substitutions for the supplied type, which may be simple, generic (closed, open or partially open), or a container type. In the generic and container cases, the result is the permutation of the base class type and type substitutions of all generic parameters."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"String"> > parameters = < ["a_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_type"> documentation = <"Name of a type."> type = <"String"> > > > ["any_class_definition"] = < name = <"any_class_definition"> documentation = <"`BMM_SIMPLE_CLASS` instance for the `Any` class. This may be defined in the BMM schema, but if not, use `BMM_DEFINITIONS._any_class_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_CLASS"> > > ["any_type_definition"] = < name = <"any_type_definition"> documentation = <"`BMM_SIMPLE_TYPE` instance for the `Any` type."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_TYPE"> > > ["boolean_type_definition"] = < name = <"boolean_type_definition"> documentation = <"`BMM_SIMPLE_TYPE` instance for the `Boolean` type."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_TYPE"> > > > invariants = < ["Inv_top_level_scope"] = <"scope = self"> > > ["BMM_MODEL_METADATA"] = < name = <"BMM_MODEL_METADATA"> documentation = <"Core properties of `BMM_MODEL`, may be used in a serial representation as well, such as `P_BMM_SCHEMA`."> properties = < ["rm_publisher"] = (P_BMM_SINGLE_PROPERTY) < name = <"rm_publisher"> documentation = <"Publisher of model expressed in the schema."> is_mandatory = type = <"String"> > ["rm_release"] = (P_BMM_SINGLE_PROPERTY) < name = <"rm_release"> documentation = <"Release of model expressed in the schema as a 3-part numeric, e.g. \"3.1.0\" . "> is_mandatory = type = <"String"> > > > ["BMM_PACKAGE"] = < name = <"BMM_PACKAGE"> documentation = <"Abstraction of a package as a tree structure whose nodes can contain other packages and classes. The `_name_` may be qualified if it is a top-level package."> ancestors = <"BMM_PACKAGE_CONTAINER", ...> properties = < ["members"] = (P_BMM_CONTAINER_PROPERTY) < name = <"members"> documentation = <"Member modules in this package."> type_def = < container_type = <"List"> type = <"BMM_MODULE"> > cardinality = <|>=0|> > > functions = < ["root_classes"] = < name = <"root_classes"> documentation = <"Obtain the set of top-level classes in this package, either from this package itself or by recursing into the structure until classes are obtained from child packages. Recurse into each child only far enough to find the first level of classes."> result = (P_BMM_CONTAINER_TYPE) < container_type = <"List"> type = <"BMM_CLASS"> > is_nullable = > ["path"] = < name = <"path"> documentation = <"Full path of this package back to root package."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["BMM_PACKAGE_CONTAINER"] = < name = <"BMM_PACKAGE_CONTAINER"> documentation = <"A BMM model component that contains packages and classes."> ancestors = <"BMM_MODEL_ELEMENT", ...> is_abstract = properties = < ["packages"] = (P_BMM_GENERIC_PROPERTY) < name = <"packages"> documentation = <"Child packages; keys all in upper case for guaranteed matching."> type_def = < generic_parameters = <"String", "BMM_PACKAGE"> root_type = <"Hash"> > > ["scope"] = (P_BMM_SINGLE_PROPERTY) < name = <"scope"> documentation = <"Model element within which a referenceable element is known."> is_mandatory = type = <"BMM_PACKAGE_CONTAINER"> > > functions = < ["package_at_path"] = < name = <"package_at_path"> documentation = <"Package at the path `_a_path_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_PACKAGE"> > parameters = < ["a_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_path"> type = <"String"> > > is_nullable = > ["do_recursive_packages"] = < name = <"do_recursive_packages"> documentation = <"Recursively execute `_action_`, which is a procedure taking a `BMM_PACKAGE` argument, on all members of packages."> result = (P_BMM_SIMPLE_TYPE) < type = <"void"> > parameters = < ["action"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"action"> type = <"EL_PROCEDURE_AGENT"> > > > ["has_package_path"] = < name = <"has_package_path"> documentation = <"True if there is a package at the path `_a_path_`; paths are delimited with delimiter `{BMM_DEFINITIONS} _Package_name_delimiter_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > parameters = < ["a_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) < name = <"a_path"> type = <"String"> > > > > > ["EL_BINARY_OPERATOR"] = < name = <"EL_BINARY_OPERATOR"> documentation = <"Binary operator expression node."> ancestors = <"EL_OPERATOR", ...> properties = < ["left_operand"] = (P_BMM_SINGLE_PROPERTY) < name = <"left_operand"> documentation = <"Left operand node."> is_mandatory = type = <"EL_EXPRESSION"> > ["right_operand"] = (P_BMM_SINGLE_PROPERTY) < name = <"right_operand"> documentation = <"Right operand node."> is_mandatory = type = <"EL_EXPRESSION"> > > > ["EL_EXPRESSION"] = < name = <"EL_EXPRESSION"> documentation = <"Abstract parent of all typed expression meta-types."> is_abstract = functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Meta-type of expression entity used in type-checking and evaluation. Effected in descendants."> is_abstract = result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > ["is_boolean"] = < name = <"is_boolean"> documentation = <"True if `_eval_type_` is notionally Boolean (i.e. a `BMM_SIMPLE_TYPE` with `_type_name()_` = `Boolean`)."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_result"] = <"Result = eval_type().equal( {BMM_MODEL}.boolean_type_definition())"> > > > > ["EL_LITERAL"] = < name = <"EL_LITERAL"> documentation = <"Literal value of any type known in the model, including primitive types. Defined via a `BMM_LITERAL_VALUE`."> ancestors = <"EL_SIMPLE", ...> properties = < ["value"] = (P_BMM_GENERIC_PROPERTY) < name = <"value"> documentation = <"The reference item from which the value of this node can be computed."> is_mandatory = type_def = < generic_parameters = <"BMM_TYPE", ...> root_type = <"BMM_LITERAL_VALUE"> > > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Return `_value.type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > > invariants = < ["Post_manifest_effective_type"] = <"Result = definition.type"> > > ["EL_OPERATOR"] = < name = <"EL_OPERATOR"> documentation = <"Abstract parent of operator types."> ancestors = <"EL_EXPRESSION", ...> is_abstract = properties = < ["precedence_overridden"] = (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"> > ["symbol"] = (P_BMM_SINGLE_PROPERTY) < name = <"symbol"> documentation = <"The symbol actually used in the expression, or intended to be used for serialisation. Must be a member of `OPERATOR_DEF._symbols_`."> type = <"String"> > ["call"] = (P_BMM_SINGLE_PROPERTY) < name = <"call"> documentation = <"Function call equivalent to this operator expression, inferred by matching operator against functions defined in interface of principal operand."> is_mandatory = type = <"EL_FUNCTION_CALL"> > > functions = < ["operator_definition"] = < name = <"operator_definition"> documentation = <"Operator definition derived from `_definition.operator_definition()_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_OPERATOR"> > > ["equivalent_call"] = < name = <"equivalent_call"> documentation = <"Function call equivalent to this operator."> result = (P_BMM_SIMPLE_TYPE) < type = <"EL_FUNCTION_CALL"> > > > invariants = < ["Symbol_validity"] = <"symbol /= Void implies operator_def.symbols.has (symbol)"> > > ["EL_UNARY_OPERATOR"] = < name = <"EL_UNARY_OPERATOR"> documentation = <"Unary operator expression node."> ancestors = <"EL_OPERATOR", ...> properties = < ["operand"] = (P_BMM_SINGLE_PROPERTY) < name = <"operand"> documentation = <"Operand node."> is_mandatory = type = <"EL_EXPRESSION"> > > > ["EL_PROPERTY_REF"] = < name = <"EL_PROPERTY_REF"> documentation = <"Reference to a writable property."> ancestors = <"EL_FEATURE_REF", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Property definition (within class)."> is_mandatory = type = <"BMM_PROPERTY"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> documentation = <"Defined to return True."> is_mandatory = type = <"Boolean"> default = > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Type definition (i.e. BMM meta-type definition object) of the constant, property or variable, inferred by inspection of the current scoping instance. Return `_definition.type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > > > ["EL_PREDICATE"] = < name = <"EL_PREDICATE"> documentation = <"Parent type of predicate of any object reference."> ancestors = <"EL_SIMPLE", ...> is_abstract = properties = < ["operand"] = (P_BMM_SINGLE_PROPERTY) < name = <"operand"> documentation = <"The target instance of this predicate."> is_mandatory = type = <"EL_VALUE_GENERATOR"> > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Return `{BMM_MODEL}._boolean_type_definition_()`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_SIMPLE_TYPE"> > > > > ["EL_DEFINED"] = < name = <"EL_DEFINED"> documentation = <"A predicate taking one external variable reference argument, that returns true if the reference is resolvable, i.e. the external value is obtainable. NOTE: probably to be removed."> ancestors = <"EL_PREDICATE", ...> > ["EL_FUNCTION_CALL"] = < name = <"EL_FUNCTION_CALL"> documentation = <"A call made on a closed function agent, returning a result. Equivalent to an 'application' of a function in Lambda calculus."> ancestors = <"EL_FEATURE_REF", "EL_AGENT_CALL"> properties = < ["agent"] = (P_BMM_SINGLE_PROPERTY) < name = <"agent"> documentation = <"The function agent being called."> is_mandatory = type = <"EL_FUNCTION_AGENT"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> documentation = <"Defined to return False."> is_mandatory = type = <"Boolean"> default = > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Return `_agent.definition.type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > ["reference"] = < name = <"reference"> documentation = <"Generated full reference name, consisting of any scoping elements, function name and routine parameters enclosed in parentheses."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > invariants = < ["Inv_valid_agent"] = <"agent.is_callable()"> > > ["EL_AGENT_CALL"] = < name = <"EL_AGENT_CALL"> documentation = <"A call made to a 'closed' agent, i.e. one with no remaining open arguments."> is_abstract = properties = < ["agent"] = (P_BMM_SINGLE_PROPERTY) < name = <"agent"> documentation = <"The agent being called."> is_mandatory = type = <"EL_AGENT"> > > invariants = < ["Inv_valid_call"] = <"agent.is_callable()"> > > ["EL_AGENT"] = < name = <"EL_AGENT"> documentation = <"A delayed routine call, whose arguments may be open, partially closed or closed. Generated by special reference to a routine, usually via a dedicated keyword, such as 'lambda' or 'agent', or other special syntax. Instances may include closed delayed calls like `calculate_age (dob=\"1987-09-13\", today=\"2019-06-03\")` but also partially open calls such as `format_structure (struct=?, style=3)`, where `struct` is an open argument. Evaluation type (i.e. type of runtime evaluated form) is `BMM_SIGNATURE`."> ancestors = <"EL_FEATURE_REF", ...> is_abstract = properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name of the routine being called."> is_mandatory = type = <"String"> > ["closed_args"] = (P_BMM_SINGLE_PROPERTY) < name = <"closed_args"> documentation = <"Closed arguments of a routine call as a tuple of objects."> type = <"EL_TUPLE"> > ["open_args"] = (P_BMM_CONTAINER_PROPERTY) < name = <"open_args"> documentation = <"Optional list of names of open arguments of the call. If not provided, and the `_name_` refers to a routine with more arguments than supplied in `_closed_args_`, the missing arguments are inferred from the `_definition_`."> type_def = < container_type = <"List"> type = <"String"> > cardinality = <|>=0|> > ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Reference to definition of a routine for which this is an agent, if one exists. "> type = <"BMM_ROUTINE"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> is_mandatory = type = <"Boolean"> default = > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Eval type is the signature corresponding to the (remaining) open arguments and return type, if any."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_ROUTINE_TYPE"> > post_conditions = < ["Post_result"] = <"Result = definition.signature"> > > ["is_callable"] = < name = <"is_callable"> documentation = <"True if there are no open arguments."> result = (P_BMM_SIMPLE_TYPE) < type = <"Boolean"> > post_conditions = < ["Post_result_validity"] = <"Result = open_arguments = Void"> > > ["reference"] = < name = <"reference"> documentation = <"Generated full reference name, including scoping elements."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["EL_TUPLE_ITEM"] = < name = <"EL_TUPLE_ITEM"> documentation = <"A single tuple item, with an optional name."> properties = < ["item"] = (P_BMM_SINGLE_PROPERTY) < name = <"item"> documentation = <"Reference to value entity. If Void, this indicates that the item in this position is Void, e.g. within a routine call parameter list."> type = <"EL_EXPRESSION"> > ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Optional name of tuple item."> type = <"String"> > > > ["EL_PROCEDURE_AGENT"] = < name = <"EL_PROCEDURE_AGENT"> documentation = <"An agent whose signature is of a procedure, i.e. has no result type."> ancestors = <"EL_AGENT", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Reference to definition of routine for which this is a call instance."> type = <"BMM_PROCEDURE"> > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Eval type is the signature corresponding to the (remaining) open arguments and return type, if any."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_PROCEDURE_TYPE"> > post_conditions = < ["Post_result"] = <"Result = definition.signature"> > > > > ["EL_TUPLE"] = < name = <"EL_TUPLE"> documentation = <"Defines an array of optionally named items each of any type."> ancestors = <"EL_EXPRESSION", ...> properties = < ["items"] = (P_BMM_CONTAINER_PROPERTY) < name = <"items"> documentation = <"Items in the tuple, potentially with names. Typical use is to represent an argument list to routine call."> type_def = < container_type = <"List"> type = <"EL_TUPLE_ITEM"> > cardinality = <|>=0|> > ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Static type inferred from literal value."> is_mandatory = type = <"BMM_TUPLE_TYPE"> > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Return `_type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > > > ["EL_FUNCTION_AGENT"] = < name = <"EL_FUNCTION_AGENT"> documentation = <"An agent whose signature is of a function, i.e. has a result type."> ancestors = <"EL_AGENT", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Reference to definition of a routine for which this is a direct call instance, if one exists. "> type = <"BMM_FUNCTION"> > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Eval type is the signature corresponding to the (remaining) open arguments and return type, if any."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_FUNCTION_TYPE"> > post_conditions = < ["Post_result"] = <"Result = definition.signature"> > > > > ["EL_ATTACHED"] = < name = <"EL_ATTACHED"> documentation = <"A predicate on any object reference (including function call) that returns True if the reference is attached, i.e. non-Void."> ancestors = <"EL_PREDICATE", ...> > ["EL_VALUE_GENERATOR"] = < name = <"EL_VALUE_GENERATOR"> documentation = <"Meta-type representing a value-generating simple expression."> ancestors = <"EL_SIMPLE", ...> is_abstract = properties = < ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> is_mandatory = type = <"Boolean"> > ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> documentation = <"Name used to represent the reference or other entity."> is_mandatory = type = <"String"> > > functions = < ["reference"] = < name = <"reference"> documentation = <"Generated full reference name, based on constituent parts of the entity. Default version outputs `_name_` field."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["EL_BOOLEAN_EXPRESSION"] = < name = <"EL_BOOLEAN_EXPRESSION"> documentation = <"Boolean-returning expression."> ancestors = <"EL_CONSTRAINED", ...> invariants = < ["Inv_boolean_expression"] = <"base_expression.is_boolean()"> > > ["EL_TYPE_REF"] = < name = <"EL_TYPE_REF"> documentation = <"Meta-type for reference to a non-abstract type as an object. Assumed to be accessible at run-time. Typically represented syntactically as `TypeName` or `{TypeName}`. May be used as a value, or as the qualifier for a function or constant access."> ancestors = <"EL_VALUE_GENERATOR", ...> properties = < ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"Type, directly from the name of the reference, e.g. `{SOME_TYPE}`."> is_mandatory = type = <"BMM_TYPE"> > ["is_mutable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_mutable"> is_mandatory = type = <"Boolean"> default = > > functions = < ["eval_type"] = < name = <"eval_type"> documentation = <"Return `_type_`."> result = (P_BMM_SIMPLE_TYPE) < type = <"BMM_TYPE"> > > > invariants = < ["Inv_no_context"] = <"context = Void"> > > ["EL_FEATURE_REF"] = < name = <"EL_FEATURE_REF"> documentation = <"A reference that is scoped by a containing entity and requires a context qualifier if it is not the currently scoping entity."> ancestors = <"EL_VALUE_GENERATOR", ...> is_abstract = properties = < ["scoper"] = (P_BMM_SINGLE_PROPERTY) < name = <"scoper"> documentation = <"Scoping expression, which must be a `EL_VALUE_GENERATOR`."> type = <"EL_VALUE_GENERATOR"> > > functions = < ["reference"] = < name = <"reference"> documentation = <"Generated full reference name, consisting of scoping elements and `_name_` concatenated using dot notation."> result = (P_BMM_SIMPLE_TYPE) < type = <"String"> > > > > ["EL_CONDITIONAL_EXPRESSION"] = < name = <"EL_CONDITIONAL_EXPRESSION"> documentation = <"Conditional structure used in condition chain expressions. Evaluated by evaluating its `_condition_`, which is a Boolean-returning expression, and if this returns True, the result is the evaluation result of `_expression_`."> ancestors = <"EL_DECISION_BRANCH", ...> generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["condition"] = (P_BMM_SINGLE_PROPERTY) < name = <"condition"> documentation = <"Boolean expression defining the condition of this decision branch."> is_mandatory = type = <"EL_EXPRESSION"> > > invariants = < ["Inv_condition_boolean"] = <"condition.is_boolean()"> > > ["EL_CONDITION_CHAIN"] = < name = <"EL_CONDITION_CHAIN"> documentation = <"Compound expression consisting of a chain of condition-gated expressions, and an ungated `_else_` member that as a whole, represents an if/then/elseif/else chains. Evaluated by iterating through `_items_` and for each one, evaluating its `_condition_`, which if True, causes the evaluation result of the chain to be that item's `_result_` evaluation result. If no member of `_items_` has a True-returning `_condition_`, the evaluation result is the result of evaluating the `_else_` expression."> ancestors = <"EL_DECISION_TABLE", ...> generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["items"] = (P_BMM_CONTAINER_PROPERTY) < name = <"items"> documentation = <"Members of the chain, equivalent to branches in an if/then/else chain and cases in a case statement."> is_mandatory = type_def = < container_type = <"List"> type_def = (P_BMM_GENERIC_TYPE) < generic_parameters = <"T", ...> root_type = <"EL_CONDITIONAL_EXPRESSION"> > > cardinality = <|>=1|> > > > ["EL_CONSTRAINED"] = < name = <"EL_CONSTRAINED"> documentation = <"Abstract parent for second-order constrained forms of first-order expression meta-types."> ancestors = <"EL_EXPRESSION", ...> is_abstract = properties = < ["base_expression"] = (P_BMM_SINGLE_PROPERTY) < name = <"base_expression"> documentation = <"The base expression of this constrained form."> is_mandatory = type = <"EL_EXPRESSION"> > > > ["EL_CASE_TABLE"] = < name = <"EL_CASE_TABLE"> documentation = <"Compound expression consisting of a list of value-range / expression pairs, and an `_else_` member that as a whole, represents a case statement flavour of decision table. Evaluated by iterating through `_items_` and for each one, comparing `_input_` to the item `_value_range_`. If the `_input_` is in the range, the evaluation result of the table is that item's `_result_` evaluation result. If no member of `_items_` has a True-returning `_condition_`, the evaluation result is the result of evaluating the `_else_` expression."> ancestors = <"EL_DECISION_TABLE", ...> generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["items"] = (P_BMM_CONTAINER_PROPERTY) < name = <"items"> documentation = <"Members of the chain, equivalent to branches in an if/then/else chain and cases in a case statement."> is_mandatory = type_def = < container_type = <"List"> type_def = (P_BMM_GENERIC_TYPE) < generic_parameters = <"T", ...> root_type = <"EL_CASE"> > > cardinality = <|>=1|> > ["test_value"] = (P_BMM_SINGLE_PROPERTY) < name = <"test_value"> documentation = <"Expressing generating the input value for the case table."> is_mandatory = type = <"EL_VALUE_GENERATOR"> > > > ["EL_CASE"] = < name = <"EL_CASE"> documentation = <"One branch of a Case table, consisting of a value constraint (the match criterion) and a result, of the generic parameter type T."> ancestors = <"EL_DECISION_BRANCH", ...> generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["value_constraint"] = (P_BMM_SINGLE_PROPERTY) < name = <"value_constraint"> documentation = <"Constraint on "> is_mandatory = type = <"C_OBJECT"> > > > ["EL_DECISION_TABLE"] = < name = <"EL_DECISION_TABLE"> documentation = <"Meta-type for decision tables. Generic on the meta-type of the `_result_` attribute of the branches, to allow specialised forms of if/else and case structures to be created."> ancestors = <"EL_TERMINAL", ...> is_abstract = generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["items"] = (P_BMM_CONTAINER_PROPERTY) < name = <"items"> documentation = <"Members of the chain, equivalent to branches in an if/then/else chain and cases in a case statement."> is_mandatory = type_def = < container_type = <"List"> type_def = (P_BMM_GENERIC_TYPE) < generic_parameters = <"T", ...> root_type = <"EL_DECISION_BRANCH"> > > cardinality = <|>=1|> > ["else"] = (P_BMM_SINGLE_PROPERTY) < name = <"else"> documentation = <"Result expression of conditional, if its `_condition_` evaluates to True."> is_mandatory = type = <"T"> > > > ["EL_DECISION_BRANCH"] = < name = <"EL_DECISION_BRANCH"> documentation = <"Abstract parent of meta-types representing a branch of some kind of decision structure. Defines `result` as being of the generic type `T`."> is_abstract = generic_parameter_defs = < ["T"] = < name = <"T"> conforms_to_type = <"EL_TERMINAL"> > > properties = < ["result"] = (P_BMM_SINGLE_PROPERTY) < name = <"result"> documentation = <"Result expression of conditional, if its `_condition_` evaluates to True."> is_mandatory = type = <"T"> > > > ["EL_VARIABLE"] = < name = <"EL_VARIABLE"> documentation = <"Abstract meta-type of any kind of symbolic variable."> ancestors = <"EL_VALUE_GENERATOR", ...> is_abstract = > ["EL_TERMINAL"] = < name = <"EL_TERMINAL"> documentation = <"Expression entities that are terminals (i.e. leaves) within operator expressions or tuples."> ancestors = <"EL_EXPRESSION", ...> is_abstract = > ["EL_SIMPLE"] = < name = <"EL_SIMPLE"> documentation = <"Simple terminal i.e. logically atomic expression element."> ancestors = <"EL_TERMINAL", ...> is_abstract = > ["EL_STATIC_REF"] = < name = <"EL_STATIC_REF"> documentation = <"Reference to a writable property, either a constant or computed."> ancestors = <"EL_FEATURE_REF", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Constant definition (within class)."> is_mandatory = type = <"BMM_STATIC"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> documentation = <"Defined to return False."> is_mandatory = type = <"Boolean"> default = > > > ["EL_WRITABLE_VARIABLE"] = < name = <"EL_WRITABLE_VARIABLE"> documentation = <"Meta-type of writable variables, including routine locals and the special variable 'Result'."> ancestors = <"EL_VARIABLE", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Variable definition to which this reference refers."> is_mandatory = type = <"BMM_WRITABLE_VARIABLE"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> documentation = <"Defined to return True in all cases."> is_mandatory = type = <"Boolean"> default = > > > ["EL_READONLY_VARIABLE"] = < name = <"EL_READONLY_VARIABLE"> documentation = <"Meta-type of read-only variables, including routine parameter and the special variable 'Self'."> ancestors = <"EL_VARIABLE", ...> properties = < ["definition"] = (P_BMM_SINGLE_PROPERTY) < name = <"definition"> documentation = <"Variable definition to which this reference refers."> is_mandatory = type = <"BMM_READONLY_VARIABLE"> > ["is_writable"] = (P_BMM_SINGLE_PROPERTY) < name = <"is_writable"> documentation = <"Defined to return False in all cases."> is_mandatory = type = <"Boolean"> default = > > > ["BMM_ACTION_DECISION_TABLE"] = < name = <"BMM_ACTION_DECISION_TABLE"> documentation = <"Specialised form of Decision Table that allows only procedure call agents (lambdas) as the result of branches."> > ["BMM_ACTION_TABLE"] = < name = <"BMM_ACTION_TABLE"> documentation = <"Multi-branch conditional statement structure"> ancestors = <"BMM_STATEMENT", ...> properties = < ["decision_table"] = (P_BMM_SINGLE_PROPERTY) < name = <"decision_table"> documentation = <"A specialised decision table whose outputs can only be procedure agents. In execution, the matched agent will be invoked."> is_mandatory = type = <"BMM_ACTION_DECISION_TABLE"> > > > ["BMM_ASSIGNMENT"] = < name = <"BMM_ASSIGNMENT"> documentation = <"Statement type representing an assignment from a value-generating source to a writable entity, i.e. a variable reference or property. At the meta-model level, may be understood as an initialisation of an existing meta-model instance."> ancestors = <"BMM_SIMPLE_STATEMENT", ...> properties = < ["target"] = (P_BMM_SINGLE_PROPERTY) < name = <"target"> documentation = <"The target variable on the notional left-hand side of this assignment."> is_mandatory = type = <"EL_VALUE_GENERATOR"> > ["source"] = (P_BMM_SINGLE_PROPERTY) < name = <"source"> documentation = <"Source right hand side) of the assignment."> is_mandatory = type = <"EL_EXPRESSION"> > > invariants = < ["Inv_target_writable"] = <"target.is_writable"> > > ["BMM_ASSERTION"] = < name = <"BMM_ASSERTION"> documentation = <"A statement that asserts the truth of its expression. If the expression evaluates to False the execution generates an exception (depending on run-time settings). May be rendered in syntax as `assert condition` or similar."> ancestors = <"BMM_SIMPLE_STATEMENT", ...> properties = < ["expression"] = (P_BMM_SINGLE_PROPERTY) < name = <"expression"> documentation = <"Boolean-valued expression of the assertion."> is_mandatory = type = <"EL_BOOLEAN_EXPRESSION"> > ["tag"] = (P_BMM_SINGLE_PROPERTY) < name = <"tag"> documentation = <"Optional tag, typically used to designate design intention of the assertion, e.g. `\"Inv_all_members_valid\"`."> type = <"String"> > > > ["BMM_PROCEDURE_CALL"] = < name = <"BMM_PROCEDURE_CALL"> documentation = <"A call made on a closed procedure agent. The method in BMM via which external actions are achieved from within a program."> ancestors = <"EL_AGENT_CALL", "BMM_SIMPLE_STATEMENT"> properties = < ["agent"] = (P_BMM_SINGLE_PROPERTY) < name = <"agent"> documentation = <"The procedure agent being called."> is_mandatory = type = <"EL_PROCEDURE_AGENT"> > > invariants = < ["Inv_valid_agent"] = <"agent.is_callable()"> > > ["BMM_STATEMENT_ITEM"] = < name = <"BMM_STATEMENT_ITEM"> documentation = <"Abstract parent of statement types representing a locally defined routine body."> is_abstract = > ["BMM_STATEMENT"] = < name = <"BMM_STATEMENT"> documentation = <"Abstract parent of 'statement' types that may be defined to implement BMM Routines."> ancestors = <"BMM_STATEMENT_ITEM", ...> is_abstract = > ["BMM_STATEMENT_BLOCK"] = < name = <"BMM_STATEMENT_BLOCK"> documentation = <"A statement 'block' corresponding to the programming language concept of the same name. May be used to establish scope in specific languages."> ancestors = <"BMM_STATEMENT_ITEM", ...> properties = < ["items"] = (P_BMM_CONTAINER_PROPERTY) < name = <"items"> documentation = <"Child blocks of the current block."> type_def = < container_type = <"List"> type = <"BMM_STATEMENT_ITEM"> > cardinality = <|>=0|> > > > ["BMM_SIMPLE_STATEMENT"] = < name = <"BMM_SIMPLE_STATEMENT"> documentation = <"Simple statement, i.e. statement with one logical element - a single expression, procedure call etc."> ancestors = <"BMM_STATEMENT", ...> is_abstract = > ["BMM_DECLARATION"] = < name = <"BMM_DECLARATION"> documentation = <"Declaration of a writable variable, associating a name with a type."> ancestors = <"BMM_SIMPLE_STATEMENT", ...> properties = < ["name"] = (P_BMM_SINGLE_PROPERTY) < name = <"name"> is_mandatory = type = <"String"> > ["result"] = (P_BMM_SINGLE_PROPERTY) < name = <"result"> is_mandatory = type = <"EL_WRITABLE_VARIABLE"> > ["type"] = (P_BMM_SINGLE_PROPERTY) < name = <"type"> documentation = <"The declared type of the variable."> is_mandatory = type = <"BMM_TYPE"> > > > >