(************************************************************************) (* Mon Mar 20 18:11:57 2000 *) (* This HTML file is produced by *) (* The EXPRESS Data Manager EXPRESS Compiler version 9.00 *) (************************************************************************)
SCHEMA iso13584_g_m_iim_schema;
CONSTANT SEP_ID : STRING := '.'; DET_CLASSIFICATION_LEN : INTEGER := 3; VALUE_CODE_LEN : INTEGER := 18; HTTP_DIRECTORY_NAME_LENGTH : INTEGER := 8; SEP_CV : STRING := '-'; CLASS_CODE_LEN : INTEGER := 14; PREF_NAME_LEN : INTEGER := 30; DATA_TYPE_CODE_LEN : INTEGER := 14; SOURCE_DOC_LEN : INTEGER := 80; SHORT_NAME_LEN : INTEGER := 15; SYN_NAME_LEN: INTEGER := PREF_NAME_LEN; PROPERTY_CODE_LEN : INTEGER := 14; SUPPLIER_CODE_LEN : INTEGER := 18; VERSION_LEN : INTEGER := 3; REVISION_LEN : INTEGER := 3; ELEMENT_CODE_LEN : INTEGER := 14; EXTERNAL_FILE_ADDRESS_LENGTH : INTEGER := 18; HTTP_FILE_NAME_LENGTH : INTEGER := 12; VALUE_FORMAT_LEN : INTEGER := 80; EXTERNAL_ITEM_CODE_LENGTH : INTEGER := 18; END_CONSTANT;
TYPE det_classification_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) = DET_CLASSIFICATION_LEN; END_TYPE;
TYPE integer_type = INTEGER; END_TYPE;
TYPE value_code_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= VALUE_CODE_LEN; END_TYPE;
TYPE language_code = IDENTIFIER; END_TYPE;
TYPE http_directory_name_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= HTTP_DIRECTORY_NAME_LENGTH; wr2 : NOT (SELF LIKE '* *'); END_TYPE;
TYPE class_code_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) <= CLASS_CODE_LEN; END_TYPE;
TYPE identifier = STRING; END_TYPE;
TYPE data_type_code_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) = DATA_TYPE_CODE_LEN; END_TYPE;
TYPE date_type = STRING(10) FIXED; END_TYPE;
TYPE source_doc_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= SOURCE_DOC_LEN; END_TYPE;
TYPE currency_code = IDENTIFIER; WHERE wr1 : LENGTH(SELF) = 3; END_TYPE;
TYPE pref_name_type = TRANSLATABLE_LABEL; WHERE wr1 : CHECK_LABEL_LENGTH(SELF,PREF_NAME_LEN); END_TYPE;
TYPE short_name_type = TRANSLATABLE_LABEL; WHERE wr1 : CHECK_LABEL_LENGTH(SELF,SHORT_NAME_LEN); END_TYPE;
TYPE label = STRING; END_TYPE;
TYPE text = STRING; END_TYPE;
TYPE property_code_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) <= PROPERTY_CODE_LEN; END_TYPE;
TYPE supplier_code_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) <= SUPPLIER_CODE_LEN; END_TYPE;
TYPE version_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) = VERSION_LEN; wr2 : SELF LIKE '###'; END_TYPE;
TYPE boolean_value = BOOLEAN; END_TYPE;
TYPE integer_value = INTEGER; END_TYPE;
TYPE real_value = REAL; END_TYPE;
TYPE string_value = STRING; END_TYPE;
TYPE revision_type = CODE_TYPE; WHERE wr1 : LENGTH(SELF) <= REVISION_LEN; END_TYPE;
TYPE note_type = TRANSLATABLE_TEXT; END_TYPE;
TYPE remark_type = TRANSLATABLE_TEXT; END_TYPE;
TYPE document_code_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= ELEMENT_CODE_LEN; END_TYPE;
TYPE table_code_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= ELEMENT_CODE_LEN; END_TYPE;
TYPE external_file_address = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= EXTERNAL_FILE_ADDRESS_LENGTH; wr2 : NOT (SELF LIKE '* *'); END_TYPE;
TYPE content_encoding_type = IDENTIFIER; WHERE wr1: (SELF = '7bit') OR (SELF = '8bit') OR (SELF = 'binary') OR (SELF = 'quoted-printable') OR (SELF = 'base64'); END_TYPE;
TYPE MIME_type = IDENTIFIER; WHERE WR1: NOT(SELF LIKE '* *'); END_TYPE;
TYPE MIME_subtype = IDENTIFIER; WHERE WR1: NOT(SELF LIKE '* *'); END_TYPE;
TYPE iab_rfc = INTEGER; WHERE wr1 : SELF > 0; END_TYPE;
TYPE http_file_name_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= HTTP_FILE_NAME_LENGTH; wr2 : NOT (SELF LIKE '* *'); wr3 : NOT (SELF LIKE '*.*.*'); wr4 : ((SELF LIKE '*.??') AND (LENGTH(SELF) <= HTTP_FILE_NAME_LENGTH - 1)) OR (SELF LIKE '*.???'); END_TYPE;
TYPE absolute_url_type = IDENTIFIER; WHERE wr1 : SELF LIKE '*://:*'; END_TYPE;
TYPE character_set_type = IDENTIFIER; END_TYPE;
TYPE si_prefix = ENUMERATION OF (exa,peta,tera,giga,mega,kilo,hecto,deca,deci,centi,milli,micro,nano,pico, femto,atto); END_TYPE;
TYPE si_unit_name = ENUMERATION OF (metre,gram,second,ampere,kelvin,mole,candela,radian,steradian,hertz,newton, pascal,joule,watt,coulomb,volt,farad,ohm,siemens,weber,tesla,henry, degree_celsius,lumen,lux,becquerel,gray,sievert); END_TYPE;
TYPE dimension_count = INTEGER; WHERE wr1 : SELF > 0; END_TYPE;
TYPE value_format_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= VALUE_FORMAT_LEN; END_TYPE;
TYPE code_type = IDENTIFIER; WHERE wr1 : NOT (SELF LIKE '*.*'); wr2 : NOT (SELF LIKE '*-*'); wr3 : NOT (SELF LIKE '* *'); END_TYPE;
TYPE level = ENUMERATION OF (min,nom,typ,max); END_TYPE;
TYPE year_number = INTEGER; END_TYPE;
TYPE definition_type = TRANSLATABLE_TEXT; END_TYPE;
TYPE external_item_code_type = IDENTIFIER; WHERE wr1 : LENGTH(SELF) <= EXTERNAL_ITEM_CODE_LENGTH; wr2 : NOT (SELF LIKE '* *'); END_TYPE;
TYPE property_semantics_or_path = SELECT (PROPERTY_SEMANTICS,SUB_PROPERTY_PATH); END_TYPE;
TYPE unit = SELECT (NAMED_UNIT,DERIVED_UNIT); END_TYPE;
TYPE value_type = SELECT (VALUE_CODE_TYPE,INTEGER_TYPE); END_TYPE;
TYPE syn_name_type = SELECT (LABEL_WITH_LANGUAGE, LABEL); WHERE wr1 : CHECK_SYN_LENGTH(SELF,SYN_NAME_LEN); END_TYPE;
TYPE primitive_value = SELECT (SIMPLE_VALUE,COMPLEX_VALUE); END_TYPE;
TYPE library_expression = SELECT (EXPRESSION,LEVEL_SPEC_EXPRESSION,ENTITY_INSTANCE_EXPRESSION, CLASS_INSTANCE_EXPRESSION); END_TYPE;
TYPE entity_instance_value = SELECT (DEFINED_ENTITY_INSTANCE_VALUE); END_TYPE;
TYPE defined_entity_instance_value=SELECT( PLACEMENT, AXIS1_PLACEMENT, AXIS2_PLACEMENT_2D, AXIS2_PLACEMENT_3D); END_TYPE;
TYPE library_variable = SELECT (LEVEL_SPEC_VARIABLE,ENTITY_INSTANCE_VARIABLE,CLASS_INSTANCE_VARIABLE); END_TYPE;
TYPE boolean_expression_or_others = SELECT (OTHERS, BOOLEAN_EXPRESSION); END_TYPE;
TYPE illustration_type = ENUMERATION OF ( schematic_drawing, realistic_picture, not_static_picture); END_TYPE;
TYPE measure_value = SELECT (LENGTH_MEASURE, MASS_MEASURE, TIME_MEASURE, ELECTRIC_CURRENT_MEASURE, THERMODYNAMIC_TEMPERATURE_MEASURE, AMOUNT_OF_SUBSTANCE_MEASURE, LUMINOUS_INTENSITY_MEASURE, PLANE_ANGLE_MEASURE, SOLID_ANGLE_MEASURE, AREA_MEASURE, VOLUME_MEASURE, RATIO_MEASURE, PARAMETER_VALUE, NUMERIC_MEASURE, CONTEXT_DEPENDENT_MEASURE, DESCRIPTIVE_MEASURE, POSITIVE_LENGTH_MEASURE, POSITIVE_PLANE_ANGLE_MEASURE, POSITIVE_RATIO_MEASURE, COUNT_MEASURE); END_TYPE;
TYPE length_measure = REAL; END_TYPE;
TYPE mass_measure = REAL; END_TYPE;
TYPE time_measure = REAL; END_TYPE;
TYPE electric_current_measure = REAL; END_TYPE;
TYPE thermodynamic_temperature_measure = REAL; END_TYPE;
TYPE amount_of_substance_measure = REAL; END_TYPE;
TYPE luminous_intensity_measure = REAL; END_TYPE;
TYPE plane_angle_measure = REAL; END_TYPE;
TYPE solid_angle_measure = REAL; END_TYPE;
TYPE area_measure = REAL; END_TYPE;
TYPE volume_measure = REAL; END_TYPE;
TYPE ratio_measure = REAL; END_TYPE;
TYPE parameter_value = REAL; END_TYPE;
TYPE numeric_measure = NUMBER; END_TYPE;
TYPE positive_length_measure = LENGTH_MEASURE; WHERE wr1: SELF > 0; END_TYPE;
TYPE positive_plane_angle_measure = PLANE_ANGLE_MEASURE; WHERE wr1: SELF > 0; END_TYPE;
TYPE positive_ratio_measure = RATIO_MEASURE; WHERE wr1: SELF > 0; END_TYPE;
TYPE context_dependent_measure = REAL; END_TYPE;
TYPE descriptive_measure = STRING; END_TYPE;
TYPE count_measure = NUMBER; END_TYPE;
TYPE translatable_label = SELECT (TRANSLATED_LABEL, LABEL); END_TYPE;
TYPE property_or_data_type_bsu = SELECT (PROPERTY_BSU,DATA_TYPE_BSU); END_TYPE;
TYPE simple_value = SELECT (NUMBER_VALUE,STRING_VALUE,BOOLEAN_VALUE); END_TYPE;
TYPE complex_value = SELECT (ENTITY_INSTANCE_VALUE,LEVEL_SPEC_VALUE,DIC_CLASS_INSTANCE); END_TYPE;
TYPE number_value = SELECT (INTEGER_VALUE,REAL_VALUE); END_TYPE;
TYPE translatable_text = SELECT (TRANSLATED_TEXT, TEXT); END_TYPE;
TYPE vector_or_direction = SELECT (VECTOR,DIRECTION); END_TYPE;
TYPE person_organization_select = SELECT (PERSON,ORGANIZATION); END_TYPE;
TYPE axis2_placement = SELECT (AXIS2_PLACEMENT_2D,AXIS2_PLACEMENT_3D); END_TYPE;
TYPE trimming_select = SELECT (CARTESIAN_POINT); END_TYPE;
ENTITY environment; syntactic_representation : GENERIC_VARIABLE; semantics : VARIABLE_SEMANTICS; END_ENTITY;
ENTITY abs_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY acos_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY and_expression SUBTYPE OF (MULTIPLE_ARITY_BOOLEAN_EXPRESSION); END_ENTITY;
ENTITY asin_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY atan_function SUBTYPE OF (BINARY_FUNCTION_CALL); END_ENTITY;
ENTITY boolean_literal SUBTYPE OF (SIMPLE_BOOLEAN_EXPRESSION,GENERIC_LITERAL); the_value : BOOLEAN; END_ENTITY;
ENTITY boolean_variable SUBTYPE OF (SIMPLE_BOOLEAN_EXPRESSION,VARIABLE); END_ENTITY;
ENTITY comparison_equal SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY comparison_greater SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY comparison_greater_equal SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY comparison_less SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY comparison_less_equal SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY comparison_not_equal SUBTYPE OF (COMPARISON_EXPRESSION); END_ENTITY;
ENTITY concat_expression SUBTYPE OF (STRING_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF STRING_EXPRESSION; END_ENTITY;
ENTITY cos_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY div_expression SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY equals_expression SUBTYPE OF (BINARY_BOOLEAN_EXPRESSION); END_ENTITY;
ENTITY exp_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY format_function SUBTYPE OF (STRING_EXPRESSION,BINARY_GENERIC_EXPRESSION); DERIVE value_to_format : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION. operands[1]; format_string : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION. operands[2]; WHERE wr1 : (('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION') IN TYPEOF( value_to_format)) AND (( 'ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION') IN TYPEOF( format_string)); END_ENTITY;
ENTITY index_expression SUBTYPE OF (STRING_EXPRESSION,BINARY_GENERIC_EXPRESSION); DERIVE operand : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[1]; index : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[2]; WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(index )); wr2 : IS_INT_EXPR(index); END_ENTITY;
ENTITY interval_expression SUBTYPE OF (BOOLEAN_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); DERIVE interval_low : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[1]; interval_item : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION .operands[2]; interval_high : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION .operands[3]; WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.EXPRESSION' IN TYPEOF(interval_low)) AND ('ISO13584_G_M_IIM_SCHEMA.EXPRESSION' IN TYPEOF(interval_item )) AND ('ISO13584_G_M_IIM_SCHEMA.EXPRESSION' IN TYPEOF( interval_high)); wr2 : (('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF. interval_low)) AND ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF.interval_high)) AND ( 'ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF. interval_item))) OR (('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF.interval_low)) AND ( 'ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(SELF. interval_item)) AND ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(SELF.interval_high))); END_ENTITY;
ENTITY int_literal SUBTYPE OF (LITERAL_NUMBER); SELF\literal_number.the_value : INTEGER; END_ENTITY;
ENTITY int_numeric_variable SUBTYPE OF (NUMERIC_VARIABLE); END_ENTITY;
ENTITY int_value_function SUBTYPE OF (VALUE_FUNCTION); END_ENTITY;
ENTITY length_function SUBTYPE OF (NUMERIC_EXPRESSION,UNARY_GENERIC_EXPRESSION); SELF\unary_generic_expression.operand : STRING_EXPRESSION; END_ENTITY;
ENTITY like_expression SUBTYPE OF (COMPARISON_EXPRESSION); WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF\ COMPARISON_EXPRESSION.operands[1])) AND ( 'ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF\ COMPARISON_EXPRESSION.operands[2])); END_ENTITY;
ENTITY log_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY log2_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY log10_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY maximum_function SUBTYPE OF (MULTIPLE_ARITY_FUNCTION_CALL); END_ENTITY;
ENTITY minimum_function SUBTYPE OF (MULTIPLE_ARITY_FUNCTION_CALL); END_ENTITY;
ENTITY minus_expression SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY minus_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY mod_expression SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY mult_expression SUBTYPE OF (MULTIPLE_ARITY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY not_expression SUBTYPE OF (UNARY_BOOLEAN_EXPRESSION); SELF\unary_generic_expression.operand : BOOLEAN_EXPRESSION; END_ENTITY;
ENTITY odd_function SUBTYPE OF (UNARY_BOOLEAN_EXPRESSION); SELF\unary_generic_expression.operand : NUMERIC_EXPRESSION; WHERE wr1 : IS_INT_EXPR(SELF\NUMERIC_EXPRESSION); END_ENTITY;
ENTITY or_expression SUBTYPE OF (MULTIPLE_ARITY_BOOLEAN_EXPRESSION); END_ENTITY;
ENTITY plus_expression SUBTYPE OF (MULTIPLE_ARITY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY power_expression SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY real_literal SUBTYPE OF (LITERAL_NUMBER); SELF\literal_number.the_value : REAL; END_ENTITY;
ENTITY real_numeric_variable SUBTYPE OF (NUMERIC_VARIABLE); END_ENTITY;
ENTITY sin_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY slash_expression SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY square_root_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY string_literal SUBTYPE OF (SIMPLE_STRING_EXPRESSION,GENERIC_LITERAL); the_value : STRING; END_ENTITY;
ENTITY string_variable SUBTYPE OF (SIMPLE_STRING_EXPRESSION,VARIABLE); END_ENTITY;
ENTITY substring_expression SUBTYPE OF (STRING_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); DERIVE operand : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[1]; index1 : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[2]; index2 : GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[3]; WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF( index1)) AND ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(index2)); wr2 : SIZEOF(SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands) = 3; wr3 : IS_INT_EXPR(index1); wr4 : IS_INT_EXPR(index2); END_ENTITY;
ENTITY tan_function SUBTYPE OF (UNARY_FUNCTION_CALL); END_ENTITY;
ENTITY value_function SUPERTYPE OF (INT_VALUE_FUNCTION) SUBTYPE OF (NUMERIC_EXPRESSION,UNARY_GENERIC_EXPRESSION); SELF\unary_generic_expression.operand : STRING_EXPRESSION; END_ENTITY;
ENTITY xor_expression SUBTYPE OF (BINARY_BOOLEAN_EXPRESSION); SELF\binary_generic_expression.operands : LIST[2:2] OF BOOLEAN_EXPRESSION; END_ENTITY;
ENTITY axis1_placement_type SUBTYPE OF (PLACEMENT_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.AXIS1_PLACEMENT' IN SELF\ ENTITY_INSTANCE_TYPE.type_name; END_ENTITY;
ENTITY axis2_placement_2d_type SUBTYPE OF (PLACEMENT_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.AXIS2_PLACEMENT_2D' IN SELF\ ENTITY_INSTANCE_TYPE.type_name; END_ENTITY;
ENTITY axis2_placement_3d_type SUBTYPE OF (PLACEMENT_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.AXIS2_PLACEMENT_3D' IN SELF\ ENTITY_INSTANCE_TYPE.type_name; END_ENTITY;
ENTITY boolean_type SUBTYPE OF (SIMPLE_TYPE); END_ENTITY;
ENTITY class_bsu SUBTYPE OF (BASIC_SEMANTIC_UNIT); SELF\basic_semantic_unit.code : CLASS_CODE_TYPE; defined_by : SUPPLIER_BSU; DERIVE absolute_id : IDENTIFIER := defined_by.absolute_id + SEP_ID + dic_identifier ; known_visible_properties : SET[0:?] OF PROPERTY_BSU := COMPUTE_KNOWN_VISIBLE_PROPERTIES(SELF); known_visible_data_types : SET[0:?] OF DATA_TYPE_BSU := COMPUTE_KNOWN_VISIBLE_DATA_TYPES(SELF); INVERSE subclasses : SET[0:?] OF CLASS FOR its_superclass; added_visible_properties : SET[0:?] OF PROPERTY_BSU FOR name_scope; added_visible_data_types : SET[0:?] OF DATA_TYPE_BSU FOR name_scope; UNIQUE ur1 : absolute_id; END_ENTITY;
-- class_BSU ENTITY class_instance_type SUBTYPE OF (COMPLEX_TYPE); domain : CLASS_BSU; END_ENTITY;
ENTITY class_value_assignment; super_class_defined_property : PROPERTY_BSU; assigned_value : VALUE_CODE_TYPE; WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(super_class_defined_property,( 'ISO13584_G_M_IIM_SCHEMA.NON_QUANTITATIVE_CODE_TYPE' IN TYPEOF(super_class_defined_property.definition[1]\PROPERTY_DET. domain))); wr2 : DEFINITION_AVAILABLE_IMPLIES(super_class_defined_property,(SIZEOF( QUERY(v <* super_class_defined_property.definition[1]\PROPERTY_DET. domain\NON_QUANTITATIVE_CODE_TYPE.domain.its_values | assigned_value = v.value_code)) = 1)); END_ENTITY;
ENTITY component_class SUBTYPE OF (ITEM_CLASS); END_ENTITY;
ENTITY condition_det SUBTYPE OF (PROPERTY_DET); END_ENTITY;
ENTITY data_type_bsu SUBTYPE OF (BASIC_SEMANTIC_UNIT); SELF\basic_semantic_unit.code : DATA_TYPE_CODE_TYPE; name_scope : CLASS_BSU; DERIVE absolute_id : IDENTIFIER := name_scope.defined_by.absolute_id + SEP_ID + name_scope.dic_identifier + SEP_ID + dic_identifier; INVERSE defining_class : SET[0:1] OF CLASS FOR defined_types; UNIQUE absolute_id; WHERE wr1 : IS_SUBCLASS(defining_class[1],name_scope.definition[1]); END_ENTITY;
ENTITY data_type_element SUBTYPE OF (DICTIONARY_ELEMENT); SELF\dictionary_element.identified_by : DATA_TYPE_BSU; names : ITEM_NAMES; type_definition : DATA_TYPE; END_ENTITY;
ENTITY dates; date_of_original_definition : DATE_TYPE; date_of_current_version : DATE_TYPE; date_of_current_revision : OPTIONAL DATE_TYPE; END_ENTITY;
ENTITY dependent_p_det SUBTYPE OF (PROPERTY_DET); depends_on : SET[1:?] OF PROPERTY_BSU; WHERE wr1 : QUERY(p <* depends_on | NOT (DEFINITION_AVAILABLE_IMPLIES(p,( 'ISO13584_G_M_IIM_SCHEMA.CONDITION_DET' IN TYPEOF(p.definition))) )) = []; END_ENTITY;
ENTITY dic_unit; structured_representation : UNIT; string_representation : OPTIONAL MATHEMATICAL_STRING; END_ENTITY;
ENTITY dic_value; value_code : VALUE_TYPE; meaning : ITEM_NAMES; source_doc_of_value : OPTIONAL DOCUMENT; END_ENTITY;
ENTITY entity_instance_type ABSTRACT SUPERTYPE SUBTYPE OF (COMPLEX_TYPE); type_name : SET OF STRING; END_ENTITY;
ENTITY identified_document SUBTYPE OF (DOCUMENT); document_identifier : SOURCE_DOC_TYPE; END_ENTITY;
ENTITY int_currency_type SUBTYPE OF (INT_TYPE); currency : OPTIONAL CURRENCY_CODE; END_ENTITY;
ENTITY int_measure_type SUBTYPE OF (INT_TYPE); unit : DIC_UNIT; END_ENTITY;
ENTITY int_type SUPERTYPE OF (ONEOF(INT_MEASURE_TYPE,INT_CURRENCY_TYPE, NON_QUANTITATIVE_INT_TYPE)) SUBTYPE OF (NUMBER_TYPE); END_ENTITY;
ENTITY item_class SUPERTYPE OF (ONEOF(COMPONENT_CLASS,MATERIAL_CLASS)) SUBTYPE OF (CLASS); simplified_drawing : OPTIONAL GRAPHICS; sub_class_properties : SET[0:?] OF PROPERTY_BSU; class_constant_values : SET[0:?] OF CLASS_VALUE_ASSIGNMENT; coded_name : OPTIONAL VALUE_CODE_TYPE; WHERE wr1 : QUERY(p <* sub_class_properties | NOT (p IN SELF.described_by)) = []; wr2 : NOT ALL_CLASS_DESCRIPTIONS_REACHABLE(SELF.identified_by) OR (QUERY(va <* class_constant_values | SIZEOF(QUERY(c <* va. super_class_defined_property.describes_classes | IS_SUBCLASS(SELF,c) AND (va.super_class_defined_property IN c\ITEM_CLASS. sub_class_properties))) <> 1) = []); END_ENTITY;
ENTITY item_names; preferred_name : PREF_NAME_TYPE; synonymous_names : SET OF SYN_NAME_TYPE; short_name : SHORT_NAME_TYPE; languages : OPTIONAL PRESENT_TRANSLATIONS; icon : OPTIONAL GRAPHICS; WHERE wr1 : NOT (EXISTS(languages) XOR (( 'ISO13584_G_M_IIM_SCHEMA.TRANSLATED_LABEL' IN TYPEOF(preferred_name)) AND (languages :=: preferred_name\ TRANSLATED_LABEL.languages) AND ( 'ISO13584_G_M_IIM_SCHEMA.TRANSLATED_LABEL' IN TYPEOF(short_name)) AND (languages :=: short_name\TRANSLATED_LABEL. languages) AND (QUERY(s <* synonymous_names | NOT ( 'ISO13584_G_M_IIM_SCHEMA.LABEL_WITH_LANGUAGE' IN TYPEOF(s))) = [] ))); wr2 : NOT EXISTS(languages) XOR (QUERY(s <* synonymous_names | EXISTS(s. language) AND NOT (s.language IN QUERY(l <* languages.language_codes | TRUE))) = []); wr3 : AT_MOST_TWO_SYNONYMS_PER_LANGUAGE(languages,synonymous_names); END_ENTITY;
ENTITY label_with_language; l : LABEL; language : LANGUAGE_CODE; END_ENTITY;
ENTITY material_class SUBTYPE OF (ITEM_CLASS); END_ENTITY;
ENTITY mathematical_string; text_representation : TEXT; sgml_representation : OPTIONAL TEXT; END_ENTITY;
ENTITY named_type SUBTYPE OF (DATA_TYPE); referred_type : DATA_TYPE_BSU; END_ENTITY;
ENTITY non_dependent_p_det SUBTYPE OF (PROPERTY_DET); END_ENTITY;
ENTITY non_quantitative_code_type SUBTYPE OF (STRING_TYPE); domain : VALUE_DOMAIN; WHERE wr1 : QUERY(v <* domain.its_values | NOT ( 'ISO13584_G_M_IIM_SCHEMA.VALUE_CODE_TYPE' IN TYPEOF(v.value_code) )) = []; END_ENTITY;
ENTITY non_quantitative_int_type SUBTYPE OF (INT_TYPE); domain : VALUE_DOMAIN; WHERE wr1 : QUERY(v <* domain.its_values | 'ISO13584_G_M_IIM_SCHEMA.VALUE_CODE_TYPE' IN TYPEOF(v.value_code) ) = []; END_ENTITY;
ENTITY non_si_unit SUBTYPE OF (NAMED_UNIT); name : LABEL; END_ENTITY;
ENTITY number_type SUPERTYPE OF (ONEOF(INT_TYPE,REAL_TYPE)) SUBTYPE OF (SIMPLE_TYPE); END_ENTITY;
ENTITY placement_type SUPERTYPE OF (ONEOF(AXIS1_PLACEMENT_TYPE,AXIS2_PLACEMENT_2D_TYPE, AXIS2_PLACEMENT_3D_TYPE)) SUBTYPE OF (ENTITY_INSTANCE_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.PLACEMENT' IN SELF\ENTITY_INSTANCE_TYPE. type_name; END_ENTITY;
ENTITY property_bsu SUBTYPE OF (BASIC_SEMANTIC_UNIT); SELF\basic_semantic_unit.code : PROPERTY_CODE_TYPE; name_scope : CLASS_BSU; DERIVE absolute_id : IDENTIFIER := name_scope.defined_by.absolute_id + SEP_ID + name_scope.dic_identifier + SEP_ID + dic_identifier; INVERSE describes_classes : SET OF CLASS FOR described_by; UNIQUE ur1 : absolute_id; WHERE wr1 : QUERY(c <* describes_classes | NOT (IS_SUBCLASS(c,name_scope. definition[1]\CLASS))) = []; END_ENTITY;
ENTITY real_currency_type SUBTYPE OF (REAL_TYPE); currency : OPTIONAL CURRENCY_CODE; END_ENTITY;
ENTITY real_measure_type SUBTYPE OF (REAL_TYPE); unit : DIC_UNIT; END_ENTITY;
ENTITY real_type SUPERTYPE OF (ONEOF(REAL_MEASURE_TYPE,REAL_CURRENCY_TYPE)) SUBTYPE OF (NUMBER_TYPE); END_ENTITY;
ENTITY string_type SUBTYPE OF (SIMPLE_TYPE); END_ENTITY;
ENTITY supplier_bsu SUBTYPE OF (BASIC_SEMANTIC_UNIT); SELF\basic_semantic_unit.code : SUPPLIER_CODE_TYPE; DERIVE SELF\basic_semantic_unit.version : VERSION_TYPE := '001'; absolute_id : IDENTIFIER := SELF\BASIC_SEMANTIC_UNIT.code; UNIQUE ur1 : absolute_id; END_ENTITY;
ENTITY supplier_element SUBTYPE OF (DICTIONARY_ELEMENT); SELF\dictionary_element.identified_by : SUPPLIER_BSU; org : ORGANIZATION; addr : ADDRESS; INVERSE associated_items : SET[0:?] OF SUPPLIER_BSU_RELATIONSHIP FOR relating_supplier; END_ENTITY;
ENTITY value_domain; its_values : LIST[2:?] OF DIC_VALUE; source_doc_of_value_domain : OPTIONAL DOCUMENT; languages : OPTIONAL PRESENT_TRANSLATIONS; terms : LIST[0:?] OF ITEM_NAMES; WHERE wr1 : NOT EXISTS(languages) XOR (QUERY(v <* its_values | languages :<>: v. meaning.languages) = []); wr2 : CODES_ARE_UNIQUE(its_values); END_ENTITY;
ENTITY global_language_assignment; language : LANGUAGE_CODE; END_ENTITY;
ENTITY present_translations; language_codes : LIST[1:?] OF UNIQUE LANGUAGE_CODE; UNIQUE ur1 : language_codes; END_ENTITY;
ENTITY translated_label; labels : LIST[1:?] OF LABEL; languages : PRESENT_TRANSLATIONS; WHERE wr1 : SIZEOF(labels) = SIZEOF(languages.language_codes); END_ENTITY;
ENTITY translated_text; texts : LIST[1:?] OF TEXT; languages : PRESENT_TRANSLATIONS; WHERE wr1 : SIZEOF(texts) = SIZEOF(languages.language_codes); END_ENTITY;
ENTITY dic_component_instance SUPERTYPE OF (LIB_COMPONENT_INSTANCE) SUBTYPE OF (DIC_ITEM_INSTANCE); WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\DIC_CLASS_INSTANCE.class_def, 'ISO13584_G_M_IIM_SCHEMA.COMPONENT_CLASS' IN TYPEOF( SELF\DIC_CLASS_INSTANCE.class_def.definition[1])); END_ENTITY;
ENTITY dic_feature_instance SUPERTYPE OF (LIB_FEATURE_INSTANCE) SUBTYPE OF (DIC_ITEM_INSTANCE); WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\DIC_CLASS_INSTANCE.class_def, 'ISO13584_G_M_IIM_SCHEMA.FEATURE_CLASS' IN TYPEOF(SELF\ DIC_CLASS_INSTANCE.class_def.definition[1])); END_ENTITY;
ENTITY dic_material_instance SUPERTYPE OF (LIB_MATERIAL_INSTANCE) SUBTYPE OF (DIC_ITEM_INSTANCE); WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\DIC_CLASS_INSTANCE.class_def, 'ISO13584_G_M_IIM_SCHEMA.MATERIAL_CLASS' IN TYPEOF(SELF\ DIC_CLASS_INSTANCE.class_def.definition[1])); END_ENTITY;
ENTITY int_level_spec_value SUBTYPE OF (LEVEL_SPEC_VALUE); SELF\level_spec_value.values : ARRAY[4:4] OF OPTIONAL INTEGER; END_ENTITY;
ENTITY lib_component_instance SUBTYPE OF (DIC_COMPONENT_INSTANCE,LIB_ITEM_INSTANCE); END_ENTITY;
ENTITY lib_feature_instance SUBTYPE OF (DIC_FEATURE_INSTANCE,LIB_ITEM_INSTANCE); END_ENTITY;
ENTITY lib_material_instance SUBTYPE OF (DIC_MATERIAL_INSTANCE,LIB_ITEM_INSTANCE); END_ENTITY;
ENTITY property_value; its_value : OPTIONAL PRIMITIVE_VALUE; prop_def : PROPERTY_BSU; WHERE wr1 : (EXISTS(SELF.its_value) AND (COMPATIBLE_TYPE_AND_VALUE(SELF.prop_def, SELF.its_value))) OR NOT EXISTS(SELF.its_value); END_ENTITY;
ENTITY real_level_spec_value SUBTYPE OF (LEVEL_SPEC_VALUE); SELF\level_spec_value.values : ARRAY[4:4] OF OPTIONAL REAL; END_ENTITY;
ENTITY binary_class_instance_constructor SUBTYPE OF (CLASS_INSTANCE_CONSTRUCTOR,BINARY_CLASS_INSTANCE_EXPRESSION); SELF\class_instance_constructor.properties : SET[2:2] OF PROPERTY_ASSIGNMENT; DERIVE SELF\binary_generic_expression.operands : LIST[2:2] OF LIBRARY_EXPRESSION := COLLECTS_REFERENCED_LIBRARY_EXPRESSIONS(SELF.properties); WHERE wr1 : SIZEOF(LIST_TO_SET(COLLECTS_ASSIGNED_PROPERTIES(SELF.properties))) = SIZEOF(COLLECTS_ASSIGNED_PROPERTIES(SELF.properties)); END_ENTITY;
ENTITY class_instance_literal SUBTYPE OF (SIMPLE_CLASS_INSTANCE_EXPRESSION,GENERIC_LITERAL); the_value : DIC_CLASS_INSTANCE; WHERE wr1 : COMPATIBLE_CLASS_AND_CLASS(SELF\CLASS_INSTANCE_EXPRESSION.expr_type, SELF.the_value\DIC_CLASS_INSTANCE.class_def); END_ENTITY;
ENTITY class_instance_variable SUBTYPE OF (SIMPLE_CLASS_INSTANCE_EXPRESSION,GENERIC_VARIABLE); END_ENTITY;
ENTITY entity_instance_literal SUBTYPE OF (SIMPLE_ENTITY_INSTANCE_EXPRESSION,GENERIC_LITERAL); the_value : ENTITY_INSTANCE_VALUE; WHERE wr1 : (SELF\ENTITY_INSTANCE_EXPRESSION.type_name <= TYPEOF(SELF.the_value)) OR (('ISO13584_G_M_IIM_SCHEMA.UNCONTROLLED_ENTITY_INSTANCE_VALUE') IN TYPEOF(SELF.the_value)); END_ENTITY;
ENTITY entity_instance_variable SUBTYPE OF (SIMPLE_ENTITY_INSTANCE_EXPRESSION,GENERIC_VARIABLE); END_ENTITY;
ENTITY exists_value SUBTYPE OF (UNARY_GENERIC_EXPRESSION,BOOLEAN_DEFINED_FUNCTION); for_variable : LIBRARY_VARIABLE; DERIVE SELF\unary_generic_expression.operand : GENERIC_EXPRESSION := SELF. for_variable; END_ENTITY;
ENTITY instance_comparison_equal SUBTYPE OF (BINARY_GENERIC_EXPRESSION, BOOLEAN_DEFINED_FUNCTION); END_ENTITY;
ENTITY int_level_spec_literal SUBTYPE OF (LEVEL_SPEC_LITERAL); SELF\level_spec_literal.the_value : INT_LEVEL_SPEC_VALUE; WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN TYPEOF(SELF\ LEVEL_SPEC_EXPRESSION.VALUE_TYPE); wr2 : COMPATIBLE_LEVEL_TYPE_AND_INSTANCE(SELF\LEVEL_SPEC_EXPRESSION.levels,[ 'ISO13584_G_M_IIM_SCHEMA.INT_TYPE'],SELF.the_value); END_ENTITY;
ENTITY int_level_spec_variable SUBTYPE OF (LEVEL_SPEC_VARIABLE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN TYPEOF(SELF\ LEVEL_SPEC_EXPRESSION.VALUE_TYPE); END_ENTITY;
ENTITY multiple_arity_class_instance_constructor SUBTYPE OF (CLASS_INSTANCE_CONSTRUCTOR, MULTIPLE_ARITY_CLASS_INSTANCE_EXPRESSION); SELF\class_instance_constructor.properties : SET[2:?] OF PROPERTY_ASSIGNMENT; DERIVE SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF LIBRARY_EXPRESSION := COLLECTS_REFERENCED_LIBRARY_EXPRESSIONS(SELF.properties); WHERE wr1 : SIZEOF(LIST_TO_SET(COLLECTS_ASSIGNED_PROPERTIES(SELF.properties))) = SIZEOF(COLLECTS_ASSIGNED_PROPERTIES(SELF.properties)); END_ENTITY;
ENTITY property_assignment; its_value : OPTIONAL LIBRARY_EXPRESSION; prop_def : PROPERTY_BSU; WHERE wr1 : (EXISTS(SELF.its_value) AND (COMPATIBLE_TYPE_AND_LIBRARY_EXPRESSION( SELF.prop_def,SELF.its_value))) OR NOT EXISTS(SELF.its_value); END_ENTITY;
ENTITY real_level_spec_literal SUBTYPE OF (LEVEL_SPEC_LITERAL); SELF\level_spec_literal.the_value : REAL_LEVEL_SPEC_VALUE; WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN TYPEOF(SELF\ LEVEL_SPEC_EXPRESSION.VALUE_TYPE); wr2 : COMPATIBLE_LEVEL_TYPE_AND_INSTANCE(SELF\LEVEL_SPEC_EXPRESSION.levels,[ 'ISO13584_G_M_IIM_SCHEMA.REAL_TYPE'],SELF.the_value); END_ENTITY;
ENTITY real_level_spec_variable SUBTYPE OF (LEVEL_SPEC_VARIABLE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN TYPEOF(SELF\ LEVEL_SPEC_EXPRESSION.VALUE_TYPE); END_ENTITY;
ENTITY unary_class_instance_constructor SUBTYPE OF (CLASS_INSTANCE_CONSTRUCTOR,UNARY_CLASS_INSTANCE_EXPRESSION); SELF\class_instance_constructor.properties : SET[1:1] OF PROPERTY_ASSIGNMENT; DERIVE SELF\unary_generic_expression.operand : LIBRARY_EXPRESSION := COLLECTS_REFERENCED_LIBRARY_EXPRESSIONS(SELF.properties)[1]; END_ENTITY;
ENTITY boolean_column SUBTYPE OF (SIMPLE_COLUMN); SELF\column.values : LIST[1:?] OF BOOLEAN_VALUE; END_ENTITY;
ENTITY class_instance_column SUBTYPE OF (COMPLEX_COLUMN); class_ref : CLASS_BSU; SELF\column.values : LIST[1:?] OF DIC_CLASS_INSTANCE; WHERE wr1 : QUERY(inst <* SELF\COLUMN.values | NOT COMPATIBLE_CLASS_AND_CLASS(SELF .class_ref,inst.class_def)) = []; END_ENTITY;
ENTITY column_traversal_variable_semantics SUBTYPE OF (VARIABLE_SEMANTICS); ctxt : TABLE_EXPRESSION; domain : VARIABLE_SEMANTICS; WHERE wr1 : SELF.domain IN SELF.ctxt.its_columns; wr2 : (SIZEOF(USEDIN(SELF,'ISO13584_G_M_IIM_SCHEMA.ENVIRONMENT.SEMANTICS')) = 0) OR COMPATIBLE_VARIABLE_SEMANTICS_AND_EXPRESSION(SELF.domain,USEDIN(SELF, 'ISO13584_G_M_IIM_SCHEMA.ENVIRONMENT.SEMANTICS')[1]. syntactic_representation); END_ENTITY;
ENTITY difference_table_expression SUBTYPE OF (SET_TABLE_EXPRESSION); END_ENTITY;
ENTITY entity_instance_column SUBTYPE OF (COMPLEX_COLUMN); type_name : SET[1:?] OF STRING; SELF\column.values : LIST[1:?] OF ENTITY_INSTANCE_VALUE; WHERE wr1 : QUERY(inst <* SELF\COLUMN.values | NOT (SELF.type_name <= TYPEOF(inst) )) = []; END_ENTITY;
ENTITY integer_column SUBTYPE OF (NUMBER_COLUMN); SELF\column.values : LIST[1:?] OF INTEGER_VALUE; WHERE wr1 : (SELF\FORMATTED_COLUMN.value_format) LIKE 'NR1*'; END_ENTITY;
ENTITY intersect_table_expression SUBTYPE OF (SET_TABLE_EXPRESSION); END_ENTITY;
ENTITY int_level_spec_column SUBTYPE OF (LEVEL_SPEC_COLUMN); SELF\column.values : LIST[1:?] OF INT_LEVEL_SPEC_VALUE; END_ENTITY;
ENTITY in_RDB_table_boolean_expression SUBTYPE OF(MULTIPLE_ARITY_GENERIC_EXPRESSION, BOOLEAN_DEFINED_FUNCTION, SQL_MAPPABLE_DEFINED_FUNCTION); DERIVE from_table: GENERIC_EXPRESSION := SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands[1]; tuple: LIST[1:?] OF GENERIC_EXPRESSION := QUERY(element <* SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands | 'ISO13584_G_M_IIM_SCHEMA.EXPRESSION' IN TYPEOF(element)); WHERE WR1: ('ISO13584_G_M_IIM_SCHEMA.TABLE_EXPRESSION' IN TYPEOF(from_table)) AND IS_SQL_MAPPABLE_TABLE_EXPRESSION (from_table\TABLE_EXPRESSION); WR2: SIZEOF (QUERY(simple_expr<* QUERY(expr<*SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands | ('ISO13584_G_M_IIM_SCHEMA.EXPRESSION' IN TYPEOF (expr)))|IS_SQL_MAPPABLE(simple_expr\EXPRESSION))) = SIZEOF(SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands) - 1; WR3: SIZEOF (from_table\TABLE_EXPRESSION.its_columns) = SIZEOF (tuple); WR4: COMPATIBLE_LIST_VARIABLE_SEMANTICS_AND_EXPRESSIONS (SELF.from_table\TABLE_EXPRESSION.its_columns, SELF.tuple); WR5: QUERY (e<*tuple | QUERY (v<*USED_VARIABLES(e)|('ISO13584_G_M_IIM_SCHEMA' + '.COLUMN_TRAVERSAL_VARIABLE_SEMANTICS') IN TYPEOF (v.interpretation.semantics)) <> [] ) = []; END_ENTITY;
ENTITY multiple_arity_cartesian_product SUBTYPE OF (MULTIPLE_ARITY_TABLE_EXPRESSION); SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF TABLE_EXPRESSION; END_ENTITY;
ENTITY natural_join_expression SUBTYPE OF (BINARY_TABLE_EXPRESSION); DERIVE table_1 : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[1]; table_2 : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[2]; WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.TABLE_EXPRESSION' IN TYPEOF(SELF. table_1)) AND ('ISO13584_G_M_IIM_SCHEMA.TABLE_EXPRESSION' IN TYPEOF(SELF.table_2)); wr2 : SIZEOF(LIST_TO_SET(table_1\TABLE_EXPRESSION.its_columns) * LIST_TO_SET (table_2\TABLE_EXPRESSION.its_columns)) > 0; END_ENTITY;
ENTITY projection_expression SUBTYPE OF (UNARY_TABLE_EXPRESSION); SELF\unary_generic_expression.operand : TABLE_EXPRESSION; argts_var : SET[1:?] OF VARIABLE_SEMANTICS; WHERE wr1 : SELF.argts_var <= LIST_TO_SET(SELF\UNARY_GENERIC_EXPRESSION.operand\ TABLE_EXPRESSION.its_columns); END_ENTITY;
ENTITY rdb_table_extension SUBTYPE OF (TABLE_EXTENSION); SELF\table_extension.content : LIST[1:?] OF UNIQUE SIMPLE_COLUMN; END_ENTITY;
ENTITY rdb_table_specification SUBTYPE OF (TABLE_SPECIFICATION); WHERE wr1 : QUERY(col <* SELF\TABLE_SPECIFICATION.column_meaning | QUERY(v <* SYNTAX_OF(col) | NOT ('ISO13584_G_M_IIM_SCHEMA.VARIABLE' IN TYPEOF(v))) <> []) = []; END_ENTITY;
ENTITY rdb_table_variable SUBTYPE OF (TABLE_VARIABLE); WHERE wr1 : QUERY(col <* SELF\TABLE_EXPRESSION.its_columns | QUERY(v <* SYNTAX_OF( col) | NOT ('ISO13584_G_M_IIM_SCHEMA.VARIABLE' IN TYPEOF(v))) <> []) = []; END_ENTITY;
ENTITY real_column SUBTYPE OF (NUMBER_COLUMN); SELF\column.values : LIST[1:?] OF REAL_VALUE; WHERE wr1 : (SELF\FORMATTED_COLUMN.value_format) LIKE 'NR2*'; END_ENTITY;
ENTITY real_level_spec_column SUBTYPE OF (LEVEL_SPEC_COLUMN); SELF\column.values : LIST[1:?] OF REAL_LEVEL_SPEC_VALUE; END_ENTITY;
ENTITY select_expression SUBTYPE OF (TABLE_EXPRESSION,BINARY_GENERIC_EXPRESSION); DERIVE from_table : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[1 ]; condition : GENERIC_EXPRESSION := SELF\BINARY_GENERIC_EXPRESSION.operands[1] ; WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.TABLE_EXPRESSION' IN TYPEOF(SELF. from_table); wr2 : 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF(SELF. condition); wr3 : QUERY(va <* USED_VARIABLES(SELF.condition) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.VARIABLE' IN TYPEOF(va))) = []; wr4 : QUERY(v <* USED_VARIABLES(SELF.condition) | (( 'ISO13584_G_M_IIM_SCHEMA.COLUMN_TRAVERSAL_VARIABLE_SEMANTICS') IN TYPEOF(v.interpretation. semantics)) AND ((v.interpretation.semantics\ COLUMN_TRAVERSAL_VARIABLE_SEMANTICS.ctxt :<>: SELF.from_table) OR ( SIZEOF(QUERY(v2 <* USED_VARIABLES(SELF.condition) | (( 'ISO13584_G_M_IIM_SCHEMA.COLUMN_TRAVERSAL_VARIABLE_SEMANTICS') IN TYPEOF(v2.interpretation. semantics)) AND (v2.interpretation.semantics\ COLUMN_TRAVERSAL_VARIABLE_SEMANTICS.domain = v.interpretation. semantics\COLUMN_TRAVERSAL_VARIABLE_SEMANTICS.domain))) <> 1))) = []; END_ENTITY;
ENTITY string_column SUBTYPE OF (FORMATTED_COLUMN); SELF\column.values : LIST[1:?] OF STRING_VALUE; WHERE wr1 : ((SELF\FORMATTED_COLUMN.value_format) LIKE 'A*') OR ((SELF\ FORMATTED_COLUMN.value_format) LIKE 'N.*'); END_ENTITY;
ENTITY table_extension SUPERTYPE OF (RDB_TABLE_EXTENSION); table_identifier : TABLE_IDENTIFICATION; content : LIST[1:?] OF UNIQUE COLUMN; revision_of_content : REVISION_TYPE; content_revision_date : DATE_TYPE; WHERE wr1 : QUERY(col <* SELF.content | SIZEOF(col.values) <> SIZEOF(SELF.content[ 1].values)) = []; wr2 : (SIZEOF(USEDIN(SELF.table_identifier, 'ISO13584_G_M_IIM_SCHEMA.TABLE_IDENTIFIER')) = 0) OR COMPATIBLE_LIST_VARIABLE_SEMANTICS_AND_COLUMNS(USEDIN(SELF. table_identifier,'ISO13584_G_M_IIM_SCHEMA.TABLE_SPECIFICATION' + '.TABLE_IDENTIFIER')[1].column_meaning,SELF.content); END_ENTITY;
ENTITY table_literal SUBTYPE OF (SIMPLE_TABLE_EXPRESSION,GENERIC_LITERAL); the_value : TABLE_IDENTIFICATION; WHERE wr1 : SIZEOF(USEDIN(SELF.the_value, 'ISO13584_G_M_IIM_SCHEMA.TABLE_SPECIFICATION' + '.TABLE_IDENTIFIER')) = 1; END_ENTITY;
ENTITY table_specification SUPERTYPE OF (RDB_TABLE_SPECIFICATION); table_identifier : TABLE_IDENTIFICATION; column_meaning : LIST[1:?] OF UNIQUE VARIABLE_SEMANTICS; key : SET[1:?] OF VARIABLE_SEMANTICS; WHERE wr1 : SELF.key <= LIST_TO_SET(SELF.column_meaning); END_ENTITY;
ENTITY table_variable SUPERTYPE OF (RDB_TABLE_VARIABLE) SUBTYPE OF (SIMPLE_TABLE_EXPRESSION,GENERIC_VARIABLE); structure : LIST[1:?] OF VARIABLE_SEMANTICS; its_key : SET[1:?] OF VARIABLE_SEMANTICS; WHERE wr1 : SELF.its_key <= LIST_TO_SET(SELF.structure); END_ENTITY;
ENTITY union_table_expression SUBTYPE OF (SET_TABLE_EXPRESSION); END_ENTITY;
ENTITY self_class_code_semantics SUBTYPE OF (SELF_CLASS_NAME_SEMANTICS); END_ENTITY;
ENTITY self_class_preferred_name_semantics SUBTYPE OF (SELF_CLASS_NAME_SEMANTICS); END_ENTITY;
ENTITY self_class_short_name_semantics SUBTYPE OF (SELF_CLASS_NAME_SEMANTICS); END_ENTITY;
ENTITY self_class_supplier_code_semantics SUBTYPE OF (SELF_CLASS_NAME_SEMANTICS); END_ENTITY;
ENTITY self_class_version_semantics SUBTYPE OF (SELF_CLASS_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_class_code_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_class_version_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_class_supplier_code_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS ); END_ENTITY;
ENTITY self_property_code_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_preferred_name_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_short_name_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY self_property_value_semantics SUBTYPE OF (SELF_PROPERTY_SEMANTICS); WHERE wr1 : QUERY(v <* SYNTAX_OF(SELF) | NOT COMPATIBLE_TYPE_AND_LIBRARY_EXPRESSION (BSU_OF_PROPERTY_SEMANTICS(SELF),v)) = []; END_ENTITY;
ENTITY self_property_version_semantics SUBTYPE OF (SELF_PROPERTY_NAME_SEMANTICS); END_ENTITY;
ENTITY sub_property_path; the_property : PROPERTY_BSU; its_own_property : OPTIONAL SUB_PROPERTY_PATH; WHERE WR1: (NOT (EXISTS (SELF.its_own_property))) OR (DATA_TYPE_TYPEOF(SELF.the_property) = []) OR (('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(SELF.the_property)) AND APPLICABLE_PROPERTIES (DATA_TYPE_CLASS_OF( SELF.the_property)[1],[SELF.its_own_property.the_property])); END_ENTITY;
ENTITY constant_range_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); minimal : LITERAL_NUMBER; maximal : LITERAL_NUMBER; step : OPTIONAL LITERAL_NUMBER; WHERE wr1 : SIZEOF(SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; wr2 : minimal.the_value <= maximal.the_value; wr3 : QUERY(va <* COLLECTS_VARIABLES(SELF\SIMPLE_DOMAIN.referenced_by. item_of.defines) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.NUMERIC_VARIABLE' IN TYPEOF(va))) = []; wr4 : (NOT EXISTS(SELF.step)) OR (SELF.step.the_value > 0); END_ENTITY;
ENTITY domain_restriction SUPERTYPE OF (FUNCTIONAL_DOMAIN_RESTRICTION); defines : SET[1:?] OF VARIABLE_SEMANTICS; assumes : SET[0:?] OF VARIABLE_SEMANTICS; domains : SET[1:?] OF GUARDED_SIMPLE_DOMAIN; constraint_description : OPTIONAL MESSAGE; DERIVE base_tables : SET[0:?] OF TABLE_IDENTIFICATION := USED_TABLES_IN_DOMAIN(SELF ); WHERE wr1 : SIZEOF(QUERY(g <* SELF.domains | 'ISO13584_G_M_IIM_SCHEMA.OTHERS' IN TYPEOF(g.guard))) = 1; END_ENTITY;
ENTITY functional_domain_restriction SUBTYPE OF (DOMAIN_RESTRICTION); SELF\domain_restriction.domains : SET[1:?] OF GUARDED_FUNCTIONAL_DOMAIN; END_ENTITY;
ENTITY library_expression_defined_value SUBTYPE OF (SIMPLE_FUNCTIONAL_DOMAIN); its_value : LIBRARY_EXPRESSION; WHERE wr1 : SIZEOF(SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; wr2 : QUERY(va <* COLLECTS_VARIABLES(SELF\SIMPLE_DOMAIN.referenced_by. item_of.defines) | NOT COMPATIBLE_VARIABLE_AND_LIBRARY_EXPRESSION(va, SELF.its_value)) = []; wr3 : COLLECTS_VAR_SEM(USED_VARIABLES(SELF.its_value)) <= SELF\SIMPLE_DOMAIN .referenced_by.item_of.assumes; END_ENTITY;
ENTITY guarded_functional_domain SUBTYPE OF (GUARDED_SIMPLE_DOMAIN); SELF\guarded_simple_domain.domain : SIMPLE_FUNCTIONAL_DOMAIN; END_ENTITY;
ENTITY guarded_simple_domain; guard : BOOLEAN_EXPRESSION_OR_OTHERS; domain : SIMPLE_DOMAIN; INVERSE item_of : DOMAIN_RESTRICTION FOR domains; WHERE wr1 : (('ISO13584_G_M_IIM_SCHEMA.OTHERS') IN TYPEOF(guard)) OR ( COLLECTS_VAR_SEM(USED_VARIABLES(guard\BOOLEAN_EXPRESSION)) <= SELF.item_of.assumes); END_ENTITY;
ENTITY null_defined_value SUBTYPE OF (SIMPLE_FUNCTIONAL_DOMAIN); WHERE wr1 : SIZEOF(SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; END_ENTITY;
ENTITY others; END_ENTITY;
ENTITY predicate_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); constraint : BOOLEAN_EXPRESSION; WHERE wr1 : COLLECTS_VAR_SEM(USED_VARIABLES(SELF.constraint)) <= SELF\ SIMPLE_DOMAIN.referenced_by.item_of.defines + SELF\SIMPLE_DOMAIN. referenced_by.item_of.assumes; END_ENTITY;
ENTITY subclass_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); from_class: CLASS_BSU; WHERE WR1: SIZEOF (SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; WR2: QUERY (va <* COLLECTS_VARIABLES( SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) |NOT ('ISO13584_G_M_IIM_SCHEMA' + '.CLASS_INSTANCE_VARIABLE' IN TYPEOF (va))) =[]; WR3: QUERY (va <* COLLECTS_VARIABLES( SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) |NOT IS_SUBCLASS (SELF.from_class.definition[1]\CLASS, va\CLASS_INSTANCE_EXPRESSION.expr_type.definition[1]\CLASS)) = []; END_ENTITY;
ENTITY table_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); from_table : TABLE_EXPRESSION; WHERE wr1 : SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines <= LIST_TO_SET( COLLECTS_COLUMNS(SELF.from_table)); wr2 : QUERY(sem <* COLLECTS_VAR_SEM(USED_VARIABLES(SELF.from_table)) | NOT ( (sem IN (SELF\SIMPLE_DOMAIN.referenced_by.item_of.assumes + SELF\ SIMPLE_DOMAIN.referenced_by.item_of.defines)) OR ((( 'ISO13584_G_M_IIM_SCHEMA.COLUMN_TRAVERSAL_VARIABLE_SEMANTICS') IN TYPEOF(sem))) AND (sem\ COLUMN_TRAVERSAL_VARIABLE_SEMANTICS.domain IN COLLECTS_COLUMNS(SELF. from_table)))) = []; END_ENTITY;
ENTITY table_defined_value SUBTYPE OF (SIMPLE_FUNCTIONAL_DOMAIN); from_table : TABLE_EXPRESSION; WHERE wr1 : SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines <= LIST_TO_SET(SELF. from_table\TABLE_EXPRESSION.its_columns); wr2 : SELF\SIMPLE_DOMAIN.referenced_by.item_of.assumes >= SELF.from_table\ TABLE_EXPRESSION.the_key; wr3 : QUERY(sem <* COLLECTS_VAR_SEM(USED_VARIABLES(SELF.from_table)) | NOT ( (sem IN (SELF\SIMPLE_DOMAIN.referenced_by.item_of.assumes + SELF\ SIMPLE_DOMAIN.referenced_by.item_of.defines)) OR ((( 'ISO13584_G_M_IIM_SCHEMA.COLUMN_TRAVERSAL_VARIABLE_SEMANTICS') IN TYPEOF(sem))) AND (sem\ COLUMN_TRAVERSAL_VARIABLE_SEMANTICS.domain IN COLLECTS_COLUMNS( from_table)))) = []; END_ENTITY;
ENTITY type_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); WHERE wr1 : SIZEOF(SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; END_ENTITY;
ENTITY variable_range_defined_domain SUBTYPE OF (SIMPLE_DOMAIN); minimal : NUMERIC_EXPRESSION; maximal : NUMERIC_EXPRESSION; step : OPTIONAL NUMERIC_EXPRESSION; WHERE wr1 : SIZEOF(SELF\SIMPLE_DOMAIN.referenced_by.item_of.defines) = 1; wr2 : COLLECTS_VAR_SEM(USED_VARIABLES(SELF.minimal) + USED_VARIABLES(SELF. maximal)) <= SELF\SIMPLE_DOMAIN.referenced_by.item_of.assumes; wr3 : NOT (EXISTS(SELF.step)) OR (COLLECTS_VAR_SEM(USED_VARIABLES(SELF.step) ) <= SELF\SIMPLE_DOMAIN.referenced_by.item_of.assumes); wr4 : QUERY(va <* COLLECTS_VARIABLES(SELF\SIMPLE_DOMAIN.referenced_by. item_of.defines) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.NUMERIC_VARIABLE' IN TYPEOF(va))) = []; END_ENTITY;
ENTITY a_posteriori_case_of SUBTYPE OF (A_POSTERIORI_SEMANTIC_RELATIONSHIP); general_model : CLASS_BSU; is_case_of : CLASS_BSU; corresponding_properties : LIST[0:?] OF LIST[2:2] OF PROPERTY_BSU; WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF.general_model,( 'ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS' IN TYPEOF(SELF.general_model .definition[1]))); wr2 : DEFINITION_AVAILABLE_IMPLIES(SELF.is_case_of,( 'ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS' IN TYPEOF(SELF.is_case_of. definition[1]))); wr3 : QUERY(couple <* SELF.corresponding_properties | NOT COMPATIBLE_TYPES( couple[1],couple[2])) = []; wr4 : QUERY(couple <* SELF.corresponding_properties | (NOT APPLICABLE_PROPERTIES(SELF.general_model,[couple[1]]) OR NOT APPLICABLE_PROPERTIES(SELF.is_case_of,[couple[2]]))) = []; END_ENTITY;
ENTITY class_document_relationship SUBTYPE OF (CLASS_BSU_RELATIONSHIP); SELF\class_bsu_relationship.related_tokens : SET[0:?] OF DOCUMENT_BSU; WHERE wr1 : VISIBLE_DOCUMENTS(SELF\CLASS_BSU_RELATIONSHIP.relating_class. identified_by,SELF.related_tokens); END_ENTITY;
ENTITY class_table_relationship SUBTYPE OF (CLASS_BSU_RELATIONSHIP); SELF\class_BSU_relationship.related_tokens: SET [1:?] OF TABLE_BSU; WHERE WR1: VISIBLE_PROPERTIES_FOR_VISIBLE_TABLES(SELF); WR2: VISIBLE_TABLES ( SELF\CLASS_BSU_RELATIONSHIP.relating_class. identified_by, SELF.related_tokens); END_ENTITY;
ENTITY component_class_case_of SUBTYPE OF (ITEM_CLASS_CASE_OF,COMPONENT_CLASS); WHERE wr1 : QUERY(cl <* SELF\ITEM_CLASS_CASE_OF.is_case_of | DEFINITION_AVAILABLE_IMPLIES(cl,( 'ISO13584_G_M_IIM_SCHEMA.COMPONENT_CLASS' IN TYPEOF(cl.definition [1])))) = SELF\ITEM_CLASS_CASE_OF.is_case_of; END_ENTITY;
ENTITY feature_class SUBTYPE OF (ITEM_CLASS); WHERE wr1 : NOT (('ISO13584_G_M_IIM_SCHEMA.COMPONENT_CLASS') IN TYPEOF( SELF)); wr2 : NOT (('ISO13584_G_M_IIM_SCHEMA.MATERIAL_CLASS') IN TYPEOF( SELF)); END_ENTITY;
ENTITY geometric_representation_context_type SUBTYPE OF (ENTITY_INSTANCE_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.GEOMETRIC_REPRESENTATION_CONTEXT' IN SELF\ENTITY_INSTANCE_TYPE.type_name; END_ENTITY;
ENTITY library_iim_id SUBTYPE OF (DATA_EXCHANGE_SPECIFICATION_ID); END_ENTITY;
ENTITY dictionary SUPERTYPE OF (DICTIONARY_IN_STANDARD_FORMAT); responsible_supplier: SUPPLIER_BSU; library_structure: LIBRARY_IIM_ID; base_protocols: SET [0:?] OF EXTERNAL_FILE_PROTOCOL; supported_vep: SET [0:?] OF VIEW_EXCHANGE_PROTOCOL_ID; referred_supplier: SET [1:?] OF SUPPLIER_BSU; contained_classes: LIST [0:?] OF UNIQUE CLASS_BSU; a_posteriori_semantic_relationships: SET [0:?] OF A_POSTERIORI_SEMANTIC_RELATIONSHIP; names: ITEM_NAMES; note: OPTIONAL NOTE_TYPE; remark: OPTIONAL REMARK_TYPE; WHERE WR1: PREFIX_ORDERED_CLASS_LIST (SELF.contained_classes); END_ENTITY;
ENTITY dictionary_in_standard_format SUBTYPE OF (DICTIONARY); WHERE wr1 : QUERY(int <* SELF\DICTIONARY.base_protocols | ((SIZEOF(QUERY(vep <* SELF\DICTIONARY.supported_vep | int IN vep\ DATA_EXCHANGE_SPECIFICATION_ID.external_file_protocols)) = 0) AND NOT ( int IN SELF\DICTIONARY.library_structure.external_file_protocols))) = []; END_ENTITY;
ENTITY document_bsu SUBTYPE OF (CLASS_RELATED_BSU); name_scope : CLASS_BSU; SELF\basic_semantic_unit.code : DOCUMENT_CODE_TYPE; DERIVE absolute_id : IDENTIFIER := name_scope.defined_by.dic_identifier + SEP_ID + name_scope.dic_identifier + SEP_ID + dic_identifier; INVERSE associate_to_class : CLASS_BSU_RELATIONSHIP FOR related_tokens; UNIQUE ur1 : absolute_id; END_ENTITY;
ENTITY document_element SUBTYPE OF (CLASS_RELATED_ELEMENT); SELF\dictionary_element.identified_by : DOCUMENT_BSU; authors : OPTIONAL LIST[1:?] OF PERSON; publishing_organisation : ORGANIZATION; END_ENTITY;
ENTITY item_class_case_of SUPERTYPE OF (ONEOF( COMPONENT_CLASS_CASE_OF, MATERIAL_CLASS_CASE_OF, FEATURE_CLASS_CASE_OF)) SUBTYPE OF (ITEM_CLASS, A_PRIORI_SEMANTICS_RELATIONSHIP); is_case_of: SET [1:?] OF CLASS_BSU; imported_properties: LIST [0:?] OF PROPERTY_BSU; imported_types: SET [0:?]OF DATA_TYPE_BSU; imported_tables : SET [0:?] OF TABLE_BSU ; imported_documents : SET [0:?] OF DOCUMENT_BSU ; DERIVE SELF\a_priori_semantics_relationship.referenced_classes: SET [1: ?] OF CLASS_BSU := SELF.is_case_of; SELF\a_priori_semantics_relationship.referenced_properties: LIST [0:?] OF PROPERTY_BSU := SELF.imported_properties; SELF\a_priori_semantics_relationship.referenced_data_types: SET [0:?] OF DATA_TYPE_BSU := SELF.imported_types; SELF\a_priori_semantics_relationship.referenced_tables: SET [0:?] OF TABLE_BSU := SELF.imported_tables; SELF\a_priori_semantics_relationship.referenced_documents: SET [0:?] OF DOCUMENT_BSU := SELF.imported_documents; WHERE WR1: SUPERCLASS_OF_ITEM_IS_ITEM (SELF); WR2: QUERY (cl <* SELF\ITEM_CLASS_CASE_OF.is_case_of | DEFINITION_AVAILABLE_IMPLIES ( cl, ('ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS' IN TYPEOF (cl.definition[1])))) = SELF\ITEM_CLASS_CASE_OF.is_case_of; END_ENTITY;
ENTITY feature_class_case_of SUBTYPE OF (ITEM_CLASS_CASE_OF, FEATURE_CLASS); WHERE WR1: QUERY (cl <* SELF\ITEM_CLASS_CASE_OF.is_case_of | DEFINITION_AVAILABLE_IMPLIES ( cl, ('ISO13584_G_M_IIM_SCHEMA.FEATURE_CLASS' IN TYPEOF (cl.definition[1])))) = SELF\ITEM_CLASS_CASE_OF.is_case_of; END_ENTITY;
ENTITY material_class_case_of SUBTYPE OF (ITEM_CLASS_CASE_OF,MATERIAL_CLASS); WHERE wr1 : QUERY(cl <* SELF\ITEM_CLASS_CASE_OF.is_case_of | DEFINITION_AVAILABLE_IMPLIES(cl,( 'ISO13584_G_M_IIM_SCHEMA.MATERIAL_CLASS' IN TYPEOF(cl.definition[ 1])))) = SELF\ITEM_CLASS_CASE_OF.is_case_of; END_ENTITY;
ENTITY rdb_table_element SUBTYPE OF (TABLE_ELEMENT,RDB_TABLE_SPECIFICATION); WHERE wr1 : QUERY(temp <* SELF.column_meaning | SIMPLE_TYPE_DATA_TYPE(temp\ PROPERTY_SEMANTICS.the_property) = FALSE) = []; END_ENTITY;
ENTITY rdb_table_content SUBTYPE OF (TABLE_CONTENT,RDB_TABLE_EXTENSION); WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\CONTENT_ITEM.dictionary_definition, 'ISO13584_G_M_IIM_SCHEMA.RDB_TABLE_ELEMENT' IN TYPEOF(SELF\ CONTENT_ITEM.dictionary_definition.definition[1])); END_ENTITY;
ENTITY representation_type SUBTYPE OF (ENTITY_INSTANCE_TYPE); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.REPRESENTATION' IN SELF\ ENTITY_INSTANCE_TYPE.type_name; END_ENTITY;
ENTITY table_bsu SUBTYPE OF (CLASS_RELATED_BSU,TABLE_IDENTIFICATION); name_scope : CLASS_BSU; SELF\basic_semantic_unit.code : TABLE_CODE_TYPE; DERIVE absolute_id : IDENTIFIER := name_scope.defined_by.dic_identifier + SEP_ID + name_scope.dic_identifier + SEP_ID + dic_identifier; UNIQUE ur1 : absolute_id; END_ENTITY;
ENTITY table_content SUBTYPE OF (CONTENT_ITEM, TABLE_EXTENSION); SELF\content_item.dictionary_definition: TABLE_BSU; DERIVE SELF\table_extension.table_identifier: TABLE_BSU := SELF\CONTENT_ITEM.dictionary_definition\TABLE_BSU; WHERE WR1: DEFINITION_AVAILABLE_IMPLIES( SELF\CONTENT_ITEM.dictionary_definition, 'ISO13584_G_M_IIM_SCHEMA.TABLE_ELEMENT' IN TYPEOF ( SELF\CONTENT_ITEM.dictionary_definition.definition[1] )); WR2: COMPATIBLE_CONTENT_AND_SPECIFICATION (SELF); END_ENTITY;
FUNCTION compatible_content_and_specification ( tab : TABLE_CONTENT) : LOGICAL; IF SIZEOF ( tab\CONTENT_ITEM.dictionary_definition.definition) = 0 THEN RETURN (UNKNOWN); END_IF; RETURN ( COMPATIBLE_LIST_LIBRARY_TYPES_AND_COLUMNS ( GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS( tab\CONTENT_ITEM.dictionary_definition.definition[1]\ TABLE_ELEMENT\TABLE_SPECIFICATION.column_meaning), tab\TABLE_EXTENSION.content)); END_FUNCTION; -- compatible_content_and_specification
ENTITY table_element SUBTYPE OF (CLASS_RELATED_ELEMENT, TABLE_SPECIFICATION); SELF\dictionary_element.identified_by: TABLE_BSU; SELF\table_specification.column_meaning: LIST [1:?] OF UNIQUE SELF_PROPERTY_SEMANTICS; SELF\table_specification.key: LIST [1:?] OF UNIQUE SELF_PROPERTY_SEMANTICS; DERIVE SELF\table_specification.table_identifier: TABLE_BSU := SELF\DICTIONARY_ELEMENT.identified_by\TABLE_BSU; WHERE WR1: QUERY (temp <* SELF.column_meaning | NOT VISIBLE_PROPERTIES ( SELF\DICTIONARY_ELEMENT.identified_by\TABLE_BSU.name_scope, GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS([temp]))) = []; END_ENTITY;
ENTITY item_class_extension SUBTYPE OF(MODEL_CLASS_EXTENSION); selection_context_parameters: LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; free_characteristics : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; derived_characteristics : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; context_dependent_characteristics: LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; identified_item : BOOLEAN; supplier_identification : OPTIONAL STRING_EXPRESSION; supplier_designation : OPTIONAL STRING_EXPRESSION; access_icon : OPTIONAL A9_ILLUSTRATION; content_msg : OPTIONAL MESSAGE; create_icon : LIST [0:?] OF A6_ILLUSTRATION; create_msg : OPTIONAL MESSAGE; class_presentation_on_paper : LIST [0:?] OF ILLUSTRATION; class_presentation_on_screen : LIST [0:?] OF ILLUSTRATION; DERIVE SELF\model_class_extension.selectable_properties tration; , ifier; sep_id + (sem))) AND (sem\ . ; ' IN TYPEOF(temp)) AND ( : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU := SELF.selection_context_parameters + SELF.free_characteristics; SELF\model_class_extension.derived_properties SU tration; , ifier; sep_id + (sem))) AND (sem\ . ; ' IN TYPEOF(temp)) AND ( : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU := SELF.derived_characteristics + SELF.context_dependent_characteristics; SELF\model_class_extension.required_properties U tration; , ifier; sep_id + (sem))) AND (sem\ . ; ' IN TYPEOF(temp)) AND ( : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU := []; WHERE WR1: DEFINITION_AVAILABLE_IMPLIES( SELF\CONTENT_ITEM.dictionary_definition, 'ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS' IN TYPEOF( (SELF\CONTENT_ITEM.dictionary_definition.definition[1]))); WR2: QUERY (elt <* SELF.selection_context_parameters| DEFINITION_AVAILABLE_IMPLIES (elt.property, 'ISO13584_G_M_IIM_SCHEMA.CONDITION_DET' IN TYPEOF (elt.property.definition[1]))) = SELF.selection_context_parameters; WR3: QUERY (elt <* SELF.free_characteristics| DEFINITION_AVAILABLE_IMPLIES (elt.property, 'ISO13584_G_M_IIM_SCHEMA.NON_DEPENDENT_P_DET' IN TYPEOF (elt.property.definition[1]))) = SELF.free_characteristics; WR4: QUERY (elt <* SELF.free_characteristics| (DATA_TYPE_TYPEOF(elt.property)<>[]) AND NOT ('ISO13584_G_M_IIM_SCHEMA.SIMPLE_TYPE' IN DATA_TYPE_TYPEOF(elt.property)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(elt.property)) ) = []; WR5: QUERY (elt <* SELF.derived_characteristics| DEFINITION_AVAILABLE_IMPLIES (elt.property, 'ISO13584_G_M_IIM_SCHEMA.NON_DEPENDENT_P_DET' IN TYPEOF (elt.property.definition[1]))) =SELF.derived_properties; WR6: QUERY (elt <* SELF.context_dependent_characteristics| DEFINITION_AVAILABLE_IMPLIES (elt.property, 'ISO13584_G_M_IIM_SCHEMA.DEPENDENT_P_DET' IN TYPEOF (elt.property.definition [1]))) = SELF.context_dependent_characteristics; WR7: SELF.access_icon IN SELF\MODEL_CLASS_EXTENSION.referenced_external_items; WR8: SELF.content_msg IN SELF\MODEL_CLASS_EXTENSION.referenced_external_items; WR9: LIST_TO_SET(SELF.create_icon) <= SELF\MODEL_CLASS_EXTENSION.referenced_external_items; WR10: SELF.create_msg IN SELF\MODEL_CLASS_EXTENSION .referenced_external_items; WR11: SELF.identified_item OR (NOT EXISTS (SELF.supplier_identification) AND NOT EXISTS (SELF.supplier_designation)); WR12: LIST_TO_SET(SELF.class_presentation_on_paper) <= SELF\MODEL_CLASS_EXTENSION.referenced_external_items; WR13: LIST_TO_SET(SELF.class_presentation_on_screen) <= SELF\MODEL_CLASS_EXTENSION.referenced_external_items; WR14: QUERY (icon <* SELF.class_presentation_on_paper | (NOT EXISTS (icon.width)) OR (icon.kind_of_content = ILLUSTRATION_TYPE.not_static_picture)) = []; WR15: QUERY (icon <* SELF.class_presentation_on_screen | (NOT EXISTS (icon.width))) = []; END_ENTITY;
ENTITY library SUPERTYPE OF (LIBRARY_IN_STANDARD_FORMAT) SUBTYPE OF (DICTIONARY); linked_interfaces : SET[0:?] OF EXTERNAL_FILE_PROTOCOL; WHERE wr1 : QUERY(CLASS <* SELF\DICTIONARY.contained_classes | (SIZEOF(CLASS\ BASIC_SEMANTIC_UNIT.referenced_by) = 1) AND ( 'ISO13584_G_M_IIM_SCHEMA.MODEL_CLASS_EXTENSION' IN TYPEOF (CLASS\BASIC_SEMANTIC_UNIT.referenced_by[1])) AND NOT (LIST_TO_SET( CLASS\BASIC_SEMANTIC_UNIT.referenced_by[1]\MODEL_CLASS_EXTENSION. referenced_view_exchange_protocol) <= SELF\DICTIONARY.supported_vep)) = []; wr2 : QUERY(CLASS <* SELF.contained_classes | (SIZEOF(CLASS\ BASIC_SEMANTIC_UNIT.referenced_by) = 1) AND ( 'ISO13584_G_M_IIM_SCHEMA.MODEL_CLASS_EXTENSION' IN TYPEOF(CLASS\ BASIC_SEMANTIC_UNIT.referenced_by[1])) AND ((SIZEOF(QUERY(pr <* CLASS\ BASIC_SEMANTIC_UNIT.referenced_by[1]\MODEL_CLASS_EXTENSION. referenced_external_items | NOT (pr\EXTERNAL_ITEM.used_protocol IN SELF\DICTIONARY.base_protocols) AND NOT (pr\EXTERNAL_ITEM. used_protocol IN SELF.linked_interfaces))) <> 0) AND (SIZEOF(QUERY(dat <* CLASS\BASIC_SEMANTIC_UNIT.referenced_by[1]\MODEL_CLASS_EXTENSION. referenced_external_items | NOT (dat\EXTERNAL_ITEM.used_protocol IN SELF.base_protocols))) <> 0))) = []; wr3 : QUERY(int <* SELF.linked_interfaces | NOT (( 'ISO13584_G_M_IIM_SCHEMA.LINKED_INTERFACE_PROGRAM_PROTOCOL' ) IN TYPEOF(int))) = []; END_ENTITY;
ENTITY library_in_standard_format SUBTYPE OF (LIBRARY,DICTIONARY_IN_STANDARD_FORMAT); WHERE wr1 : QUERY(int <* SELF\LIBRARY.linked_interfaces | SIZEOF(QUERY(vep <* SELF \DICTIONARY.supported_vep | int\EXTERNAL_FILE_PROTOCOL.base_protocol IN vep\DATA_EXCHANGE_SPECIFICATION_ID.external_file_protocols)) = 0) = []; END_ENTITY;
ENTITY opt_or_mand_property_bsu; property : PROPERTY_BSU; is_optional : BOOLEAN; displayable : BOOLEAN; END_ENTITY;
ENTITY A6_illustration SUBTYPE OF (ILLUSTRATION); END_ENTITY;
ENTITY A9_illustration SUBTYPE OF (ILLUSTRATION); END_ENTITY;
ENTITY document_content SUBTYPE OF (CLASS_BSU_RELATED_CONTENT); SELF\content_item.dictionary_definition : DOCUMENT_BSU; SELF\external_item.used_protocol : DATA_PROTOCOL; END_ENTITY;
ENTITY external_file_unit SUPERTYPE OF (HTTP_FILE); file : EXTERNAL_FILE_ADDRESS; content_encoding : OPTIONAL CONTENT_ENCODING_TYPE; INVERSE unit_of : LANGUAGE_SPECIFIC_CONTENT FOR content_files; WHERE wr1 : (('ISO13584_G_M_IIM_SCHEMA.HTTP_PROTOCOL' IN TYPEOF(SELF.unit_of. content_of.content_of.used_protocol)) AND ( 'ISO13584_G_M_IIM_SCHEMA.HTTP_FILE' IN TYPEOF(SELF))) XOR NOT (( 'ISO13584_G_M_IIM_SCHEMA.HTTP_PROTOCOL' IN TYPEOF(SELF.unit_of. content_of.content_of.used_protocol)) OR ( 'ISO13584_G_M_IIM_SCHEMA.HTTP_FILE' IN TYPEOF(SELF.file))); END_ENTITY;
ENTITY http_class_directory; name : HTTP_DIRECTORY_NAME_TYPE; class : CLASS_BSU; UNIQUE ur1 : CLASS; END_ENTITY;
ENTITY http_file SUBTYPE OF (EXTERNAL_FILE_UNIT); mime : MIME_TYPE; exchange_format : MIME_SUBTYPE; format_RFC : OPTIONAL IAB_RFC; http_file_name : HTTP_FILE_NAME_TYPE; http_directory : OPTIONAL HTTP_CLASS_DIRECTORY; remote_access : OPTIONAL ABSOLUTE_URL_TYPE; UNIQUE UR1: http_file_name, http_directory; WHERE WR1: EXISTS(http_directory) XOR ('ISO13584_G_M_IIM_SCHEMA.SUPPLIER_BSU_RELATED_CONTENT' IN TYPEOF( SELF.unit_of.content_of.content_of)); END_ENTITY;
ENTITY http_protocol SUBTYPE OF (STANDARD_DATA_PROTOCOL); http_rfc : IAB_RFC; DERIVE SELF\external_file_protocol.protocol_name : IDENTIFIER := 'http'; END_ENTITY;
ENTITY illustration SUPERTYPE OF (ONEOF(A6_ILLUSTRATION,A9_ILLUSTRATION)) SUBTYPE OF (DIALOGUE_RESOURCE, GRAPHICS); kind_of_content : ILLUSTRATION_TYPE; width: OPTIONAL LENGTH_MEASURE_WITH_UNIT; height: OPTIONAL LENGTH_MEASURE_WITH_UNIT; WHERE WR1: (NOT EXISTS (SELF.width) AND NOT EXISTS (SELF.height)) OR (EXISTS (SELF.width) AND EXISTS (SELF.height)); END_ENTITY;
ENTITY language_specific_content; content_files : SET[1:?] OF EXTERNAL_FILE_UNIT; main_file : OPTIONAL EXTERNAL_FILE_UNIT; character_encoding : OPTIONAL CHARACTER_SET_TYPE; INVERSE content_of : EXTERNAL_CONTENT FOR consists_of; WHERE wr1 : NOT EXISTS(main_file) OR (main_file IN content_files); wr2 : EXISTS(main_file) XOR ( 'ISO13584_G_M_IIM_SCHEMA.PROGRAM_LIBRARY_CONTENT' IN TYPEOF(SELF. content_of.content_of)); wr3 : EXISTS(character_encoding) OR NOT ( 'ISO13584_G_M_IIM_SCHEMA.HTTP_PROTOCOL' IN TYPEOF(SELF.content_of .content_of.used_protocol)); END_ENTITY;
ENTITY message SUBTYPE OF (DIALOGUE_RESOURCE); END_ENTITY;
ENTITY non_standard_data_protocol SUBTYPE OF (DATA_PROTOCOL,NON_STANDARD_PROTOCOL); WHERE wr1 : NOT EXISTS(SELF\EXTERNAL_FILE_PROTOCOL.base_protocol); END_ENTITY;
ENTITY not_translatable_external_content SUBTYPE OF (EXTERNAL_CONTENT); the_value : LANGUAGE_SPECIFIC_CONTENT; DERIVE SELF\external_content.consists_of : SET[1:1] OF LANGUAGE_SPECIFIC_CONTENT := [the_value]; END_ENTITY;
ENTITY not_translated_external_content SUBTYPE OF (EXTERNAL_CONTENT); the_value : LANGUAGE_SPECIFIC_CONTENT; DERIVE SELF\external_content.consists_of : SET[1:1] OF LANGUAGE_SPECIFIC_CONTENT := [the_value]; END_ENTITY;
ENTITY standard_data_protocol SUBTYPE OF (DATA_PROTOCOL,STANDARD_PROTOCOL); WHERE wr1 : NOT EXISTS(SELF\EXTERNAL_FILE_PROTOCOL.base_protocol); END_ENTITY;
ENTITY translated_external_content SUBTYPE OF (EXTERNAL_CONTENT); values : LIST[1:?] OF LANGUAGE_SPECIFIC_CONTENT; languages : PRESENT_TRANSLATIONS; DERIVE SELF\external_content.consists_of : SET[1:?] OF LANGUAGE_SPECIFIC_CONTENT := LIST_TO_SET(values); WHERE wr1 : SIZEOF(SELF.values) = SIZEOF(SELF.languages.language_codes); END_ENTITY;
ENTITY si_unit SUBTYPE OF (NAMED_UNIT); prefix : OPTIONAL SI_PREFIX; name : SI_UNIT_NAME; DERIVE SELF\named_unit.dimensions : DIMENSIONAL_EXPONENTS := DIMENSIONS_FOR_SI_UNIT (SELF.name); END_ENTITY;
ENTITY named_unit SUPERTYPE OF (ONEOF(SI_UNIT,CONVERSION_BASED_UNIT,CONTEXT_DEPENDENT_UNIT) ANDOR ONEOF(LENGTH_UNIT,MASS_UNIT,TIME_UNIT, ELECTRIC_CURRENT_UNIT,THERMODYNAMIC_TEMPERATURE_UNIT, AMOUNT_OF_SUBSTANCE_UNIT,LUMINOUS_INTENSITY_UNIT, PLANE_ANGLE_UNIT,SOLID_ANGLE_UNIT,AREA_UNIT,VOLUME_UNIT, RATIO_UNIT)); dimensions : DIMENSIONAL_EXPONENTS; END_ENTITY;
ENTITY conversion_based_unit SUBTYPE OF (NAMED_UNIT); name : LABEL; conversion_factor : MEASURE_WITH_UNIT; END_ENTITY;
ENTITY context_dependent_unit SUBTYPE OF (NAMED_UNIT); name : LABEL; END_ENTITY;
ENTITY length_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 1.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY mass_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 1.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY time_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 1.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY electric_current_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 1.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY thermodynamic_temperature_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 1.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY amount_of_substance_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 1.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY luminous_intensity_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 1.0); END_ENTITY;
ENTITY plane_angle_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY solid_angle_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY area_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 2.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY volume_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 3.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY ratio_unit SUBTYPE OF (NAMED_UNIT); WHERE wr1 : (SELF\NAMED_UNIT.dimensions.length_exponent = 0.0) AND (SELF\ NAMED_UNIT.dimensions.mass_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.time_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. electric_current_exponent = 0.0) AND (SELF\NAMED_UNIT.dimensions. thermodynamic_temperature_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.amount_of_substance_exponent = 0.0) AND (SELF\NAMED_UNIT. dimensions.luminous_intensity_exponent = 0.0); END_ENTITY;
ENTITY dimensional_exponents; length_exponent : REAL; mass_exponent : REAL; time_exponent : REAL; electric_current_exponent : REAL; thermodynamic_temperature_exponent : REAL; amount_of_substance_exponent : REAL; luminous_intensity_exponent : REAL; END_ENTITY;
ENTITY derived_unit_element; unit : NAMED_UNIT; exponent : REAL; END_ENTITY;
ENTITY derived_unit; elements : SET[1:?] OF DERIVED_UNIT_ELEMENT; WHERE wr1 : (SIZEOF(elements) > 1) OR ((SIZEOF(elements) = 1) AND (elements[1]. exponent <> 1.0)); END_ENTITY;
ENTITY global_unit_assigned_context SUBTYPE OF (REPRESENTATION_CONTEXT); units : SET[1:?] OF UNIT; END_ENTITY;
ENTITY measure_with_unit SUPERTYPE OF (ONEOF(LENGTH_MEASURE_WITH_UNIT,MASS_MEASURE_WITH_UNIT, TIME_MEASURE_WITH_UNIT,ELECTRIC_CURRENT_MEASURE_WITH_UNIT, THERMODYNAMIC_TEMPERATURE_MEASURE_WITH_UNIT, AMOUNT_OF_SUBSTANCE_MEASURE_WITH_UNIT, LUMINOUS_INTENSITY_MEASURE_WITH_UNIT, PLANE_ANGLE_MEASURE_WITH_UNIT,SOLID_ANGLE_MEASURE_WITH_UNIT, AREA_MEASURE_WITH_UNIT,VOLUME_MEASURE_WITH_UNIT, RATIO_MEASURE_WITH_UNIT)); value_component : MEASURE_VALUE; unit_component : UNIT; WHERE wr1 : VALID_UNITS(SELF); END_ENTITY;
ENTITY length_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.LENGTH_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY mass_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.MASS_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY time_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.TIME_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY electric_current_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.ELECTRIC_CURRENT_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY thermodynamic_temperature_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.THERMODYNAMIC_TEMPERATURE_UNIT' IN TYPEOF(SELF\MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY amount_of_substance_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.AMOUNT_OF_SUBSTANCE_UNIT' IN TYPEOF(SELF \MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY luminous_intensity_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.LUMINOUS_INTENSITY_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY plane_angle_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.PLANE_ANGLE_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY solid_angle_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.SOLID_ANGLE_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY area_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.AREA_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY volume_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.VOLUME_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY ratio_measure_with_unit SUBTYPE OF (MEASURE_WITH_UNIT); WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.RATIO_UNIT' IN TYPEOF(SELF\ MEASURE_WITH_UNIT.unit_component); END_ENTITY;
ENTITY organization; id : OPTIONAL IDENTIFIER; name : LABEL; description : TEXT; END_ENTITY;
ENTITY address; internal_location : OPTIONAL LABEL; street_number : OPTIONAL LABEL; street : OPTIONAL LABEL; postal_box : OPTIONAL LABEL; town : OPTIONAL LABEL; region : OPTIONAL LABEL; postal_code : OPTIONAL LABEL; country : OPTIONAL LABEL; facsimile_number : OPTIONAL LABEL; telephone_number : OPTIONAL LABEL; electronic_mail_address : OPTIONAL LABEL; telex_number : OPTIONAL LABEL; WHERE wr1 : EXISTS(internal_location) OR EXISTS(street_number) OR EXISTS(street) OR EXISTS(postal_box) OR EXISTS(town) OR EXISTS(region) OR EXISTS( postal_code) OR EXISTS(country) OR EXISTS(facsimile_number) OR EXISTS( telephone_number) OR EXISTS(electronic_mail_address) OR EXISTS( telex_number); END_ENTITY;
ENTITY axis1_placement SUBTYPE OF (PLACEMENT); axis : OPTIONAL DIRECTION; DERIVE z : DIRECTION := NVL(NORMALISE(axis),DIRECTION([0.0,0.0,1.0])); WHERE wr1 : SELF\GEOMETRIC_REPRESENTATION_ITEM.dim = 3; END_ENTITY;
ENTITY axis2_placement_2d SUBTYPE OF (PLACEMENT); ref_direction : OPTIONAL DIRECTION; DERIVE p : LIST[2:2] OF DIRECTION := BUILD_2AXES(ref_direction); WHERE wr1 : SELF\GEOMETRIC_REPRESENTATION_ITEM.dim = 2; END_ENTITY;
ENTITY axis2_placement_3d SUBTYPE OF (PLACEMENT); axis : OPTIONAL DIRECTION; ref_direction : OPTIONAL DIRECTION; DERIVE p : LIST[3:3] OF DIRECTION := BUILD_AXES(axis,ref_direction); WHERE wr1 : SELF\PLACEMENT.location.dim = 3; wr2 : (NOT (EXISTS(axis))) OR (axis.dim = 3); wr3 : (NOT (EXISTS(ref_direction))) OR (ref_direction.dim = 3); wr4 : (NOT (EXISTS(axis))) OR (NOT (EXISTS(ref_direction))) OR ( CROSS_PRODUCT(axis,ref_direction).magnitude > 0.0); END_ENTITY;
ENTITY geometric_representation_context SUBTYPE OF (REPRESENTATION_CONTEXT); coordinate_space_dimension : DIMENSION_COUNT; END_ENTITY;
ENTITY placement SUPERTYPE OF (ONEOF(AXIS1_PLACEMENT,AXIS2_PLACEMENT_2D,AXIS2_PLACEMENT_3D)) SUBTYPE OF (GEOMETRIC_REPRESENTATION_ITEM); location : CARTESIAN_POINT; END_ENTITY;
ENTITY representation; name : LABEL; items : SET[1:?] OF REPRESENTATION_ITEM; context_of_items : REPRESENTATION_CONTEXT; END_ENTITY;
ENTITY representation_context; context_identifier : IDENTIFIER; context_type : TEXT; INVERSE representations_in_context : SET[1:?] OF REPRESENTATION FOR context_of_items; END_ENTITY;
ENTITY representation_item; name : LABEL; WHERE wr1 : SIZEOF(USING_REPRESENTATIONS(SELF)) > 0; END_ENTITY;
ENTITY generic_variable ABSTRACT SUPERTYPE SUBTYPE OF (SIMPLE_GENERIC_EXPRESSION); INVERSE interpretation : ENVIRONMENT FOR syntactic_representation; END_ENTITY;
ENTITY variable_semantics ABSTRACT SUPERTYPE; END_ENTITY;
ENTITY unary_function_call ABSTRACT SUPERTYPE OF (ONEOF(ABS_FUNCTION,MINUS_FUNCTION,SIN_FUNCTION, COS_FUNCTION,TAN_FUNCTION,ASIN_FUNCTION,ACOS_FUNCTION, EXP_FUNCTION,LOG_FUNCTION,LOG2_FUNCTION,LOG10_FUNCTION ,SQUARE_ROOT_FUNCTION)) SUBTYPE OF (UNARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY multiple_arity_boolean_expression ABSTRACT SUPERTYPE OF (ONEOF(AND_EXPRESSION,OR_EXPRESSION)) SUBTYPE OF (BOOLEAN_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF BOOLEAN_EXPRESSION; END_ENTITY;
ENTITY binary_function_call ABSTRACT SUPERTYPE OF (ATAN_FUNCTION) SUBTYPE OF (BINARY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY simple_boolean_expression ABSTRACT SUPERTYPE OF (ONEOF(BOOLEAN_LITERAL,BOOLEAN_VARIABLE)) SUBTYPE OF (BOOLEAN_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY generic_literal ABSTRACT SUPERTYPE SUBTYPE OF (SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY variable ABSTRACT SUPERTYPE OF (ONEOF(NUMERIC_VARIABLE,BOOLEAN_VARIABLE, STRING_VARIABLE)) SUBTYPE OF (GENERIC_VARIABLE); END_ENTITY;
ENTITY comparison_expression ABSTRACT SUPERTYPE OF (ONEOF(COMPARISON_EQUAL,COMPARISON_GREATER, COMPARISON_GREATER_EQUAL,COMPARISON_LESS, COMPARISON_LESS_EQUAL,COMPARISON_NOT_EQUAL, LIKE_EXPRESSION)) SUBTYPE OF (BOOLEAN_EXPRESSION,BINARY_GENERIC_EXPRESSION); SELF\binary_generic_expression.operands : LIST[2:2] OF EXPRESSION; WHERE wr1 : (('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[1])) AND ( 'ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[2]))) OR (( 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[1])) AND ( 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[2]))) OR (( 'ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[1])) AND ( 'ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF(SELF\ BINARY_GENERIC_EXPRESSION.operands[2]))); END_ENTITY;
ENTITY string_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_STRING_EXPRESSION,INDEX_EXPRESSION, SUBSTRING_EXPRESSION,CONCAT_EXPRESSION,FORMAT_FUNCTION )) SUBTYPE OF (EXPRESSION); END_ENTITY;
ENTITY multiple_arity_generic_expression ABSTRACT SUPERTYPE SUBTYPE OF (GENERIC_EXPRESSION); operands : LIST[2:?] OF GENERIC_EXPRESSION; END_ENTITY;
ENTITY binary_numeric_expression ABSTRACT SUPERTYPE OF (ONEOF(MINUS_EXPRESSION,DIV_EXPRESSION,MOD_EXPRESSION, SLASH_EXPRESSION,POWER_EXPRESSION,BINARY_FUNCTION_CALL )) SUBTYPE OF (NUMERIC_EXPRESSION,BINARY_GENERIC_EXPRESSION); SELF\binary_generic_expression.operands : LIST[2:2] OF NUMERIC_EXPRESSION; END_ENTITY;
ENTITY binary_boolean_expression ABSTRACT SUPERTYPE OF (ONEOF(XOR_EXPRESSION,EQUALS_EXPRESSION)) SUBTYPE OF (BOOLEAN_EXPRESSION,BINARY_GENERIC_EXPRESSION); END_ENTITY;
ENTITY binary_generic_expression ABSTRACT SUPERTYPE SUBTYPE OF (GENERIC_EXPRESSION); operands : LIST[2:2] OF GENERIC_EXPRESSION; END_ENTITY;
ENTITY generic_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_GENERIC_EXPRESSION, UNARY_GENERIC_EXPRESSION,BINARY_GENERIC_EXPRESSION, MULTIPLE_ARITY_GENERIC_EXPRESSION)); WHERE wr1 : IS_ACYCLIC(SELF); END_ENTITY;
ENTITY boolean_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_BOOLEAN_EXPRESSION, UNARY_BOOLEAN_EXPRESSION,BINARY_BOOLEAN_EXPRESSION, MULTIPLE_ARITY_BOOLEAN_EXPRESSION, COMPARISON_EXPRESSION,INTERVAL_EXPRESSION, BOOLEAN_DEFINED_FUNCTION)) SUBTYPE OF (EXPRESSION); END_ENTITY;
ENTITY literal_number ABSTRACT SUPERTYPE OF (ONEOF(INT_LITERAL,REAL_LITERAL)) SUBTYPE OF (SIMPLE_NUMERIC_EXPRESSION,GENERIC_LITERAL); the_value : NUMBER; END_ENTITY;
ENTITY numeric_variable SUPERTYPE OF (ONEOF(INT_NUMERIC_VARIABLE,REAL_NUMERIC_VARIABLE)) SUBTYPE OF (SIMPLE_NUMERIC_EXPRESSION,VARIABLE); WHERE wr1 : ('ISO13584_G_M_IIM_SCHEMA.INT_NUMERIC_VARIABLE' IN TYPEOF(SELF)) OR ('ISO13584_G_M_IIM_SCHEMA.REAL_NUMERIC_VARIABLE' IN TYPEOF( SELF)); END_ENTITY;
ENTITY numeric_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_NUMERIC_EXPRESSION, UNARY_NUMERIC_EXPRESSION,BINARY_NUMERIC_EXPRESSION, MULTIPLE_ARITY_NUMERIC_EXPRESSION,LENGTH_FUNCTION, VALUE_FUNCTION)) SUBTYPE OF (EXPRESSION); DERIVE is_int : BOOLEAN := IS_INT_EXPR(SELF); sql_mappable : BOOLEAN := IS_SQL_MAPPABLE(SELF); END_ENTITY;
ENTITY unary_generic_expression ABSTRACT SUPERTYPE SUBTYPE OF (GENERIC_EXPRESSION); operand : GENERIC_EXPRESSION; END_ENTITY;
ENTITY multiple_arity_function_call ABSTRACT SUPERTYPE OF (ONEOF(MAXIMUM_FUNCTION,MINIMUM_FUNCTION)) SUBTYPE OF (MULTIPLE_ARITY_NUMERIC_EXPRESSION); END_ENTITY;
ENTITY multiple_arity_numeric_expression ABSTRACT SUPERTYPE OF (ONEOF(PLUS_EXPRESSION,MULT_EXPRESSION, MULTIPLE_ARITY_FUNCTION_CALL)) SUBTYPE OF (NUMERIC_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF NUMERIC_EXPRESSION; END_ENTITY;
ENTITY unary_boolean_expression ABSTRACT SUPERTYPE OF (ONEOF(NOT_EXPRESSION,ODD_FUNCTION)) SUBTYPE OF (BOOLEAN_EXPRESSION,UNARY_GENERIC_EXPRESSION); END_ENTITY;
ENTITY simple_string_expression ABSTRACT SUPERTYPE OF (ONEOF(STRING_LITERAL,STRING_VARIABLE)) SUBTYPE OF (STRING_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY simple_type ABSTRACT SUPERTYPE OF (ONEOF(NUMBER_TYPE,BOOLEAN_TYPE,STRING_TYPE)) SUBTYPE OF (DATA_TYPE); value_format : VALUE_FORMAT_TYPE; END_ENTITY;
ENTITY basic_semantic_unit ABSTRACT SUPERTYPE OF (ONEOF(SUPPLIER_BSU,CLASS_BSU,PROPERTY_BSU, DATA_TYPE_BSU,SUPPLIER_RELATED_BSU,CLASS_RELATED_BSU)) ; code : CODE_TYPE; version : VERSION_TYPE; DERIVE dic_identifier : IDENTIFIER := code + SEP_CV + version; INVERSE definition : SET[0:1] OF DICTIONARY_ELEMENT FOR identified_by; referenced_by : SET[0:1] OF CONTENT_ITEM FOR dictionary_definition; END_ENTITY;
-- basic_semantic_unit ENTITY class ABSTRACT SUPERTYPE OF (ITEM_CLASS) SUBTYPE OF (CLASS_AND_PROPERTY_ELEMENTS); SELF\dictionary_element.identified_by : CLASS_BSU; its_superclass : OPTIONAL CLASS_BSU; described_by : LIST[0:?] OF UNIQUE PROPERTY_BSU; defined_types : SET[0:?] OF DATA_TYPE_BSU; DERIVE subclasses : SET[0:?] OF CLASS := identified_by.subclasses; known_applicable_properties : SET[0:?] OF PROPERTY_BSU := COMPUTE_KNOWN_APPLICABLE_PROPERTIES(SELF\ DICTIONARY_ELEMENT.identified_by); known_applicable_data_types : SET[0:?] OF DATA_TYPE_BSU := COMPUTE_KNOWN_APPLICABLE_DATA_TYPES(SELF\ DICTIONARY_ELEMENT.identified_by); INVERSE associated_items : SET[0:?] OF CLASS_BSU_RELATIONSHIP FOR relating_class; WHERE wr1 : ACYCLIC_SUPERCLASS_RELATIONSHIP(SELF.identified_by,[]); wr2 : NOT ALL_CLASS_DESCRIPTIONS_REACHABLE(SELF\DICTIONARY_ELEMENT. identified_by) OR (LIST_TO_SET(SELF.described_by) <= SELF\ DICTIONARY_ELEMENT.identified_by\CLASS_BSU.known_visible_properties); wr3 : NOT ALL_CLASS_DESCRIPTIONS_REACHABLE(SELF\DICTIONARY_ELEMENT. identified_by) OR (SELF.defined_types <= SELF\DICTIONARY_ELEMENT. identified_by\CLASS_BSU.known_visible_data_types); wr4 : LIST_TO_SET(SELF.described_by) * NVL(SELF.its_superclass.definition[1] \CLASS.known_applicable_properties,[]) = []; wr5 : SELF.defined_types * NVL(SELF.its_superclass.definition[1]\CLASS. known_applicable_data_types,[]) = []; END_ENTITY;
ENTITY complex_type ABSTRACT SUPERTYPE OF (ONEOF(LEVEL_TYPE,CLASS_INSTANCE_TYPE, ENTITY_INSTANCE_TYPE)) SUBTYPE OF (DATA_TYPE); END_ENTITY;
ENTITY property_det ABSTRACT SUPERTYPE OF (ONEOF(CONDITION_DET,DEPENDENT_P_DET, NON_DEPENDENT_P_DET)) SUBTYPE OF (CLASS_AND_PROPERTY_ELEMENTS); SELF\dictionary_element.identified_by : PROPERTY_BSU; preferred_symbol : OPTIONAL MATHEMATICAL_STRING; synonymous_symbols : SET[0:2] OF MATHEMATICAL_STRING; figure : OPTIONAL GRAPHICS; det_classification : OPTIONAL DET_CLASSIFICATION_TYPE; domain : DATA_TYPE; formula : OPTIONAL MATHEMATICAL_STRING; DERIVE describes_classes : SET[0:?] OF CLASS := identified_by.describes_classes; END_ENTITY;
ENTITY dictionary_element ABSTRACT SUPERTYPE OF (ONEOF(SUPPLIER_ELEMENT,CLASS_AND_PROPERTY_ELEMENTS, DATA_TYPE_ELEMENT)); identified_by : BASIC_SEMANTIC_UNIT; time_stamps : OPTIONAL DATES; revision : REVISION_TYPE; END_ENTITY;
ENTITY data_type ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_TYPE,COMPLEX_TYPE,NAMED_TYPE)); END_ENTITY;
ENTITY document ABSTRACT SUPERTYPE; END_ENTITY;
ENTITY graphics ABSTRACT SUPERTYPE; END_ENTITY;
ENTITY referenced_graphics SUBTYPE OF (GRAPHICS); graphics_reference: DOCUMENT_BSU; END_ENTITY;
ENTITY referenced_document SUBTYPE OF (DOCUMENT); document_reference: DOCUMENT_BSU; WHERE WR1 : NOT ('ISO13584_G_M_IIM_SCHEMA.IDENTIFIED_DOCUMENT' IN TYPEOF (SELF)); END_ENTITY;
ENTITY supplier_bsu_relationship ABSTRACT SUPERTYPE; relating_supplier : SUPPLIER_ELEMENT; related_tokens : SET[1:?] OF SUPPLIER_RELATED_BSU; END_ENTITY;
ENTITY dic_item_instance ABSTRACT SUPERTYPE OF (ONEOF(DIC_COMPONENT_INSTANCE,DIC_MATERIAL_INSTANCE, DIC_FEATURE_INSTANCE) ANDOR LIB_ITEM_INSTANCE) SUBTYPE OF (DIC_CLASS_INSTANCE); WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\DIC_CLASS_INSTANCE.class_def, 'ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS' IN TYPEOF(SELF\ DIC_CLASS_INSTANCE.class_def.definition[1])); wr2 : NOT (ALL_CLASS_DESCRIPTIONS_REACHABLE(SELF.class_def)) OR (QUERY(prop <* SELF.properties | ((SIZEOF(prop.prop_def.definition) = 1) AND ( 'ISO13584_G_M_IIM_SCHEMA.DEPENDENT_P_DET' IN TYPEOF(prop.prop_def .definition[1])) AND EXISTS(prop.its_value) AND (QUERY(ctxt <* prop. prop_def.definition[1]\DEPENDENT_P_DET.depends_on | SIZEOF(QUERY(prop2 <* SELF.properties | ((prop2.prop_def = ctxt) AND EXISTS(prop2. its_value)))) <> 1) <> []))) = []); END_ENTITY;
ENTITY dic_class_instance ABSTRACT SUPERTYPE OF (DIC_ITEM_INSTANCE); class_def : CLASS_BSU; properties : SET[0:?] OF PROPERTY_VALUE; WHERE wr1 : (QUERY(prop <* SELF.properties | NOT ((APPLICABLE_PROPERTIES(SELF. class_def,[prop.prop_def])))) = []); wr2 : QUERY(prop <* SELF.properties | (SIZEOF(QUERY(prop1 <* SELF.properties | prop1.prop_def = prop.prop_def)) = 1)) = SELF.properties; END_ENTITY;
ENTITY level_spec_value ABSTRACT SUPERTYPE OF (ONEOF(INT_LEVEL_SPEC_VALUE,REAL_LEVEL_SPEC_VALUE)); values : ARRAY[4:4] OF OPTIONAL NUMBER; END_ENTITY;
ENTITY lib_item_instance ABSTRACT SUPERTYPE OF (ONEOF(LIB_COMPONENT_INSTANCE,LIB_MATERIAL_INSTANCE, LIB_FEATURE_INSTANCE)) SUBTYPE OF (DIC_ITEM_INSTANCE); supplier_identification : OPTIONAL STRING; supplier_designation : OPTIONAL STRING; user_identification : OPTIONAL STRING; user_designation : OPTIONAL STRING; WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\DIC_CLASS_INSTANCE.class_def,(SIZEOF (SELF\DIC_CLASS_INSTANCE.class_def.referenced_by) = 1)); wr2 : QUERY(prop <* SELF.properties | NOT ((ALLOWED_PROPERTIES(SELF\ DIC_CLASS_INSTANCE.class_def,[prop.prop_def])))) = []; wr3 : NOT ALL_CLASS_DESCRIPTIONS_REACHABLE(SELF\DIC_CLASS_INSTANCE.class_def ) OR (QUERY(prop <* GM_FREE_CHARACTERISTICS_LIST(SELF\ DIC_CLASS_INSTANCE.class_def) | NOT (prop IN COLLECTS_ASSIGNED_INSTANCE_PROPERTIES(SELF\DIC_CLASS_INSTANCE. properties))) = []); END_ENTITY;
ENTITY class_instance_constructor ABSTRACT SUPERTYPE OF (ONEOF(UNARY_CLASS_INSTANCE_CONSTRUCTOR, BINARY_CLASS_INSTANCE_CONSTRUCTOR, MULTIPLE_ARITY_CLASS_INSTANCE_CONSTRUCTOR)) SUBTYPE OF (CLASS_INSTANCE_EXPRESSION); properties : SET[1:?] OF PROPERTY_ASSIGNMENT; WHERE wr1 : DEFINITION_AVAILABLE_IMPLIES(SELF\CLASS_INSTANCE_EXPRESSION.expr_type, APPLICABLE_PROPERTIES(SELF\CLASS_INSTANCE_EXPRESSION.expr_type, LIST_TO_SET(COLLECTS_ASSIGNED_PROPERTIES(SELF.properties)))); END_ENTITY;
ENTITY binary_class_instance_expression ABSTRACT SUPERTYPE OF (BINARY_CLASS_INSTANCE_CONSTRUCTOR) SUBTYPE OF (CLASS_INSTANCE_EXPRESSION,BINARY_GENERIC_EXPRESSION); END_ENTITY;
ENTITY simple_class_instance_expression ABSTRACT SUPERTYPE OF (ONEOF(CLASS_INSTANCE_VARIABLE,CLASS_INSTANCE_LITERAL)) SUBTYPE OF (CLASS_INSTANCE_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY class_instance_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_CLASS_INSTANCE_EXPRESSION, UNARY_CLASS_INSTANCE_EXPRESSION, BINARY_CLASS_INSTANCE_EXPRESSION, MULTIPLE_ARITY_CLASS_INSTANCE_EXPRESSION)) SUBTYPE OF (GENERIC_EXPRESSION); expr_type : CLASS_BSU; END_ENTITY;
ENTITY simple_entity_instance_expression ABSTRACT SUPERTYPE OF (ONEOF(ENTITY_INSTANCE_VARIABLE,ENTITY_INSTANCE_LITERAL )) SUBTYPE OF (ENTITY_INSTANCE_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY entity_instance_expression ABSTRACT SUPERTYPE OF (SIMPLE_ENTITY_INSTANCE_EXPRESSION) SUBTYPE OF (GENERIC_EXPRESSION); type_name : SET[1:?] OF STRING; END_ENTITY;
ENTITY boolean_defined_function ABSTRACT SUPERTYPE SUBTYPE OF (DEFINED_FUNCTION,BOOLEAN_EXPRESSION); END_ENTITY;
ENTITY level_spec_literal ABSTRACT SUPERTYPE OF (ONEOF(INT_LEVEL_SPEC_LITERAL,REAL_LEVEL_SPEC_LITERAL)) SUBTYPE OF (SIMPLE_LEVEL_SPEC_EXPRESSION,GENERIC_LITERAL); the_value : LEVEL_SPEC_VALUE; WHERE wr1 : COMPATIBLE_LEVEL_TYPE_AND_INSTANCE(SELF\LEVEL_SPEC_EXPRESSION.levels, TYPEOF(SELF\LEVEL_SPEC_EXPRESSION.VALUE_TYPE),SELF.the_value); END_ENTITY;
ENTITY level_spec_expression ABSTRACT SUPERTYPE OF (SIMPLE_LEVEL_SPEC_EXPRESSION) SUBTYPE OF (GENERIC_EXPRESSION); levels : LIST[1:4] OF UNIQUE LEVEL; value_type : NUMBER_TYPE; END_ENTITY;
ENTITY level_spec_variable ABSTRACT SUPERTYPE OF (ONEOF(INT_LEVEL_SPEC_VARIABLE,REAL_LEVEL_SPEC_VARIABLE )) SUBTYPE OF (SIMPLE_LEVEL_SPEC_EXPRESSION,GENERIC_VARIABLE); END_ENTITY;
ENTITY multiple_arity_class_instance_expression ABSTRACT SUPERTYPE OF (MULTIPLE_ARITY_CLASS_INSTANCE_CONSTRUCTOR) SUBTYPE OF (CLASS_INSTANCE_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); END_ENTITY;
ENTITY unary_class_instance_expression ABSTRACT SUPERTYPE OF (UNARY_CLASS_INSTANCE_CONSTRUCTOR) SUBTYPE OF (CLASS_INSTANCE_EXPRESSION,UNARY_GENERIC_EXPRESSION); END_ENTITY;
ENTITY simple_column ABSTRACT SUPERTYPE OF (ONEOF(BOOLEAN_COLUMN,FORMATTED_COLUMN)) SUBTYPE OF (COLUMN); SELF\column.values : LIST[1:?] OF SIMPLE_VALUE; END_ENTITY;
ENTITY complex_column ABSTRACT SUPERTYPE OF (ONEOF(LEVEL_SPEC_COLUMN,ENTITY_INSTANCE_COLUMN, CLASS_INSTANCE_COLUMN)) SUBTYPE OF (COLUMN); SELF\column.values : LIST[1:?] OF COMPLEX_VALUE; END_ENTITY;
ENTITY column ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_COLUMN,COMPLEX_COLUMN)); values : LIST[1:?] OF PRIMITIVE_VALUE; INVERSE belongs_to : TABLE_EXTENSION FOR content; END_ENTITY;
ENTITY table_expression ABSTRACT SUPERTYPE OF (ONEOF(SIMPLE_TABLE_EXPRESSION, UNARY_TABLE_EXPRESSION, BINARY_TABLE_EXPRESSION, MULTIPLE_ARITY_TABLE_EXPRESSION, SELECT_EXPRESSION)) SUBTYPE OF (GENERIC_EXPRESSION); DERIVE its_columns: LIST[1:?] OF VARIABLE_SEMANTICS :=COLLECTS_COLUMNS (SELF); the_key: SET[1:?] OF VARIABLE_SEMANTICS := RETURN_KEY(SELF); is_SQL_mappable: LOGICAL := IS_SQL_MAPPABLE_TABLE_EXPRESSION (SELF); WHERE WR1: QUERY (sem<*its_columns |SIZEOF (QUERY (sem_2 <* its_columns |sem_2 :=: sem)) <> 1) = []; END_ENTITY;
ENTITY set_table_expression ABSTRACT SUPERTYPE OF (ONEOF(UNION_TABLE_EXPRESSION, INTERSECT_TABLE_EXPRESSION,DIFFERENCE_TABLE_EXPRESSION )) SUBTYPE OF (BINARY_TABLE_EXPRESSION); WHERE wr1 : SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands[1]\TABLE_EXPRESSION. its_columns = SELF\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands[2]\ TABLE_EXPRESSION.its_columns; END_ENTITY;
ENTITY number_column ABSTRACT SUPERTYPE OF (ONEOF(REAL_COLUMN,INTEGER_COLUMN)) SUBTYPE OF (FORMATTED_COLUMN); SELF\column.values : LIST[1:?] OF NUMBER_VALUE; END_ENTITY;
ENTITY formatted_column ABSTRACT SUPERTYPE OF (ONEOF(NUMBER_COLUMN,STRING_COLUMN)) SUBTYPE OF (SIMPLE_COLUMN); value_format : VALUE_FORMAT_TYPE; END_ENTITY;
ENTITY level_spec_column ABSTRACT SUPERTYPE OF (ONEOF(INT_LEVEL_SPEC_COLUMN,REAL_LEVEL_SPEC_COLUMN)) SUBTYPE OF (COMPLEX_COLUMN); levels : LIST[1:4] OF UNIQUE LEVEL; SELF\column.values : LIST[1:?] OF LEVEL_SPEC_VALUE; WHERE wr1 : QUERY(inst <* SELF\COLUMN.values | NOT RIGHT_VALUES_FOR_LEVEL_SPEC( SELF.levels,inst)) = []; END_ENTITY;
ENTITY sql_mappable_defined_function ABSTRACT SUPERTYPE SUBTYPE OF (DEFINED_FUNCTION); END_ENTITY;
ENTITY multiple_arity_table_expression ABSTRACT SUPERTYPE OF (MULTIPLE_ARITY_CARTESIAN_PRODUCT) SUBTYPE OF (TABLE_EXPRESSION,MULTIPLE_ARITY_GENERIC_EXPRESSION); SELF\multiple_arity_generic_expression.operands : LIST[2:?] OF TABLE_EXPRESSION; END_ENTITY;
ENTITY binary_table_expression ABSTRACT SUPERTYPE OF (ONEOF(SET_TABLE_EXPRESSION,NATURAL_JOIN_EXPRESSION)) SUBTYPE OF (TABLE_EXPRESSION,BINARY_GENERIC_EXPRESSION); SELF\binary_generic_expression.operands : LIST[2:2] OF TABLE_EXPRESSION; END_ENTITY;
ENTITY unary_table_expression ABSTRACT SUPERTYPE OF (PROJECTION_EXPRESSION) SUBTYPE OF (TABLE_EXPRESSION,UNARY_GENERIC_EXPRESSION); SELF\unary_generic_expression.operand : TABLE_EXPRESSION; END_ENTITY;
ENTITY table_identification ABSTRACT SUPERTYPE; WHERE wr1 : SIZEOF(USEDIN(SELF,'ISO13584_G_M_IIM_SCHEMA.TABLE_SPECIFICATION' + '.TABLE_IDENTIFIER')) <= 1; wr2 : SIZEOF(USEDIN(SELF,'ISO13584_G_M_IIM_SCHEMA.TABLE_EXTENSION' + '.TABLE_IDENTIFIER')) <= 1; END_ENTITY;
ENTITY simple_table_expression ABSTRACT SUPERTYPE OF (ONEOF(TABLE_VARIABLE,TABLE_LITERAL)) SUBTYPE OF (TABLE_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY self_class_name_semantics ABSTRACT SUPERTYPE OF (ONEOF(SELF_CLASS_PREFERRED_NAME_SEMANTICS, SELF_CLASS_SHORT_NAME_SEMANTICS, SELF_CLASS_CODE_SEMANTICS, SELF_CLASS_SUPPLIER_CODE_SEMANTICS, SELF_CLASS_VERSION_SEMANTICS)) SUBTYPE OF (SELF_CLASS_VARIABLE_SEMANTICS); WHERE wr1 : SIZEOF(QUERY(v <* SYNTAX_OF(SELF) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.STRING_VARIABLE' IN TYPEOF(v)))) = 0; END_ENTITY;
ENTITY self_property_name_semantics ABSTRACT SUPERTYPE OF (ONEOF(SELF_PROPERTY_PREFERRED_NAME_SEMANTICS, SELF_PROPERTY_SHORT_NAME_SEMANTICS, SELF_PROPERTY_CODE_SEMANTICS, SELF_PROPERTY_VERSION_SEMANTICS, SELF_PROPERTY_CLASS_CODE_SEMANTICS, SELF_PROPERTY_CLASS_VERSION_SEMANTICS, SELF_PROPERTY_CLASS_SUPPLIER_CODE_SEMANTICS)) SUBTYPE OF (SELF_PROPERTY_SEMANTICS); WHERE wr1 : QUERY(v <* SYNTAX_OF(SELF) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.STRING_VARIABLE' IN TYPEOF(v))) = []; END_ENTITY;
ENTITY self_property_semantics ABSTRACT SUPERTYPE OF (ONEOF(SELF_PROPERTY_VALUE_SEMANTICS, SELF_PROPERTY_NAME_SEMANTICS)) SUBTYPE OF (SELF_VARIABLE_SEMANTICS,PROPERTY_SEMANTICS); END_ENTITY;
ENTITY simple_domain ABSTRACT SUPERTYPE OF (ONEOF(TABLE_DEFINED_DOMAIN,TYPE_DEFINED_DOMAIN, SUBCLASS_DEFINED_DOMAIN,CONSTANT_RANGE_DEFINED_DOMAIN, VARIABLE_RANGE_DEFINED_DOMAIN,PREDICATE_DEFINED_DOMAIN ,SIMPLE_FUNCTIONAL_DOMAIN)); INVERSE referenced_by : GUARDED_SIMPLE_DOMAIN FOR domain; END_ENTITY;
ENTITY simple_functional_domain ABSTRACT SUPERTYPE OF (ONEOF(LIBRARY_EXPRESSION_DEFINED_VALUE, TABLE_DEFINED_VALUE,NULL_DEFINED_VALUE)) SUBTYPE OF (SIMPLE_DOMAIN); END_ENTITY;
ENTITY a_posteriori_semantic_relationship ABSTRACT SUPERTYPE OF (A_POSTERIORI_CASE_OF); END_ENTITY;
ENTITY class_bsu_relationship ABSTRACT SUPERTYPE; relating_class : CLASS; related_tokens : SET[1:?] OF CLASS_RELATED_BSU; END_ENTITY;
ENTITY external_file_protocol ABSTRACT SUPERTYPE OF ( (ONEOF (STANDARD_PROTOCOL, NON_STANDARD_PROTOCOL)) ANDOR (ONEOF (DATA_PROTOCOL))); organisation: ORGANIZATION; country: OPTIONAL IDENTIFIER; protocol_name: IDENTIFIER; protocol_version: IDENTIFIER; level: OPTIONAL IDENTIFIER; designation: ITEM_NAMES; base_protocol: OPTIONAL EXTERNAL_FILE_PROTOCOL; WHERE WR1: (NOT (SELF.protocol_name LIKE '* *')) AND (NOT (SELF.protocol_name LIKE '*.*')) AND (NOT (SELF.protocol_name LIKE '*-*')); WR2: NOT (SELF.protocol_version LIKE '* *'); END_ENTITY;
ENTITY view_exchange_protocol_id SUBTYPE OF (DATA_EXCHANGE_SPECIFICATION_ID); referenced_iso10303_ap : OPTIONAL APPLICATION_PROTOCOL_DEFINITION; END_ENTITY;
ENTITY data_exchange_specification_id ABSTRACT SUPERTYPE OF (ONEOF(LIBRARY_IIM_ID,VIEW_EXCHANGE_PROTOCOL_ID)); status : LABEL; name : IDENTIFIER; date : YEAR_NUMBER; application : OPTIONAL IDENTIFIER; level : OPTIONAL IDENTIFIER; external_file_protocols : SET[0:?] OF EXTERNAL_FILE_PROTOCOL; END_ENTITY;
ENTITY class_related_bsu ABSTRACT SUPERTYPE SUBTYPE OF (BASIC_SEMANTIC_UNIT); END_ENTITY;
ENTITY class_related_element ABSTRACT SUPERTYPE OF (ONEOF(TABLE_ELEMENT,DOCUMENT_ELEMENT)) SUBTYPE OF (DICTIONARY_ELEMENT); SELF\dictionary_element.identified_by : CLASS_RELATED_BSU; names : ITEM_NAMES; definition : DEFINITION_TYPE; note : OPTIONAL NOTE_TYPE; remark : OPTIONAL REMARK_TYPE; END_ENTITY;
ENTITY person; id : IDENTIFIER; last_name : OPTIONAL LABEL; first_name : OPTIONAL LABEL; middle_names : OPTIONAL LIST[1:?] OF LABEL; prefix_titles : OPTIONAL LIST[1:?] OF LABEL; suffix_titles : OPTIONAL LIST[1:?] OF LABEL; UNIQUE ur1 : id; WHERE wr1 : EXISTS(last_name) OR EXISTS(first_name); END_ENTITY;
ENTITY a_priori_semantics_relationship ABSTRACT SUPERTYPE OF (ITEM_CLASS_CASE_OF) SUBTYPE OF(CLASS); referenced_classes: SET [1:?] OF CLASS_BSU; referenced_properties: LIST [0:?] OF PROPERTY_BSU; referenced_data_types: SET [0:?] OF DATA_TYPE_BSU; referenced_tables : SET[0:?] OF TABLE_BSU; referenced_documents : SET[0:?] OF DOCUMENT_BSU; WHERE WR1: QUERY ( prop <* referenced_properties | QUERY ( cl <* referenced_classes | NOT VISIBLE_PROPERTIES (cl, [prop]) AND NOT APPLICABLE_PROPERTIES (cl, [prop])) = referenced_classes) = []; WR2: QUERY ( typ <* referenced_data_types | QUERY ( cl <* referenced_classes | NOT VISIBLE_TYPES (cl, [typ]) AND NOT APPLICABLE_TYPES (cl, [typ])) = referenced_classes) = []; WR3: QUERY ( tab <* referenced_tables | QUERY ( cl <* referenced_classes | NOT VISIBLE_TABLES (cl, [tab]) AND NOT APPLICABLE_TABLES (cl, [tab])) = referenced_classes) = []; WR4: QUERY ( doc <* referenced_documents | QUERY ( cl <* referenced_classes | NOT VISIBLE_DOCUMENTS (cl, [doc]) AND NOT APPLICABLE_DOCUMENTS (cl, [doc])) = referenced_classes) = []; END_ENTITY;
ENTITY property_semantics ABSTRACT SUPERTYPE OF (SELF_PROPERTY_SEMANTICS) SUBTYPE OF (VARIABLE_SEMANTICS); the_property : PROPERTY_BSU; its_own_property : OPTIONAL SUB_PROPERTY_PATH; WHERE wr1 : (NOT (EXISTS (SELF.its_own_property))) OR (DATA_TYPE_TYPEOF(SELF.the_property) = []) OR (('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(SELF.the_property)) AND APPLICABLE_PROPERTIES ( DATA_TYPE_CLASS_OF(SELF.the_property)[1], [SELF.its_own_property.the_property])); END_ENTITY;
ENTITY content_item ABSTRACT SUPERTYPE; dictionary_definition : BASIC_SEMANTIC_UNIT; END_ENTITY;
ENTITY model_class_extension ABSTRACT SUPERTYPE OF (ITEM_CLASS_EXTENSION) SUBTYPE OF (CLASS_EXTENSION); selectable_properties : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; required_properties : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; derived_properties : LIST [0:?] OF UNIQUE OPT_OR_MAND_PROPERTY_BSU; new_derived_prop : SET [0:?] OF PROPERTY_BSU; new_mandatory_prop : SET [0:?] OF PROPERTY_BSU; class_extension : SET [0:?] OF DOMAIN_RESTRICTION; derivation : SET [0:?] OF FUNCTIONAL_DOMAIN_RESTRICTION; filters : SET [0:?] OF DOMAIN_RESTRICTION; referenced_external_items : SET [0:?] OF CLASS_EXTENSION_EXTERNAL_ITEM; used_protocols : SET [0:?] OF EXTERNAL_FILE_PROTOCOL; referenced_view_exchange_protocol : LIST [0:?] OF VIEW_EXCHANGE_PROTOCOL_ID; content_version : VERSION_TYPE; content_revision : REVISION_TYPE; WHERE WR1: QUERY ( opt_or_mand <* SELF.selectable_properties |NOT APPLICABLE_PROPERTIES (SELF\CONTENT_ITEM.dictionary_definition\CLASS_BSU, [opt_or_mand.property])) = []; WR2: QUERY ( opt_or_mand <* SELF.derived_properties |NOT APPLICABLE_PROPERTIES (SELF\CONTENT_ITEM.dictionary_definition\CLASS_BSU, [opt_or_mand.property])) = []; WR3: SELECTABLE_PROPERTIES_NOT_DEFINED_TWICE(SELF); WR4: DERIVED_PROPERTIES_NOT_DEFINED_TWICE(SELF); WR5: (NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition\CLASS_BSU)) OR (SIZEOF (SELF.new_derived_prop) = 0) OR (EXISTS_SUPER(SELF.dictionary_definition\CLASS_BSU) AND (QUERY (prop<*SELF.new_derived_prop |NOT (prop IN SELECTABLE_PROPERTIES_LIST( SUPER (SELF.dictionary_definition)[1]))) = [])); WR6: (NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition \CLASS_BSU)) OR (SIZEOF (SELF.new_mandatory_prop) = 0) OR (EXISTS_SUPER(SELF.dictionary_definition\CLASS_BSU) AND (QUERY (prop<*SELF.new_mandatory_prop |NOT (prop IN OPTIONAL_PROPERTIES_LIST( SUPER (SELF.dictionary_definition)[1]))) = [])); WR7: QUERY (dom<* ( SELF.CLASS_EXTENSION + SELF.derivation + SELF.filters) |(QUERY (sem<*dom.defines | NOT ('ISO13584_VARIABLE_SEMANTICS_SCHEMA' +'.SELF_PROPERTY_VALUE_SEMANTICS' IN TYPEOF(sem))) <> []) OR (QUERY (sem<* dom.assumes | NOT ('ISO13584_VARIABLE_SEMANTICS_SCHEMA' +'.SELF_PROPERTY_VALUE_SEMANTICS' IN TYPEOF(sem))) <> [])) = []; WR8: QUERY (dom<*( SELF.CLASS_EXTENSION + SELF.derivation) |QUERY (sem<* dom.defines | EXISTS (sem.its_own_property)) <> []) = []; WR9: NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition\CLASS_BSU) OR (QUERY (dom<* ( SELF.CLASS_EXTENSION + SELF.derivation + SELF.filters) |(QUERY (sem<*dom.assumes | NOT (sem\PROPERTY_SEMANTICS.the_property IN PROVIDED_PROPERTIES_LIST ( SELF.dictionary_definition))) <> [])) = []); WR10: NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition) OR (QUERY (dom<* (SELF.CLASS_EXTENSION + SELF.filters) |(QUERY (sem<*dom.defines | NOT (sem\PROPERTY_SEMANTICS.the_property IN SELECTABLE_PROPERTIES_LIST ( SELF.dictionary_definition))) <> [])) = []); WR11: NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition\CLASS_BSU) OR (QUERY (dom<* ( SELF.CLASS_EXTENSION + SELF.derivation + SELF.filters) |(QUERY (tab<*dom.base_tables | NOT APPLICABLE_TABLES ( SELF.dictionary_definition, [tab])) <> [])) = []); WR12: ACYCLIC_CLASS_EXTENSION_DEFINITION( SELF.dictionary_definition\CLASS_BSU); WR13: QUERY (prop<*SELF.selectable_properties |SIZEOF (QUERY (choi<*SELF.CLASS_EXTENSION |(prop.property IN GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS( choi\DOMAIN_RESTRICTION.defines))))<> 1) = []; WR14: QUERY (prop<*SELF.derived_properties |SIZEOF (QUERY (f<*SELF.derivation |(prop.property IN GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS( f.defines)))) <> 1) = []; WR15: QUERY (prop<*SELF.new_derived_prop |SIZEOF (QUERY (f<*SELF.derivation |prop IN GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS( f.defines))) <> 1) = []; WR16: NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition\CLASS_BSU) OR (QUERY (f<*SELF.derivation |(QUERY (prop<*f.defines |NOT (GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS([prop])[1] IN DERIVED_PROPERTIES_LIST (SELF.dictionary_definition\CLASS_BSU))) <> [])) = []); WR17: NOT ALL_CLASS_DESCRIPTIONS_REACHABLE( SELF.dictionary_definition\CLASS_BSU) OR (QUERY (prop<* DERIVED_PROPERTIES_LIST ( SELF.dictionary_definition) |SIZEOF (QUERY (f<*DEFINED_DERIVATION_FUNCTION( SELF.dictionary_definition\CLASS_BSU) |QUERY (sem<* f.defines |sem\PROPERTY_SEMANTICS.the_property = prop) <>[])) <> 1 ) = []); WR18: QUERY (item<*SELF.referenced_external_items |NOT (item\DICTIONARY_EXTERNAL_ITEM.used_protocol IN SELF.used_protocols)) = []; WR19: QUERY (filt<*filters |NOT( EXISTS(filt.constraint_description))) = []; WR20: QUERY (dom_1 <* CLASS_EXTENSION | NOT ( QUERY ( dom_2 <* dom_1.domains | 'ISO13584_DOMAIN_RESOURCE_SCHEMA.PREDICATE_DEFINED_DOMAIN' IN TYPEOF (dom_2.domain)) = [] )) = []; END_ENTITY;
FUNCTION selectable_properties_not_defined_twice ( class_ext : MODEL_CLASS_EXTENSION):LOGICAL; IF NOT EXISTS_SUPER(class_ext.dictionary_definition\CLASS_BSU) THEN RETURN (UNKNOWN) ; ELSE RETURN ( ARE_PROPERTIES_NOT_IN( class_ext.selectable_properties, PROVIDED_PROPERTIES_LIST( SUPER(class_ext.dictionary_definition)[1]))); END_IF; END_FUNCTION; -- selectable_properties_not_defined_twice
FUNCTION derived_properties_not_defined_twice ( class_ext: MODEL_CLASS_EXTENSION):LOGICAL; IF NOT EXISTS_SUPER(class_ext.dictionary_definition\CLASS_BSU) THEN RETURN (UNKNOWN) ; ELSE RETURN ( ARE_PROPERTIES_NOT_IN ( class_ext.derived_properties, PROVIDED_PROPERTIES_LIST( SUPER(class_ext.dictionary_definition)[1]))); END_IF; END_FUNCTION;
ENTITY external_item ABSTRACT SUPERTYPE OF (ONEOF(DICTIONARY_EXTERNAL_ITEM, CLASS_EXTENSION_EXTERNAL_ITEM)); used_protocol : EXTERNAL_FILE_PROTOCOL; content : EXTERNAL_CONTENT; END_ENTITY;
ENTITY class_bsu_related_content ABSTRACT SUPERTYPE OF (DOCUMENT_CONTENT) SUBTYPE OF (DICTIONARY_EXTERNAL_ITEM); SELF\content_item.dictionary_definition : CLASS_RELATED_BSU; END_ENTITY;
ENTITY data_protocol ABSTRACT SUPERTYPE OF (ONEOF(STANDARD_DATA_PROTOCOL, NON_STANDARD_DATA_PROTOCOL)) SUBTYPE OF (EXTERNAL_FILE_PROTOCOL); END_ENTITY;
ENTITY dialogue_resource ABSTRACT SUPERTYPE OF (ONEOF(MESSAGE,ILLUSTRATION)) SUBTYPE OF (CLASS_EXTENSION_EXTERNAL_ITEM); SELF\external_item.used_protocol : DATA_PROTOCOL; END_ENTITY;
ENTITY external_content ABSTRACT SUPERTYPE OF (ONEOF(TRANSLATED_EXTERNAL_CONTENT, NOT_TRANSLATED_EXTERNAL_CONTENT, NOT_TRANSLATABLE_EXTERNAL_CONTENT)); consists_of : SET[1:?] OF LANGUAGE_SPECIFIC_CONTENT; INVERSE content_of : EXTERNAL_ITEM FOR content; END_ENTITY;
ENTITY non_standard_protocol ABSTRACT SUPERTYPE OF (NON_STANDARD_DATA_PROTOCOL) SUBTYPE OF (EXTERNAL_FILE_PROTOCOL); END_ENTITY;
ENTITY standard_protocol ABSTRACT SUPERTYPE OF (STANDARD_DATA_PROTOCOL) SUBTYPE OF (EXTERNAL_FILE_PROTOCOL); END_ENTITY;
ENTITY direction SUBTYPE OF (GEOMETRIC_REPRESENTATION_ITEM); direction_ratios : LIST[2:3] OF REAL; WHERE wr1 : SIZEOF(QUERY(tmp <* direction_ratios | tmp <> 0.0)) > 0; END_ENTITY;
ENTITY geometric_representation_item SUPERTYPE OF (ONEOF(POINT,DIRECTION,VECTOR,PLACEMENT)) SUBTYPE OF (REPRESENTATION_ITEM); DERIVE dim : DIMENSION_COUNT := DIMENSION_OF(SELF); WHERE wr1 : SIZEOF(QUERY(using_rep <* USING_REPRESENTATIONS(SELF) | NOT ( 'ISO13584_G_M_IIM_SCHEMA.GEOMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF(using_rep.context_of_items)))) = 0; END_ENTITY;
ENTITY cartesian_point SUBTYPE OF (POINT); coordinates : LIST[1:3] OF LENGTH_MEASURE; END_ENTITY;
ENTITY simple_generic_expression ABSTRACT SUPERTYPE OF (ONEOF(GENERIC_LITERAL,GENERIC_VARIABLE)) SUBTYPE OF (GENERIC_EXPRESSION); END_ENTITY;
ENTITY unary_numeric_expression ABSTRACT SUPERTYPE OF (UNARY_FUNCTION_CALL) SUBTYPE OF (NUMERIC_EXPRESSION,UNARY_GENERIC_EXPRESSION); SELF\unary_generic_expression.operand : NUMERIC_EXPRESSION; END_ENTITY;
ENTITY expression ABSTRACT SUPERTYPE OF (ONEOF(NUMERIC_EXPRESSION,BOOLEAN_EXPRESSION, STRING_EXPRESSION)) SUBTYPE OF (GENERIC_EXPRESSION); END_ENTITY;
ENTITY simple_numeric_expression ABSTRACT SUPERTYPE OF (ONEOF(LITERAL_NUMBER,NUMERIC_VARIABLE)) SUBTYPE OF (NUMERIC_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY class_and_property_elements ABSTRACT SUPERTYPE OF (ONEOF(PROPERTY_DET,CLASS)) SUBTYPE OF (DICTIONARY_ELEMENT); names : ITEM_NAMES; definition : DEFINITION_TYPE; source_doc_of_definition : OPTIONAL DOCUMENT; note : OPTIONAL NOTE_TYPE; remark : OPTIONAL REMARK_TYPE; END_ENTITY;
ENTITY supplier_related_bsu ABSTRACT SUPERTYPE SUBTYPE OF (BASIC_SEMANTIC_UNIT); END_ENTITY;
ENTITY defined_function ABSTRACT SUPERTYPE OF (BOOLEAN_DEFINED_FUNCTION ANDOR SQL_MAPPABLE_DEFINED_FUNCTION); END_ENTITY;
ENTITY simple_level_spec_expression ABSTRACT SUPERTYPE OF (ONEOF(LEVEL_SPEC_VARIABLE,LEVEL_SPEC_LITERAL)) SUBTYPE OF (LEVEL_SPEC_EXPRESSION,SIMPLE_GENERIC_EXPRESSION); END_ENTITY;
ENTITY self_class_variable_semantics ABSTRACT SUPERTYPE OF (SELF_CLASS_NAME_SEMANTICS) SUBTYPE OF (SELF_VARIABLE_SEMANTICS); END_ENTITY;
ENTITY self_variable_semantics ABSTRACT SUPERTYPE OF (ONEOF(SELF_PROPERTY_SEMANTICS, SELF_CLASS_VARIABLE_SEMANTICS)) SUBTYPE OF (VARIABLE_SEMANTICS); END_ENTITY;
ENTITY application_protocol_definition; status : LABEL; application_interpreted_model_schema_name : LABEL; application_protocol_year : YEAR_NUMBER; application : APPLICATION_CONTEXT; END_ENTITY;
ENTITY class_extension ABSTRACT SUPERTYPE OF (ONEOF(MODEL_CLASS_EXTENSION)) SUBTYPE OF (CONTENT_ITEM); SELF\content_item.dictionary_definition: CLASS_BSU; WHERE WR1:NO_EXTENSION_FOR_SUPERCLASS (SELF); END_ENTITY;
ENTITY class_extension_external_item ABSTRACT SUPERTYPE OF (DIALOGUE_RESOURCE) SUBTYPE OF (EXTERNAL_ITEM); code : EXTERNAL_ITEM_CODE_TYPE; INVERSE belongs_to : MODEL_CLASS_EXTENSION FOR referenced_external_items; UNIQUE ur1 : code,belongs_to; END_ENTITY;
ENTITY dictionary_external_item ABSTRACT SUPERTYPE OF (CLASS_BSU_RELATED_CONTENT) SUBTYPE OF (CONTENT_ITEM,EXTERNAL_ITEM); revision : REVISION_TYPE; END_ENTITY;
ENTITY vector SUBTYPE OF (GEOMETRIC_REPRESENTATION_ITEM); orientation : DIRECTION; magnitude : LENGTH_MEASURE; WHERE wr1 : magnitude >= 0.0; END_ENTITY;
ENTITY point SUPERTYPE OF (CARTESIAN_POINT) SUBTYPE OF (GEOMETRIC_REPRESENTATION_ITEM); END_ENTITY;
ENTITY level_type SUBTYPE OF (COMPLEX_TYPE); levels : LIST[1:4] OF UNIQUE LEVEL; value_type : SIMPLE_TYPE; WHERE wr1 : 'ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN TYPEOF(VALUE_TYPE); END_ENTITY;
ENTITY application_context; application : TEXT; INVERSE context_elements : SET[1:?] OF APPLICATION_CONTEXT_ELEMENT FOR frame_of_reference; END_ENTITY;
ENTITY application_context_element; name : LABEL; frame_of_reference : APPLICATION_CONTEXT; END_ENTITY;
FUNCTION is_int_expr(arg : NUMERIC_EXPRESSION) : BOOLEAN; LOCAL i : INTEGER; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.INT_LITERAL' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_LITERAL' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.ABS_FUNCTION' IN TYPEOF(arg) THEN RETURN (IS_INT_EXPR(arg\UNARY_NUMERIC_EXPRESSION.operand)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MINUS_FUNCTION' IN TYPEOF(arg) THEN RETURN (IS_INT_EXPR(arg\UNARY_NUMERIC_EXPRESSION.operand)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.SIN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COS_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.TAN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ASIN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ACOS_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ATAN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.EXP_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG2_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG10_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.PLUS_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MULT_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MINIMUM_FUNCTION' IN TYPEOF(arg)) THEN REPEAT i := 1 TO SIZEOF(arg\MULTIPLE_ARITY_NUMERIC_EXPRESSION.operands); IF NOT IS_INT_EXPR(arg\MULTIPLE_ARITY_NUMERIC_EXPRESSION.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.POWER_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_INT_EXPR(arg\BINARY_NUMERIC_EXPRESSION.operands[1]) AND IS_INT_EXPR(arg\BINARY_NUMERIC_EXPRESSION.operands[2])); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.DIV_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MOD_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SLASH_EXPRESSION' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LENGTH_FUNCTION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.VALUE_FUNCTION' IN TYPEOF(arg) THEN IF 'ISO13584_G_M_IIM_SCHEMA.INT_VALUE_FUNCTION' IN TYPEOF(arg) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.INTEGER_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.STRING_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; RETURN (FALSE); END_FUNCTION;
-- is_int_expr FUNCTION compute_known_visible_properties(cl : CLASS_BSU) : SET OF PROPERTY_BSU ; LOCAL s : SET OF PROPERTY_BSU := []; END_LOCAL; s := s + USEDIN(cl,'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU.NAME_SCOPE'); IF SIZEOF(cl.definition) = 0 THEN RETURN (s); ELSE IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN s := s + COMPUTE_KNOWN_VISIBLE_PROPERTIES(cl.definition[1]\CLASS. its_superclass); END_IF; RETURN (s); END_IF; END_FUNCTION;
FUNCTION compute_known_visible_data_types(cl : CLASS_BSU) : SET OF DATA_TYPE_BSU; LOCAL s : SET OF DATA_TYPE_BSU := []; END_LOCAL; s := s + USEDIN(cl,'ISO13584_G_M_IIM_SCHEMA.DATA_TYPE_BSU.NAME_SCOPE'); IF SIZEOF(cl.definition) = 0 THEN RETURN (s); ELSE IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN s := s + COMPUTE_KNOWN_VISIBLE_DATA_TYPES(cl.definition[1]\CLASS. its_superclass); END_IF; RETURN (s); END_IF; END_FUNCTION;
FUNCTION definition_available_implies ( BSU: BASIC_SEMANTIC_UNIT; expression: LOGICAL): LOGICAL; RETURN (NOT (SIZEOF(BSU.definition) = 1) OR expression); END_FUNCTION; -- definition_available_implies
FUNCTION is_subclass(sub,super : CLASS) : LOGICAL; IF (NOT EXISTS(sub)) OR (NOT EXISTS(super)) THEN RETURN (UNKNOWN); END_IF; IF NOT EXISTS(sub.its_superclass) THEN RETURN (FALSE); END_IF; IF SIZEOF(sub.its_superclass.definition) = 1 THEN IF (sub.its_superclass.definition[1]\CLASS = super) THEN RETURN (TRUE); ELSE RETURN (IS_SUBCLASS(sub.its_superclass.definition[1]\CLASS,super)); END_IF; ELSE RETURN (UNKNOWN); END_IF; END_FUNCTION;
-- is_subclass FUNCTION all_class_descriptions_reachable (cl:CLASS_BSU): BOOLEAN; IF NOT EXISTS(cl) THEN RETURN(FALSE); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(FALSE); END_IF; IF NOT (EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (TRUE); ELSE RETURN(ALL_CLASS_DESCRIPTIONS_REACHABLE( cl.definition[1]\CLASS.its_superclass)); END_IF; END_FUNCTION; -- all_class_descriptions_reachable
FUNCTION at_most_two_synonyms_per_language(languages : PRESENT_TRANSLATIONS; synonymous_names : SET OF SYN_NAME_TYPE) : BOOLEAN; IF EXISTS(languages) THEN REPEAT i := 1 TO SIZEOF(languages.language_codes); IF SIZEOF(QUERY(s <* synonymous_names | s.language = languages. language_codes[i])) > 2 THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); ELSE RETURN (SIZEOF(synonymous_names) <= 2); END_IF; END_FUNCTION;
-- at_most_two_synonyms_per_language FUNCTION codes_are_unique(values : LIST OF DIC_VALUE) : BOOLEAN; LOCAL l : SET OF STRING := []; END_LOCAL; REPEAT i := 1 TO SIZEOF(values); l := l + values[i].value_code; END_REPEAT; RETURN (SIZEOF(values) = SIZEOF(l)); END_FUNCTION;
-- codes_are_unique FUNCTION compatible_type_and_value( dom: PROPERTY_OR_DATA_TYPE_BSU; val: PRIMITIVE_VALUE ): LOGICAL; LOCAL temp: SET[0:1] OF CLASS_BSU; END_LOCAL; IF DATA_TYPE_TYPEOF(dom)= [] THEN (* the final domain of the type is not available *) RETURN(UNKNOWN); END_IF; (* The following express statements deal with simple types *) IF 'ISO13584_G_M_IIM_SCHEMA.INTEGER_VALUE' IN TYPEOF(val) THEN RETURN ( ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF (dom)) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF (dom)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF (dom))) ); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_VALUE' IN TYPEOF(val) THEN RETURN ( ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF (dom)) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF (dom)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF (dom))) ); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_VALUE' IN TYPEOF(val) THEN RETURN ( 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_TYPE' IN DATA_TYPE_TYPEOF (dom) ); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.STRING_VALUE' IN TYPEOF(val) THEN RETURN ( 'ISO13584_G_M_IIM_SCHEMA.STRING_TYPE' IN DATA_TYPE_TYPEOF (dom) ); END_IF; (* The following express statements deal with complex types *) IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_VALUE' IN TYPEOF(val) THEN IF 'ISO13584_G_M_IIM_SCHEMA'+ '.UNCONTROLLED_ENTITY_INSTANCE_VALUE' IN TYPEOF(val) THEN RETURN(UNKNOWN); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF (dom)) AND (SIZEOF (DATA_TYPE_TYPE_NAME(dom)) <> 0) AND (DATA_TYPE_TYPE_NAME(dom) <= TYPEOF(val)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.DIC_CLASS_INSTANCE' IN TYPEOF(val) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF (dom)) AND (SIZEOF (DATA_TYPE_CLASS_OF(dom)) <> 0) THEN temp := DATA_TYPE_CLASS_OF(dom); RETURN (COMPATIBLE_CLASS_AND_CLASS(temp[1], val\DIC_CLASS_INSTANCE.class_def)); ELSE RETURN(FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_VALUE' IN TYPEOF(val) THEN IF ('ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN DATA_TYPE_TYPEOF (dom)) THEN RETURN (COMPATIBLE_LEVEL_TYPE_AND_INSTANCE ( DATA_TYPE_LEVEL_SPEC(dom), DATA_TYPE_LEVEL_VALUE_TYPEOF(dom), val)); ELSE RETURN(FALSE); END_IF; END_IF; RETURN (FALSE); END_FUNCTION; -- compatible_type_and_value
FUNCTION collects_referenced_library_expressions(p_a : AGGREGATE OF PROPERTY_ASSIGNMENT) : LIST[1:?] OF LIBRARY_EXPRESSION; LOCAL assign_exp : LIST[0:?] OF LIBRARY_EXPRESSION; i : INTEGER; END_LOCAL; assign_exp := []; REPEAT i := 1 TO HIBOUND(p_a); IF EXISTS(p_a[i].its_value) THEN assign_exp := assign_exp + p_a[i].its_value; END_IF; END_REPEAT; RETURN (assign_exp); END_FUNCTION;
-- collects_referenced_library_expressions FUNCTION collects_assigned_properties(p_a : AGGREGATE OF PROPERTY_ASSIGNMENT) : LIST OF PROPERTY_BSU; LOCAL assign_prop : LIST OF PROPERTY_BSU; --assigned properties of the --multiple_arity_class_instance_constructor i : INTEGER; END_LOCAL; assign_prop := []; REPEAT i := 1 TO HIBOUND(p_a); assign_prop := assign_prop + p_a[i].prop_def; END_REPEAT; RETURN (assign_prop); END_FUNCTION;
-- collects_assigned_properties FUNCTION compatible_class_and_class(cl1 : CLASS_BSU;cl2 : CLASS_BSU) : LOGICAL ; IF (cl1.defined_by\BASIC_SEMANTIC_UNIT.code = cl2.defined_by\ BASIC_SEMANTIC_UNIT.code) AND (cl1\BASIC_SEMANTIC_UNIT.code = cl2\ BASIC_SEMANTIC_UNIT.code) AND (cl1\BASIC_SEMANTIC_UNIT.version >= cl2\ BASIC_SEMANTIC_UNIT.version) THEN RETURN (TRUE); END_IF; IF (SIZEOF(cl2\BASIC_SEMANTIC_UNIT.definition) = 0) THEN RETURN (UNKNOWN); END_IF; IF (SIZEOF(cl2\BASIC_SEMANTIC_UNIT.definition) = 1) AND (NOT EXISTS(cl2\ BASIC_SEMANTIC_UNIT.definition[1]\CLASS.its_superclass)) THEN RETURN (FALSE); END_IF; RETURN (COMPATIBLE_CLASS_AND_CLASS(cl1,cl2\BASIC_SEMANTIC_UNIT.definition[1]\ CLASS.its_superclass)); END_FUNCTION;
-- compatible_class_and_class FUNCTION compatible_level_type_and_instance(levels : LIST[1:4] OF UNIQUE LEVEL ;value_typeof : SET OF STRING;val : LEVEL_SPEC_VALUE) : BOOLEAN; LOCAL c_val : BOOLEAN; END_LOCAL; c_val := FALSE; IF ('ISO13584_G_M_IIM_SCHEMA.INT_LEVEL_SPEC_VALUE' IN TYPEOF(val)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN value_typeof) THEN c_val := TRUE; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.REAL_LEVEL_SPEC_VALUE' IN TYPEOF(val)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN value_typeof) THEN c_val := TRUE; END_IF; RETURN (c_val AND (RIGHT_VALUES_FOR_LEVEL_SPEC(levels,val))); END_FUNCTION;
-- compatible_level_type_and_instance FUNCTION compatible_type_and_library_expression(dom : PROPERTY_OR_DATA_TYPE_BSU ;expr : LIBRARY_EXPRESSION) : LOGICAL; LOCAL temp : SET[0:1] OF CLASS_BSU; END_LOCAL; IF DATA_TYPE_TYPEOF(dom) = [] THEN RETURN (UNKNOWN); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_EXPRESSION' IN TYPEOF(expr) THEN IF ('ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN DATA_TYPE_TYPEOF(dom)) AND (LIST_TO_SET(DATA_TYPE_LEVEL_SPEC(dom)) = LIST_TO_SET(expr\ LEVEL_SPEC_EXPRESSION.levels)) AND (TYPEOF(expr\LEVEL_SPEC_EXPRESSION. VALUE_TYPE) <= DATA_TYPE_LEVEL_VALUE_TYPEOF(dom)) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_EXPRESSION' IN TYPEOF(expr) THEN IF ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF (dom)) AND (DATA_TYPE_TYPE_NAME(dom) <= expr\ENTITY_INSTANCE_EXPRESSION. type_name) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_EXPRESSION' IN TYPEOF(expr) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF( dom)) AND (SIZEOF(DATA_TYPE_CLASS_OF(dom)) = 1) THEN temp := DATA_TYPE_CLASS_OF(dom); RETURN (COMPATIBLE_CLASS_AND_CLASS(temp[1],expr.expr_type)); ELSE RETURN (FALSE); END_IF; END_IF; RETURN (COMPATIBLE_SIMPLE_TYPE_AND_EXPRESSION(dom,expr\EXPRESSION)); END_FUNCTION;
-- compatible_type_and_library_expression FUNCTION compatible_variable_semantics_and_expression ( sem: VARIABLE_SEMANTICS; expr: EXPRESSION ): LOGICAL; LOCAL va: SET OF GENERIC_VARIABLE; i: INTEGER; END_LOCAL; va := SYNTAX_OF (sem); IF SIZEOF (va) = 0 THEN RETURN (UNKNOWN); ELSE REPEAT i := LOBOUND (va) TO HIBOUND (va); IF ( NOT COMPATIBLE_VARIABLE_AND_EXPRESSION (va[i], expr)) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; END_FUNCTION; -- compatible_variable_semantics_and_expression
FUNCTION is_SQL_mappable_table_expression (arg: TABLE_EXPRESSION ) : LOGICAL; LOCAL i: INTEGER; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.SIMPLE_TABLE_EXPRESSION' IN TYPEOF (arg) THEN IF ('ISO13584_G_M_IIM_SCHEMA.RDB_TABLE_VARIABLE' IN TYPEOF(arg)) THEN RETURN (TRUE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.TABLE_LITERAL' IN TYPEOF(arg)) THEN IF (SIZEOF ( USEDIN (arg\TABLE_LITERAL.the_value, 'ISO13584_G_M_IIM_SCHEMA.TABLE_SPECIFICATION' + '.TABLE_IDENTIFIER')) = 1) THEN RETURN (('ISO13584_G_M_IIM_SCHEMA' +'.RDB_TABLE_SPECIFICATION') IN TYPEOF (USEDIN (arg\TABLE_LITERAL.the_value, 'ISO13584_G_M_IIM_SCHEMA' +'.TABLE_SPECIFICATION.TABLE_IDENTIFIER')[1])); ELSE RETURN (UNKNOWN); END_IF; END_IF; RETURN (FALSE); -- table_variable that is not -- an RDB_table_variable END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.UNARY_TABLE_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_SQL_MAPPABLE_TABLE_EXPRESSION( arg\UNARY_TABLE_EXPRESSION.operand)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.SELECT_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_SQL_MAPPABLE_TABLE_EXPRESSION( arg\SELECT_EXPRESSION.from_table\TABLE_EXPRESSION) AND IS_SQL_MAPPABLE( arg\SELECT_EXPRESSION.condition\BOOLEAN_EXPRESSION)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.BINARY_TABLE_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_SQL_MAPPABLE_TABLE_EXPRESSION( arg\BINARY_TABLE_EXPRESSION.operands[1]) AND IS_SQL_MAPPABLE_TABLE_EXPRESSION( arg\BINARY_TABLE_EXPRESSION.operands[2])); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_TABLE_EXPRESSION' IN TYPEOF(arg)) THEN REPEAT i :=1 TO SIZEOF (arg\MULTIPLE_ARITY_TABLE_EXPRESSION.operands); IF NOT IS_SQL_MAPPABLE_TABLE_EXPRESSION (arg\MULTIPLE_ARITY_TABLE_EXPRESSION.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; RETURN(UNKNOWN); END_FUNCTION; -- is_SQL_mappable_table_expression
FUNCTION and_then(op1, op2 : LOGICAL) : LOGICAL; IF NOT op1 THEN RETURN (FALSE); ELSE RETURN (op1 AND op2); END_IF; END_FUNCTION; -- and_then
FUNCTION or_else(op1, op2 : LOGICAL) : LOGICAL; IF op1 THEN RETURN (TRUE); ELSE RETURN (op1 OR op2); END_IF; END_FUNCTION; -- or_else
FUNCTION is_sql_mappable(arg : EXPRESSION) : BOOLEAN; LOCAL i : INTEGER; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.SIMPLE_NUMERIC_EXPRESSION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SQL_MAPPABLE_DEFINED_FUNCTION' IN TYPEOF(arg ) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MINUS_FUNCTION' IN TYPEOF(arg) THEN RETURN (IS_SQL_MAPPABLE(arg\UNARY_NUMERIC_EXPRESSION.operand)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.ABS_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.SIN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COS_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.TAN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ASIN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ACOS_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.ATAN_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.EXP_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG2_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LOG10_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.VALUE_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LENGTH_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.PLUS_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MULT_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MINIMUM_FUNCTION' IN TYPEOF(arg)) THEN REPEAT i := 1 TO SIZEOF(arg\MULTIPLE_ARITY_NUMERIC_EXPRESSION.operands); IF NOT IS_SQL_MAPPABLE(arg\MULTIPLE_ARITY_NUMERIC_EXPRESSION.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.SLASH_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_SQL_MAPPABLE(arg\BINARY_NUMERIC_EXPRESSION.operands[1]) AND IS_SQL_MAPPABLE(arg\BINARY_NUMERIC_EXPRESSION.operands[2])); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.DIV_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.MOD_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.POWER_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SIMPLE_BOOLEAN_EXPRESSION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NOT_EXPRESSION' IN TYPEOF(arg) THEN RETURN (IS_SQL_MAPPABLE(arg\UNARY_GENERIC_EXPRESSION.operand)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.ODD_FUNCTION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.XOR_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.AND_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.OR_EXPRESSION' IN TYPEOF(arg)) THEN REPEAT i := 1 TO SIZEOF(arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.operands); IF NOT IS_SQL_MAPPABLE(arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.EQUALS_EXPRESSION' IN TYPEOF(arg) THEN RETURN (IS_SQL_MAPPABLE(arg\BINARY_GENERIC_EXPRESSION.operands[1]) AND IS_SQL_MAPPABLE(arg\BINARY_GENERIC_EXPRESSION.operands[2])); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.COMPARISON_EQUAL' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COMPARISON_GREATER' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COMPARISON_GREATER_EQUAL' IN TYPEOF(arg)) OR ('ISO13584_G_M_IIM_SCHEMA.COMPARISON_LESS' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COMPARISON_LESS_EQUAL' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.COMPARISON_NOT_EQUAL' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.LIKE_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (IS_SQL_MAPPABLE(arg\COMPARISON_EXPRESSION.operands[1]) AND IS_SQL_MAPPABLE(arg\COMPARISON_EXPRESSION.operands[2])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.INTERVAL_EXPRESSION' IN TYPEOF(arg) THEN RETURN (IS_SQL_MAPPABLE(arg\INTERVAL_EXPRESSION.interval_low) AND IS_SQL_MAPPABLE(arg\INTERVAL_EXPRESSION.interval_high) AND IS_SQL_MAPPABLE (arg\INTERVAL_EXPRESSION.interval_item)); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_DEFINED_FUNCTION' IN TYPEOF(arg)) OR ('ISO13584_G_M_IIM_SCHEMA.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg) ) OR ('ISO13584_G_M_IIM_SCHEMA.STRING_DEFINED_FUNCTION' IN TYPEOF(arg )) THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SIMPLE_STRING_EXPRESSION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.INDEX_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.SUBSTRING_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.CONCAT_EXPRESSION' IN TYPEOF(arg)) OR ( 'ISO13584_G_M_IIM_SCHEMA.FORMAT_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; RETURN (FALSE); END_FUNCTION;
-- is_SQL_mappable FUNCTION compatible_list_variable_semantics_and_expressions(sem : LIST[0:?] OF VARIABLE_SEMANTICS ;exprs : LIST[0:?] OF EXPRESSION) : LOGICAL; LOCAL i : INTEGER; res : LOGICAL; END_LOCAL; IF SIZEOF(sem) <> SIZEOF(exprs) THEN RETURN (FALSE); END_IF; res := TRUE; REPEAT i := LOBOUND(sem) TO HIBOUND(sem); res := res AND COMPATIBLE_VARIABLE_SEMANTICS_AND_EXPRESSION(sem[i],exprs[i]) ; END_REPEAT; RETURN (res); END_FUNCTION;
-- compatible_list_variable_semantics_and_expressions FUNCTION used_variables(arg : GENERIC_EXPRESSION) : SET OF GENERIC_VARIABLE; LOCAL result : SET OF GENERIC_VARIABLE := []; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.GENERIC_VARIABLE' IN TYPEOF(arg) THEN RETURN ([arg]); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.UNARY_GENERIC_EXPRESSION' IN TYPEOF(arg) THEN RETURN (USED_VARIABLES(arg\UNARY_GENERIC_EXPRESSION.operand)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BINARY_GENERIC_EXPRESSION' IN TYPEOF(arg) THEN RETURN (USED_VARIABLES(arg\BINARY_GENERIC_EXPRESSION.operands[1]) + USED_VARIABLES(arg\BINARY_GENERIC_EXPRESSION.operands[2])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_GENERIC_EXPRESSION' IN TYPEOF (arg) THEN REPEAT i := 1 TO SIZEOF(arg\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands); result := result + USED_VARIABLES(arg\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[i]); END_REPEAT; RETURN (result); END_IF; RETURN ([]); -- in this case the subtype shall not contain -- any variable (see IP1 in generic_expression) END_FUNCTION;
-- used_variables FUNCTION syntax_of (sem: VARIABLE_SEMANTICS ): SET OF GENERIC_VARIABLE; LOCAL env : BAG OF ENVIRONMENT; vars : SET OF GENERIC_VARIABLE; i : INTEGER; END_LOCAL; env := USEDIN ( sem, 'ISO13584_G_M_IIM_SCHEMA.ENVIRONMENT.SEMANTICS'); vars := []; REPEAT i := LOINDEX (env) TO HIINDEX (env); vars := vars + env[i].syntactic_representation; END_REPEAT; RETURN (vars); END_FUNCTION; -- syntax_of
FUNCTION compatible_list_variable_semantics_and_columns(sem : LIST[0:?] OF VARIABLE_SEMANTICS;col : LIST[0:?] OF COLUMN ) : LOGICAL; LOCAL i : INTEGER; res : LOGICAL; END_LOCAL; IF SIZEOF(sem) <> SIZEOF(col) THEN RETURN (FALSE); END_IF; res := TRUE; REPEAT i := LOBOUND(col) TO HIBOUND(col); res := res AND COMPATIBLE_COLUMN_AND_VARIABLE_SEMANTICS(col[i],sem[i]); END_REPEAT; RETURN (res); END_FUNCTION;
-- compatible_list_variable_semantics_and_columns FUNCTION bsu_of_property_semantics(v : PROPERTY_SEMANTICS_OR_PATH) : PROPERTY_BSU; LOCAL prop : PROPERTY_BSU; END_LOCAL; prop := v.the_property; IF EXISTS(v.its_own_property) THEN RETURN (BSU_OF_PROPERTY_SEMANTICS(v.its_own_property)); ELSE RETURN (prop); END_IF; END_FUNCTION;
-- BSU_of_property_semantics FUNCTION collects_variables(v_sem : AGGREGATE OF VARIABLE_SEMANTICS) : SET OF GENERIC_VARIABLE; LOCAL l : SET OF GENERIC_VARIABLE := []; END_LOCAL; REPEAT i := 1 TO SIZEOF(v_sem); l := l + SYNTAX_OF(v_sem[i]); END_REPEAT; RETURN (l); END_FUNCTION;
-- collects_variables FUNCTION used_tables_in_domain(arg : DOMAIN_RESTRICTION) : SET OF TABLE_IDENTIFICATION; LOCAL result : SET OF TABLE_IDENTIFICATION := []; END_LOCAL; REPEAT i := 1 TO SIZEOF(arg.domains); IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF(arg.domains[i ].guard) THEN result := result + USED_TABLE_LITERALS(arg.domains[i].guard\BOOLEAN_EXPRESSION); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_DEFINED_DOMAIN' IN TYPEOF(arg.domains [i].domain) THEN result := result + USED_TABLE_LITERALS(arg.domains[i].domain\ TABLE_DEFINED_DOMAIN.from_table); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PREDICATE_DEFINED_DOMAIN' IN TYPEOF(arg. domains[i].domain) THEN result := result + USED_TABLE_LITERALS(arg.domains[i].domain\ PREDICATE_DEFINED_DOMAIN.constraint); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LIBRARY_EXPRESSION_DEFINED_VALUE' IN TYPEOF(arg.domains[i].domain) THEN result := result + USED_TABLE_LITERALS(arg.domains[i].domain\ LIBRARY_EXPRESSION_DEFINED_VALUE.its_value); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_DEFINED_VALUE' IN TYPEOF(arg.domains[ i].domain) THEN result := result + USED_TABLE_LITERALS(arg.domains[i].domain\ TABLE_DEFINED_VALUE.from_table); END_IF; END_REPEAT; RETURN (result); END_FUNCTION;
-- used_tables_in_domain FUNCTION compatible_variable_and_library_expression(va : LIBRARY_VARIABLE;expr : LIBRARY_EXPRESSION) : LOGICAL; IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_EXPRESSION' IN TYPEOF(expr) THEN IF (('ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_VARIABLE' IN TYPEOF(va)) AND ((LIST_TO_SET(va\LEVEL_SPEC_EXPRESSION.levels)) = LIST_TO_SET(expr\ LEVEL_SPEC_EXPRESSION.levels)) AND (TYPEOF(va\LEVEL_SPEC_EXPRESSION. VALUE_TYPE) <= TYPEOF(expr\LEVEL_SPEC_EXPRESSION.VALUE_TYPE))) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_EXPRESSION' IN TYPEOF(expr) THEN IF ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_VARIABLE' IN TYPEOF(va)) AND (va\ENTITY_INSTANCE_EXPRESSION.type_name <= expr\ ENTITY_INSTANCE_EXPRESSION.type_name) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_EXPRESSION' IN TYPEOF(expr) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_VARIABLE' IN TYPEOF(va)) THEN RETURN (COMPATIBLE_CLASS_AND_CLASS(va\CLASS_INSTANCE_EXPRESSION.expr_type ,expr\CLASS_INSTANCE_EXPRESSION.expr_type)); ELSE RETURN (FALSE); END_IF; END_IF; RETURN (COMPATIBLE_VARIABLE_AND_EXPRESSION(va,expr)); END_FUNCTION;
-- compatible_variable_and_library_expression FUNCTION collects_var_sem(va : AGGREGATE OF GENERIC_VARIABLE) : SET OF VARIABLE_SEMANTICS; LOCAL l : SET OF VARIABLE_SEMANTICS := []; END_LOCAL; REPEAT i := 1 TO SIZEOF(va); l:= l + SEMANTICS_OF(va[i]); END_REPEAT; RETURN (l); END_FUNCTION;
-- collects_var_sem FUNCTION collects_columns (t: TABLE_EXPRESSION) : LIST OF VARIABLE_SEMANTICS; LOCAL i: INTEGER; res, tempo: LIST [0:?] OF VARIABLE_SEMANTICS:=[]; x: BAG [1:1] OF TABLE_SPECIFICATION; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_VARIABLE'IN TYPEOF(t) THEN RETURN( t\TABLE_VARIABLE.structure); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_LITERAL' IN TYPEOF(t) THEN x := USEDIN(t\TABLE_LITERAL.the_value, 'ISO13584_G_M_IIM_SCHEMA' + '.TABLE_SPECIFICATION.TABLE_IDENTIFIER'); RETURN(x[1].column_meaning); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NATURAL_JOIN_EXPRESSION' IN TYPEOF(t) THEN RETURN( DIFF_COLUMNS( COLLECTS_COLUMNS( t\NATURAL_JOIN_EXPRESSION.table_1\TABLE_EXPRESSION), COLLECTS_COLUMNS( t\NATURAL_JOIN_EXPRESSION.table_2\TABLE_EXPRESSION))); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BINARY_TABLE_EXPRESSION' IN TYPEOF(t) THEN RETURN(COLLECTS_COLUMNS (t\BINARY_TABLE_EXPRESSION.operands[1])+ COLLECTS_COLUMNS(t\BINARY_TABLE_EXPRESSION.operands[2])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_TABLE_EXPRESSION' IN TYPEOF(t) THEN REPEAT i:=1 TO SIZEOF(t\MULTIPLE_ARITY_TABLE_EXPRESSION.operands); res := res + COLLECTS_COLUMNS(t\MULTIPLE_ARITY_TABLE_EXPRESSION.operands[i]); END_REPEAT; RETURN(res); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SELECT_EXPRESSION' IN TYPEOF(t) THEN RETURN(COLLECTS_COLUMNS (t\BINARY_GENERIC_EXPRESSION.operands[1]\TABLE_EXPRESSION)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROJECTION_EXPRESSION' IN TYPEOF(t) THEN REPEAT i := 1 TO SIZEOF(t\PROJECTION_EXPRESSION.argts_var); tempo := tempo +t\PROJECTION_EXPRESSION.argts_var[i]; END_REPEAT; RETURN(tempo); END_IF; RETURN([]); END_FUNCTION; -- collects_columns
FUNCTION compatible_types ( p1: PROPERTY_OR_DATA_TYPE_BSU; p2: PROPERTY_OR_DATA_TYPE_BSU) :LOGICAL; LOCAL p1_domain, p2_domain: DATA_TYPE; END_LOCAL; IF (NOT EXISTS(p1)) OR (NOT EXISTS(p2)) THEN RETURN(UNKNOWN); -- p1 or p2 indeterminate END_IF; (* case 1 *) IF p1 = p2 THEN RETURN (TRUE); END_IF; (* case 2 *) IF ((TYPEOF (p1) = TYPEOF (p2)) AND (p1\BASIC_SEMANTIC_UNIT.code = p2.code) AND (p1.name_scope\BASIC_SEMANTIC_UNIT.code = p2.name_scope\BASIC_SEMANTIC_UNIT.code) AND (p1\BASIC_SEMANTIC_UNIT.version >= p2\BASIC_SEMANTIC_UNIT.version)) THEN RETURN (TRUE); END_IF; (* case 8 *) IF (SIZEOF(p1\BASIC_SEMANTIC_UNIT.definition)=0) OR (SIZEOF(p2\BASIC_SEMANTIC_UNIT.definition)=0) THEN RETURN(UNKNOWN); ELSE IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF (p1) THEN p1_domain := p1.definition [1]\PROPERTY_DET.domain; ELSE p1_domain := p1.definition[1]\DATA_TYPE_ELEMENT.type_definition; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF (p2) THEN p2_domain := p2.definition [1]\PROPERTY_DET.domain; ELSE p2_domain := p2.definition[1]\DATA_TYPE_ELEMENT.type_definition; END_IF; END_IF; (* case 3 *) IF p1_domain = p2_domain THEN RETURN(TRUE); END_IF; (* case 4 *) IF (NOT(SIZEOF(DATA_TYPE_TYPEOF(p1)) = 0)) AND (DATA_TYPE_TYPEOF(p1)<=DATA_TYPE_TYPEOF(p2)) AND (NOT ('ISO13584_G_M_IIM_SCHEMA.COMPLEX_TYPE' IN DATA_TYPE_TYPEOF(p2))) THEN RETURN(TRUE); END_IF; (* case 5 *) IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(p1)) AND ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(p2)) THEN RETURN(COMPATIBLE_SUBCLASS(DATA_TYPE_CLASS_OF (p1)[1], DATA_TYPE_CLASS_OF (p2)[1])); END_IF; (* case 6 *) IF ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(p1)) AND ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(p2)) THEN IF ((DATA_TYPE_TYPE_NAME (p1) <= DATA_TYPE_TYPE_NAME (p2)) AND (DATA_TYPE_TYPE_NAME (p1) <> [])) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; (* case 7 *) IF ('ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN DATA_TYPE_TYPEOF(p1)) AND ('ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN DATA_TYPE_TYPEOF(p2)) THEN IF (DATA_TYPE_LEVEL_SPEC (p1) = DATA_TYPE_LEVEL_SPEC(p2)) AND (DATA_TYPE_LEVEL_VALUE_TYPEOF(p1) <> []) AND (DATA_TYPE_LEVEL_VALUE_TYPEOF(p1) <= DATA_TYPE_LEVEL_VALUE_TYPEOF(p2)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; (* case 8 *) IF ((DATA_TYPE_TYPEOF(p1) = []) OR (DATA_TYPE_TYPEOF(p2) = [])) THEN RETURN (UNKNOWN); ELSE RETURN (FALSE); END_IF; END_FUNCTION; -- compatible_types
FUNCTION applicable_properties( cl: CLASS_BSU; prop: AGGREGATE OF PROPERTY_BSU): LOGICAL; IF SIZEOF(prop) = 0 THEN RETURN(TRUE); END_IF; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; prop := prop - LIST_TO_SET(cl.definition[1]\CLASS.described_by); IF 'ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(cl.definition[1]) THEN prop := prop - LIST_TO_SET(cl.definition[1] \A_PRIORI_SEMANTICS_RELATIONSHIP.referenced_properties); END_IF; IF SIZEOF(Prop)=0 THEN RETURN(TRUE); ELSE IF EXISTS (cl.definition[1]\CLASS.its_superclass) THEN RETURN (APPLICABLE_PROPERTIES(cl.definition[1] \CLASS.its_superclass, prop)); ELSE RETURN (FALSE); END_IF; END_IF; END_FUNCTION; -- applicable_properties
FUNCTION visible_documents (cl: CLASS_BSU; doc: AGGREGATE OF DOCUMENT_BSU): LOGICAL; LOCAL i: INTEGER; END_LOCAL; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; REPEAT i := 1 TO SIZEOF(doc); IF doc[i].name_scope = cl THEN doc := doc - doc[i]; END_IF; END_REPEAT; IF SIZEOF(doc) = 0 THEN RETURN(TRUE); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN (VISIBLE_DOCUMENTS(cl.definition[1] \CLASS.its_superclass, doc)); ELSE RETURN(FALSE); END_IF; END_FUNCTION; -- visible_documents
FUNCTION get_property_BSU_from_property_semantics (l : AGGREGATE OF VARIABLE_SEMANTICS): LIST[1:?] OF PROPERTY_BSU; LOCAL i: INTEGER; res: LIST[0:?] OF PROPERTY_BSU:=[]; END_LOCAL; REPEAT i := 1 TO SIZEOF(l); res := res + l[i]\PROPERTY_SEMANTICS.the_property; END_REPEAT; RETURN(res); END_FUNCTION; -- get_property_BSU_from_property_semantics
FUNCTION visible_tables (cl: CLASS_BSU; tab: AGGREGATE OF TABLE_BSU): LOGICAL; LOCAL i: INTEGER; END_LOCAL; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; REPEAT i := 1 TO SIZEOF(tab); IF tab[i].name_scope = cl THEN tab := tab - tab[i]; END_IF; END_REPEAT; IF SIZEOF(tab) = 0 THEN RETURN(TRUE); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN (VISIBLE_TABLES(cl.definition[1] \CLASS.its_superclass, tab)); ELSE RETURN(FALSE); END_IF; END_FUNCTION; -- visible_tables
FUNCTION prefix_ordered_class_list(classes : LIST[2:?] OF CLASS_BSU) : BOOLEAN ; LOCAL i,j,k : INTEGER; related_token : CLASS_RELATED_BSU; -- items associated with -- a class through a -- class_BSU_relationship END_LOCAL; REPEAT i := 2 TO SIZEOF(classes); IF SIZEOF(classes[i].definition) = 1 THEN IF (EXISTS(classes[i].definition[1]\CLASS.its_superclass)) AND (NOT (( classes[i].definition[1]\CLASS.its_superclass) IN (MAKES_SUB_LIST( classes,1,i - 1)))) THEN RETURN (FALSE); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(classes[i].definition[1])) THEN IF (QUERY(x <* classes[i].definition[1]\A_PRIORI_SEMANTICS_RELATIONSHIP. referenced_classes | NOT (x IN MAKES_SUB_LIST(classes,1,i - 1))) <> [ ]) THEN RETURN (FALSE); END_IF; END_IF; IF NOT (SIZEOF(classes[i].definition[1]\CLASS.described_by) = 0) THEN IF MAKES_REFERENCE_OUTSIDE(classes[i].definition[1]\CLASS.described_by, MAKES_SUB_LIST(classes,1,i - 1)) THEN RETURN (FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(classes[i].definition[1])) THEN IF MAKES_REFERENCE_OUTSIDE(classes[i].definition[1]\ A_PRIORI_SEMANTICS_RELATIONSHIP.referenced_properties,MAKES_SUB_LIST( classes,1,i - 1)) THEN RETURN (FALSE); END_IF; END_IF; IF NOT (SIZEOF(classes[i].definition[1]\CLASS.defined_types) = 0) THEN IF MAKES_REFERENCE_OUTSIDE(classes[i].definition[1]\CLASS.defined_types, MAKES_SUB_LIST(classes,1,i - 1)) THEN RETURN (FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(classes[i].definition[1])) THEN IF MAKES_REFERENCE_OUTSIDE(classes[i].definition[1]\ A_PRIORI_SEMANTICS_RELATIONSHIP.referenced_data_types,MAKES_SUB_LIST( classes,1,i - 1)) THEN RETURN (FALSE); END_IF; END_IF; IF NOT (SIZEOF(classes[i].definition[1]\CLASS.associated_items) = 0) THEN REPEAT j := 1 TO SIZEOF(classes[i].definition[1]\CLASS.associated_items) ; REPEAT k := 1 TO SIZEOF(classes[i].definition[1]\CLASS.associated_items [j]\CLASS_BSU_RELATIONSHIP.related_tokens); related_token := classes[i].definition[1]\CLASS.associated_items[j]\ CLASS_BSU_RELATIONSHIP.related_tokens[k]; IF (('ISO13584_G_M_IIM_SCHEMA.TABLE_BSU') IN (TYPEOF( related_token))) AND NOT (related_token\TABLE_BSU.name_scope IN MAKES_SUB_LIST(classes,1,i)) THEN RETURN (FALSE); END_IF; IF (('ISO13584_G_M_IIM_SCHEMA.DOCUMENT_BSU') IN ( TYPEOF(related_token))) AND NOT (related_token\DOCUMENT_BSU. name_scope IN MAKES_SUB_LIST(classes,1,i)) THEN RETURN (FALSE); END_IF; END_REPEAT; END_REPEAT; END_IF; END_IF; END_REPEAT; RETURN (TRUE); END_FUNCTION;
-- prefix_ordered_class_list FUNCTION simple_type_data_type (type_spec: PROPERTY_OR_DATA_TYPE_BSU ): LOGICAL; IF NOT EXISTS(type_spec) THEN RETURN(UNKNOWN); -- type_spec is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SIMPLE_TYPE' IN DATA_TYPE_TYPEOF (type_spec) THEN RETURN (TRUE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.COMPLEX_TYPE' IN DATA_TYPE_TYPEOF (type_spec) THEN RETURN (FALSE); END_IF; RETURN (UNKNOWN); END_FUNCTION; -- simple_type_data_type
FUNCTION compatible_list_library_types_and_columns(dom : LIST[0:?] OF PROPERTY_OR_DATA_TYPE_BSU; col : LIST[0:?] OF COLUMN) : LOGICAL; LOCAL i : INTEGER; res : LOGICAL; END_LOCAL; res := TRUE; IF SIZEOF(dom) <> SIZEOF(col) THEN RETURN (FALSE); END_IF; REPEAT i := LOBOUND(col) TO HIBOUND(col); IF DATA_TYPE_TYPEOF(dom[i]) = [] THEN res := UNKNOWN; ELSE IF 'ISO13584_G_M_IIM_SCHEMA.INTEGER_COLUMN' IN TYPEOF(col[i]) THEN IF ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF(dom[i])) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF( dom[i])) AND NOT ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF(dom[i]))) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_COLUMN' IN TYPEOF(col[i]) THEN IF ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF(dom[i]) ) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF (dom[i])) AND NOT ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF(dom[i]))) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_COLUMN' IN TYPEOF(col[i]) THEN IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_TYPE' IN DATA_TYPE_TYPEOF(dom[i ]) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.STRING_COLUMN' IN TYPEOF(col[i]) THEN IF 'ISO13584_G_M_IIM_SCHEMA.STRING_TYPE' IN DATA_TYPE_TYPEOF(dom[i] ) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_COLUMN' IN TYPEOF(col[i]) THEN IF ('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(dom[i])) AND (DATA_TYPE_TYPE_NAME(dom[i]) <= col[i]\ ENTITY_INSTANCE_COLUMN.type_name) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_COLUMN' IN TYPEOF(col[i]) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(dom[i])) AND (COMPATIBLE_SUBCLASS(DATA_TYPE_CLASS_OF (dom[i])[1],col[i]\CLASS_INSTANCE_COLUMN.class_ref)) THEN ; ELSE RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_COLUMN' IN TYPEOF(col[i]) THEN IF ('ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN DATA_TYPE_TYPEOF(dom[i] )) THEN REPEAT j := LOBOUND(col[i].values) TO HIBOUND(col[i].values); IF NOT (COMPATIBLE_LEVEL_TYPE_AND_INSTANCE(DATA_TYPE_LEVEL_SPEC(dom[i ]),DATA_TYPE_LEVEL_VALUE_TYPEOF(dom[i]),col[i].values[j])) THEN RETURN (FALSE); END_IF; END_REPEAT; ELSE RETURN (FALSE); END_IF; END_IF; END_IF; END_REPEAT; RETURN (res); END_FUNCTION;
-- compatible_list_library_types_and_columns FUNCTION visible_properties (cl: CLASS_BSU; prop: AGGREGATE OF PROPERTY_BSU): LOGICAL; LOCAL i: INTEGER; ok: BOOLEAN:=TRUE; END_LOCAL; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; REPEAT i:=1 TO SIZEOF(prop); IF NOT(prop[i] IN COMPUTE_KNOWN_VISIBLE_PROPERTIES(cl)) THEN ok:=FALSE; END_IF; END_REPEAT; IF NOT(ok) AND NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN(UNKNOWN); END_IF; IF NOT(ok) AND ALL_CLASS_DESCRIPTIONS_REACHABLE(cl) THEN RETURN(FALSE); END_IF; RETURN(TRUE); END_FUNCTION; -- visible_properties
FUNCTION data_type_typeof (type_spec: PROPERTY_OR_DATA_TYPE_BSU) : SET OF STRING; LOCAL res: BOOLEAN; x: DATA_TYPE; END_LOCAL; res := FALSE; IF NOT EXISTS(type_spec) THEN RETURN([]); -- type_spec is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(type_spec) THEN IF NOT(SIZEOF(type_spec.definition)=0) THEN x := type_spec.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(type_spec.definition)=0) THEN x := type_spec.definition[1] \DATA_TYPE_ELEMENT.type_definition; res := TRUE; END_IF; END_IF; IF NOT (res) THEN RETURN([]); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN IF NOT(SIZEOF(x\NAMED_TYPE.referred_type.definition)=0) THEN RETURN (DATA_TYPE_TYPEOF(x\NAMED_TYPE.referred_type)); ELSE RETURN ([]); END_IF; ELSE RETURN(TYPEOF(x)); END_IF; END_FUNCTION; -- data_type_typeof
FUNCTION data_type_named_type(type_spec: PROPERTY_OR_DATA_TYPE_BSU) : SET[0:1] OF DATA_TYPE_BSU; LOCAL res: BOOLEAN; s: SET[0:1] OF DATA_TYPE_BSU; x: DATA_TYPE; END_LOCAL; res := FALSE; s := [ ]; IF NOT EXISTS(type_spec) THEN RETURN([]); -- type_spec is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(type_spec) THEN IF NOT(SIZEOF(type_spec.definition)=0) THEN x := type_spec.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(type_spec.definition)=0) THEN x:=type_spec.definition[1]\DATA_TYPE_ELEMENT.type_definition; res := TRUE; END_IF; END_IF; IF res THEN IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN s :=s + x\NAMED_TYPE.referred_type; END_IF; END_IF; RETURN(s); END_FUNCTION; -- data_type_named_type
FUNCTION check_syn_length ( s: SYN_NAME_TYPE; s_length: INTEGER) :BOOLEAN; IF 'ISO13584_G_M_IIM_SCHEMA.LABEL_WITH_LANGUAGE' IN TYPEOF(s) THEN RETURN (LENGTH(s\LABEL_WITH_LANGUAGE.l) <= s_length); ELSE RETURN (LENGTH(s) <= s_length); END_IF; END_FUNCTION;
-- check_syn_length FUNCTION dimensions_for_si_unit(n : SI_UNIT_NAME) : DIMENSIONAL_EXPONENTS; CASE n OF metre : RETURN (DIMENSIONAL_EXPONENTS(1.0,0.0,0.0,0.0,0.0,0.0,0.0)); gram : RETURN (DIMENSIONAL_EXPONENTS(0.0,1.0,0.0,0.0,0.0,0.0,0.0)); second : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,1.0,0.0,0.0,0.0,0.0)); ampere : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,1.0,0.0,0.0,0.0)); kelvin : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,1.0,0.0,0.0)); mole : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,1.0,0.0)); candela : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,1.0)); radian : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,0.0)); steradian : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,0.0)); hertz : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,- 1.0,0.0,0.0,0.0,0.0)); newton : RETURN (DIMENSIONAL_EXPONENTS(1.0,1.0,- 2.0,0.0,0.0,0.0,0.0)); pascal : RETURN (DIMENSIONAL_EXPONENTS(- 1.0,1.0,- 2.0,0.0,0.0,0.0,0.0)); joule : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 2.0,0.0,0.0,0.0,0.0)); watt : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 3.0,0.0,0.0,0.0,0.0)); coulomb : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,1.0,1.0,0.0,0.0,0.0)); volt : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 3.0,- 1.0,0.0,0.0,0.0)); farad : RETURN (DIMENSIONAL_EXPONENTS(- 2.0,- 1.0,4.0,1.0,0.0,0.0,0.0)); ohm : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 3.0,- 2.0,0.0,0.0,0.0)); siemens : RETURN (DIMENSIONAL_EXPONENTS(- 2.0,- 1.0,3.0,2.0,0.0,0.0,0.0)); weber : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 2.0,- 1.0,0.0,0.0,0.0)); tesla : RETURN (DIMENSIONAL_EXPONENTS(0.0,1.0,- 2.0,- 1.0,0.0,0.0,0.0)); henry : RETURN (DIMENSIONAL_EXPONENTS(2.0,1.0,- 2.0,- 2.0,0.0,0.0,0.0)); degree_celsius : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,1.0,0.0,0.0)) ; lumen : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,1.0)); lux : RETURN (DIMENSIONAL_EXPONENTS(- 2.0,0.0,0.0,0.0,0.0,0.0,1.0)); becquerel : RETURN (DIMENSIONAL_EXPONENTS(0.0,0.0,- 1.0,0.0,0.0,0.0,0.0)); gray : RETURN (DIMENSIONAL_EXPONENTS(2.0,0.0,- 2.0,0.0,0.0,0.0,0.0)); sievert : RETURN (DIMENSIONAL_EXPONENTS(2.0,0.0,- 2.0,0.0,0.0,0.0,0.0)); END_CASE; END_FUNCTION;
FUNCTION valid_units(m : MEASURE_WITH_UNIT) : BOOLEAN; IF 'ISO13584_G_M_IIM_SCHEMA.LENGTH_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 1.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MASS_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,1.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.TIME_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,1.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.ELECTRIC_CURRENT_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,1.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.THERMODYNAMIC_TEMPERATURE_MEASURE' IN TYPEOF (m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,1.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.AMOUNT_OF_SUBSTANCE_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,1.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LUMINOUS_INTENSITY_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,0.0,1.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PLANE_ANGLE_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SOLID_ANGLE_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.AREA_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 2.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.VOLUME_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 3.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.RATIO_MEASURE' IN TYPEOF(m.value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.POSITIVE_LENGTH_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 1.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.POSITIVE_PLANE_ANGLE_MEASURE' IN TYPEOF(m. value_component) THEN IF DERIVE_DIMENSIONAL_EXPONENTS(m.unit_component) <> DIMENSIONAL_EXPONENTS( 0.0,0.0,0.0,0.0,0.0,0.0,0.0) THEN RETURN (FALSE); END_IF; END_IF; RETURN (TRUE); END_FUNCTION;
FUNCTION normalise(arg : VECTOR_OR_DIRECTION) : VECTOR_OR_DIRECTION; LOCAL ndim : INTEGER; v : DIRECTION; result : VECTOR_OR_DIRECTION; vec : VECTOR; mag : REAL; END_LOCAL; IF NOT EXISTS(arg) THEN result := ?; ELSE ndim := arg.dim; IF 'ISO13584_G_M_IIM_SCHEMA.VECTOR' IN TYPEOF(arg) THEN BEGIN vec := arg; v := arg.orientation; IF arg.magnitude = 0.0 THEN RETURN (?); ELSE vec.magnitude := 1.0; END_IF; END; ELSE v := arg; END_IF; mag := 0.0; REPEAT i := 1 TO ndim; mag := mag + v.direction_ratios[i] * v.direction_ratios[i]; END_REPEAT; IF mag > 0.0 THEN mag := SQRT(mag); REPEAT i := 1 TO ndim; v.direction_ratios[i] := v.direction_ratios[i] / mag; END_REPEAT; IF 'ISO13584_G_M_IIM_SCHEMA.VECTOR' IN TYPEOF(arg) THEN vec.orientation := v; result := vec; ELSE result := v; END_IF; ELSE RETURN (?); END_IF; END_IF; RETURN (result); END_FUNCTION;
FUNCTION build_2axes(ref_direction : DIRECTION) : LIST[2:2] OF DIRECTION; LOCAL u : LIST[2:2] OF DIRECTION; END_LOCAL; u[1] := NVL(NORMALISE(ref_direction),DIRECTION([1.0,0.0])); u[2] := ORTHOGONAL_COMPLEMENT(u[1]); RETURN (u); END_FUNCTION;
FUNCTION build_axes(axis,ref_direction : DIRECTION) : LIST[3:3] OF DIRECTION; LOCAL u : LIST[3:3] OF DIRECTION; END_LOCAL; u[3] := NVL(NORMALISE(axis),DIRECTION([0.0,0.0,1.0])); u[1] := FIRST_PROJ_AXIS(u[3],ref_direction); u[2] := NORMALISE(CROSS_PRODUCT(u[3],u[1])).orientation; RETURN (u); END_FUNCTION;
FUNCTION cross_product(arg1,arg2 : DIRECTION) : VECTOR; LOCAL mag : REAL; res : DIRECTION; v1,v2 : LIST[3:3] OF REAL; result : VECTOR; END_LOCAL; IF (NOT EXISTS(arg1) OR (arg1.dim = 2)) OR (NOT EXISTS(arg2) OR (arg2.dim = 2 )) THEN RETURN (?); ELSE BEGIN v1 := NORMALISE(arg1).direction_ratios; v2 := NORMALISE(arg2).direction_ratios; res.direction_ratios[1] := (v1[2] * v2[3] - v1[3] * v2[2]); res.direction_ratios[2] := (v1[3] * v2[1] - v1[1] * v2[3]); res.direction_ratios[3] := (v1[1] * v2[2] - v1[2] * v2[1]); mag := 0.0; REPEAT i := 1 TO 3; mag := mag + res.direction_ratios[i] * res.direction_ratios[i]; END_REPEAT; IF (mag > 0.0) THEN result.orientation := res; result.magnitude := SQRT(mag); ELSE result.orientation := arg1; result.magnitude := 0.0; END_IF; RETURN (result); END; END_IF; END_FUNCTION;
FUNCTION using_representations(item : REPRESENTATION_ITEM) : SET OF REPRESENTATION; LOCAL results : SET OF REPRESENTATION; result_bag : BAG OF REPRESENTATION; intermediate_items : SET OF REPRESENTATION_ITEM; i : INTEGER; END_LOCAL; -- Find the representations in which the item is used and add to the -- results set. result_bag := USEDIN(item,'ISO13584_G_M_IIM_SCHEMA.REPRESENTATION.ITEMS' ); IF SIZEOF(result_bag) > 0 THEN REPEAT i := 1 TO HIINDEX(result_bag); results := results + result_bag[i]; END_REPEAT; END_IF; -- Find the set of representation_items in which item is used. intermediate_items := QUERY(z <* BAG_TO_SET(USEDIN(item,'')) | 'ISO13584_G_M_IIM_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(z)); -- If the set of intermediate items is not empty; IF SIZEOF(intermediate_items) > 0 THEN REPEAT i := 1 TO HIINDEX(intermediate_items); results := results + USING_REPRESENTATIONS(intermediate_items[i]); END_REPEAT; END_IF; -- Return the set of representation in which the input item is -- used directly and indirectly (through intervening representation_items). RETURN (results); END_FUNCTION;
FUNCTION is_acyclic(arg : GENERIC_EXPRESSION) : BOOLEAN; RETURN (ACYCLIC(arg,[])); END_FUNCTION;
-- is_acyclic FUNCTION compute_known_applicable_properties(cl : CLASS_BSU) : SET OF PROPERTY_BSU; LOCAL s : SET OF PROPERTY_BSU := []; END_LOCAL; IF SIZEOF(cl.definition) = 0 THEN RETURN (s); ELSE REPEAT i := 1 TO SIZEOF(cl.definition[1]\CLASS.described_by); s := s + cl.definition[1]\CLASS.described_by[i]; END_REPEAT; IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN s := s + COMPUTE_KNOWN_APPLICABLE_PROPERTIES(cl.definition[1]\CLASS. its_superclass); END_IF; RETURN (s); END_IF; END_FUNCTION;
FUNCTION compute_known_applicable_data_types(cl : CLASS_BSU) : SET OF DATA_TYPE_BSU; LOCAL s : SET OF DATA_TYPE_BSU := []; END_LOCAL; IF SIZEOF(cl.definition) = 0 THEN RETURN (s); ELSE REPEAT i := 1 TO SIZEOF(cl.definition[1]\CLASS.defined_types); s := s + cl.definition[1]\CLASS.defined_types[i]; END_REPEAT; IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN s := s + COMPUTE_KNOWN_APPLICABLE_DATA_TYPES(cl.definition[1]\CLASS. its_superclass); END_IF; RETURN (s); END_IF; END_FUNCTION;
FUNCTION acyclic_superclass_relationship(current : CLASS_BSU;visited : SET OF CLASS) : LOGICAL; IF SIZEOF(current.definition) = 1 THEN IF current.definition[1]\CLASS IN visited THEN RETURN (FALSE); ELSE IF EXISTS(current.definition[1]\CLASS.its_superclass) THEN RETURN (ACYCLIC_SUPERCLASS_RELATIONSHIP(current.definition[1]\CLASS. its_superclass,visited + current.definition[1]\CLASS)); ELSE RETURN (TRUE); END_IF; END_IF; ELSE RETURN (UNKNOWN); END_IF; END_FUNCTION;
-- acyclic_superclass_relationship FUNCTION list_to_set(l : LIST[0:?] OF GENERIC : type_elem) : SET OF GENERIC : type_elem; LOCAL s : SET OF GENERIC : type_elem := []; END_LOCAL; REPEAT i := 1 TO SIZEOF(l); s := s + l[i]; END_REPEAT; RETURN (s); END_FUNCTION;
-- list_to_set FUNCTION check_label_length(l : TRANSLATABLE_LABEL;l_length : INTEGER) : BOOLEAN; IF 'ISO13584_G_M_IIM_SCHEMA.TRANSLATED_LABEL' IN TYPEOF(l) THEN REPEAT i := 1 TO SIZEOF(l.labels); IF LENGTH(l.labels[i]) > l_length THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); ELSE RETURN (LENGTH(l) <= l_length); END_IF; END_FUNCTION;
-- check_label_length FUNCTION allowed_properties (cl: CLASS_BSU; prop: SET OF PROPERTY_BSU) : LOGICAL; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); -- the class itself is indeterminate END_IF; IF NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN(UNKNOWN); END_IF; IF prop <= (LIST_TO_SET(PROVIDED_PROPERTIES_LIST (cl))) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_FUNCTION; -- allowed_properties
FUNCTION gm_free_characteristics_list(cl : CLASS_BSU) : LIST OF PROPERTY_BSU; LOCAL i : INTEGER; selec : LIST OF PROPERTY_BSU := []; --non redefined properties def : LIST OF PROPERTY_BSU; --free defined characteristics redef : SET OF PROPERTY_BSU; --derived redefined properties END_LOCAL; def := FREE_DEFINED_CHARACTERISTICS(cl); redef := DERIVED_REDEFINED_PROPERTIES(cl); REPEAT i := 1 TO SIZEOF(def); IF NOT (def[i] IN redef) THEN selec := selec + def[i]; END_IF; END_REPEAT; RETURN (selec); END_FUNCTION;
-- gm_free_characteristics_list FUNCTION collects_assigned_instance_properties(props : SET[0:?] OF PROPERTY_VALUE) : SET OF PROPERTY_BSU; LOCAL assign_prop : SET OF PROPERTY_BSU; --assigned properties of the dic_class_instance i : INTEGER; END_LOCAL; assign_prop := []; REPEAT i := 1 TO HIBOUND(props); assign_prop := assign_prop + props[i].prop_def; END_REPEAT; RETURN (assign_prop); END_FUNCTION;
-- collects_assigned_instance_properties FUNCTION data_type_type_name(t: PROPERTY_OR_DATA_TYPE_BSU) : SET [0:?] OF STRING; LOCAL res: BOOLEAN; s: SET [0:1] OF STRING; x: DATA_TYPE; END_LOCAL; res := FALSE; s := [ ]; IF NOT EXISTS(t) THEN RETURN([]); -- t is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(t) THEN IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\DATA_TYPE_ELEMENT.type_definition; res:=TRUE; END_IF; END_IF; IF res THEN IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_TYPE' IN TYPEOF(x) THEN s := x\ENTITY_INSTANCE_TYPE.type_name; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN s := DATA_TYPE_TYPE_NAME(x\NAMED_TYPE.referred_type); END_IF; END_IF; RETURN(s); END_FUNCTION; -- data_type_type_name
FUNCTION data_type_class_of(type_spec: PROPERTY_OR_DATA_TYPE_BSU) : SET[0:1] OF CLASS_BSU; LOCAL res: BOOLEAN; s: SET[0:1] OF CLASS_BSU; x: DATA_TYPE; END_LOCAL; res := FALSE; s := [ ]; IF NOT EXISTS(type_spec) THEN RETURN([]); -- type_spec is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(type_spec) THEN IF NOT(SIZEOF(type_spec.definition)=0) THEN x := type_spec.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(type_spec.definition)=0) THEN x := type_spec.definition[1]\DATA_TYPE_ELEMENT.type_definition; res := TRUE; END_IF; END_IF; IF res THEN IF 'ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN TYPEOF(x) THEN s :=s+ x\CLASS_INSTANCE_TYPE.domain; RETURN(s); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN s := DATA_TYPE_CLASS_OF(x\NAMED_TYPE.referred_type); RETURN(s); END_IF; END_IF; RETURN(s); END_FUNCTION; -- data_type_class_of
FUNCTION visible_properties_for_visible_tables ( rel : CLASS_TABLE_RELATIONSHIP) : LOGICAL; IF QUERY (table <* rel.related_tokens | SIZEOF ( table.definition) =0) <> [] THEN RETURN (UNKNOWN); END_IF; RETURN ( QUERY (table <* rel.related_tokens | (APPLICABLE_PROPERTIES (rel\CLASS_BSU_RELATIONSHIP.relating_class .identified_by, GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS (table\BASIC_SEMANTIC_UNIT.definition[1] \TABLE_ELEMENT.column_meaning)) = FALSE)) = []); END_FUNCTION;
FUNCTION data_type_level_spec (t: PROPERTY_OR_DATA_TYPE_BSU) : LIST[0:4] OF UNIQUE LEVEL; LOCAL res: BOOLEAN; s: LIST[0:4] OF UNIQUE LEVEL; x: DATA_TYPE; END_LOCAL; res := FALSE; s := []; IF NOT EXISTS(t) THEN RETURN([]); -- t is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(t) THEN IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\DATA_TYPE_ELEMENT.type_definition; res := TRUE; END_IF; END_IF; IF res THEN IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN TYPEOF(x) THEN s := x\LEVEL_TYPE.levels; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN s := DATA_TYPE_LEVEL_SPEC(x\NAMED_TYPE.referred_type); END_IF; END_IF; RETURN(s); END_FUNCTION; -- data_type_level_spec
FUNCTION data_type_level_value_typeof(t: PROPERTY_OR_DATA_TYPE_BSU) : SET OF STRING; LOCAL res: BOOLEAN; s: SET OF STRING; x: DATA_TYPE; END_LOCAL; res := FALSE; s := []; IF NOT EXISTS(t) THEN RETURN([]); -- t is indeterminate END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF(t) THEN IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\PROPERTY_DET.domain; res := TRUE; END_IF; ELSE IF NOT(SIZEOF(t.definition)=0) THEN x := t.definition[1]\DATA_TYPE_ELEMENT.type_definition; res := TRUE; END_IF; END_IF; IF res THEN IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_TYPE' IN TYPEOF(x) THEN s := TYPEOF(x\LEVEL_TYPE.VALUE_TYPE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.NAMED_TYPE' IN TYPEOF(x) THEN s := DATA_TYPE_LEVEL_VALUE_TYPEOF(x\NAMED_TYPE .referred_type); END_IF; END_IF; RETURN(s); END_FUNCTION; -- data_type_level_value_typeof
FUNCTION right_values_for_level_spec ( levels: LIST [1:4] OF UNIQUE LEVEL; val: LEVEL_SPEC_VALUE ):BOOLEAN; LOCAL c_place: BOOLEAN; lev: SET [1:4] OF LEVEL; END_LOCAL; c_place := TRUE; lev := LIST_TO_SET(levels); IF EXISTS (val.values[1]) THEN IF LEVEL.min IN lev THEN lev:= lev - [LEVEL.min]; ELSE c_place:= FALSE; END_IF; END_IF; IF EXISTS (val.values[2]) THEN IF LEVEL.nom IN lev THEN lev:= lev -[LEVEL.nom]; ELSE c_place:= FALSE; END_IF; END_IF; IF EXISTS (val.values[3]) THEN IF LEVEL.typ IN lev THEN lev:= lev - [LEVEL.typ]; ELSE c_place:= FALSE; END_IF; END_IF; IF EXISTS (val.values[4]) THEN IF LEVEL.max IN lev THEN lev:= lev - [LEVEL.max]; ELSE c_place:= FALSE; END_IF; END_IF; IF (c_place AND (SIZEOF(lev)=0)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_FUNCTION; -- right_values_for_level_spec
FUNCTION compatible_simple_type_and_expression( dom:PROPERTY_OR_DATA_TYPE_BSU; expr: EXPRESSION): LOGICAL; IF DATA_TYPE_TYPEOF(dom)= [] THEN RETURN(UNKNOWN); END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF (expr)) AND IS_INT_EXPR (expr\NUMERIC_EXPRESSION) THEN IF (('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF (dom)) OR ('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF (dom))) AND (NOT ('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF (dom))) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF (expr)) AND NOT IS_INT_EXPR (expr\NUMERIC_EXPRESSION) THEN IF (('ISO13584_G_M_IIM_SCHEMA.REAL_TYPE' IN DATA_TYPE_TYPEOF (dom)) OR ('ISO13584_G_M_IIM_SCHEMA.NUMBER_TYPE' IN DATA_TYPE_TYPEOF (dom))) AND (NOT ('ISO13584_G_M_IIM_SCHEMA.INT_TYPE' IN DATA_TYPE_TYPEOF (dom))) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF (expr)) THEN IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_TYPE' IN DATA_TYPE_TYPEOF (dom) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF (expr)) THEN IF 'ISO13584_G_M_IIM_SCHEMA.STRING_TYPE' IN DATA_TYPE_TYPEOF (dom) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; -- all simple types have been considered END_FUNCTION; -- compatible_simple_type_and_expression
FUNCTION return_key (t: TABLE_EXPRESSION) : SET [1:?] OF VARIABLE_SEMANTICS; LOCAL i: INTEGER; res: SET [0:?] OF VARIABLE_SEMANTICS:=[]; x: BAG[1:1] OF TABLE_SPECIFICATION; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_VARIABLE'IN TYPEOF(t) THEN RETURN(t\SIMPLE_TABLE_EXPRESSION\TABLE_VARIABLE.its_key); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_LITERAL' IN TYPEOF(t) THEN x := USEDIN(t\TABLE_LITERAL.the_value, 'ISO13584_G_M_IIM_SCHEMA.' + 'TABLE_SPECIFICATION.TABLE_IDENTIFIER'); RETURN (x[1]\TABLE_SPECIFICATION.key); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.SELECT_EXPRESSION' IN TYPEOF(t) THEN RETURN ( RETURN_KEY( t\BINARY_GENERIC_EXPRESSION.operands[1]\TABLE_EXPRESSION)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.PROJECTION_EXPRESSION' IN TYPEOF(t) THEN IF QUERY (col <* t\PROJECTION_EXPRESSION.operand.the_key | NOT (col IN t\PROJECTION_EXPRESSION.argts_var)) <> [] THEN RETURN (LIST_TO_SET(t\TABLE_EXPRESSION.its_columns)); ELSE RETURN (t\PROJECTION_EXPRESSION.operand.the_key); END_IF; END_IF; IF (('ISO13584_G_M_IIM_SCHEMA.INTERSECT_TABLE_EXPRESSION' IN TYPEOF(t)) OR ('ISO13584_G_M_IIM_SCHEMA.DIFFERENCE_TABLE_EXPRESSION' IN TYPEOF(t))) THEN RETURN (RETURN_KEY(t\BINARY_TABLE_EXPRESSION.operands[1])); END_IF; IF (('ISO13584_G_M_IIM_SCHEMA.UNION_TABLE_EXPRESSION' IN TYPEOF(t)) OR ('ISO13584_G_M_IIM_SCHEMA.NATURAL_JOIN_EXPRESSION' IN TYPEOF(t))) THEN RETURN (RETURN_KEY(t\BINARY_TABLE_EXPRESSION.operands[1]) + RETURN_KEY(t\BINARY_TABLE_EXPRESSION.operands[2])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_TABLE_EXPRESSION' IN TYPEOF(t) THEN REPEAT i := 1 TO SIZEOF(t\MULTIPLE_ARITY_TABLE_EXPRESSION.operands); res := res +RETURN_KEY(t\MULTIPLE_ARITY_TABLE_EXPRESSION.operands[i]); END_REPEAT; RETURN (res); END_IF; RETURN([]); END_FUNCTION; -- return_key
FUNCTION compatible_variable_and_expression( va: GENERIC_VARIABLE; expr: EXPRESSION): LOGICAL; IF ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF (expr)) AND IS_INT_EXPR (expr\NUMERIC_EXPRESSION) THEN IF ('ISO13584_G_M_IIM_SCHEMA.INT_NUMERIC_VARIABLE' IN TYPEOF(va)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.NUMERIC_EXPRESSION' IN TYPEOF (expr)) THEN IF ('ISO13584_G_M_IIM_SCHEMA.REAL_NUMERIC_VARIABLE' IN TYPEOF(va)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.BOOLEAN_EXPRESSION' IN TYPEOF (expr)) THEN IF('ISO13584_G_M_IIM_SCHEMA.BOOLEAN_VARIABLE' IN TYPEOF(va)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; IF ('ISO13584_G_M_IIM_SCHEMA.STRING_EXPRESSION' IN TYPEOF (expr)) THEN IF ('ISO13584_G_M_IIM_SCHEMA.STRING_VARIABLE' IN TYPEOF(va)) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_IF; -- all simple types have been considered RETURN(UNKNOWN); END_FUNCTION; -- compatible_variable_and_expression
FUNCTION compatible_column_and_variable_semantics(col : COLUMN;sem : VARIABLE_SEMANTICS) : LOGICAL ; LOCAL va : SET OF GENERIC_VARIABLE; i : INTEGER; END_LOCAL; va := SYNTAX_OF(sem); IF SIZEOF(va) = 0 THEN RETURN (UNKNOWN); ELSE REPEAT i := LOBOUND(va) TO HIBOUND(va); IF (NOT COMPATIBLE_COLUMN_AND_VARIABLE(col,va[i])) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; END_FUNCTION;
-- compatible_column_and_variable_semantics FUNCTION used_table_literals(arg : GENERIC_EXPRESSION) : SET OF TABLE_IDENTIFICATION; LOCAL result : SET OF TABLE_IDENTIFICATION := []; END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.TABLE_LITERAL' IN TYPEOF(arg) THEN RETURN ([arg\TABLE_LITERAL.the_value]); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.UNARY_GENERIC_EXPRESSION' IN TYPEOF(arg) THEN RETURN (USED_TABLE_LITERALS(arg\UNARY_GENERIC_EXPRESSION.operand)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BINARY_GENERIC_EXPRESSION' IN TYPEOF(arg) THEN RETURN (USED_TABLE_LITERALS(arg\BINARY_GENERIC_EXPRESSION.operands[1]) + USED_TABLE_LITERALS(arg\BINARY_GENERIC_EXPRESSION.operands[2])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_GENERIC_EXPRESSION' IN TYPEOF (arg) THEN REPEAT i := 1 TO SIZEOF(arg\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands); result := result + USED_TABLE_LITERALS(arg\ MULTIPLE_ARITY_GENERIC_EXPRESSION.operands[i]); END_REPEAT; RETURN (result); END_IF; RETURN ([]); END_FUNCTION;
-- used_table_literals FUNCTION semantics_of(vars : GENERIC_VARIABLE) : VARIABLE_SEMANTICS; RETURN (vars.interpretation.semantics); END_FUNCTION;
-- semantics_of FUNCTION diff_columns(l1,l2 : LIST[1:?] OF VARIABLE_SEMANTICS) : LIST[1:?] OF VARIABLE_SEMANTICS; LOCAL i : INTEGER; END_LOCAL; REPEAT i := 1 TO SIZEOF(l2); IF l2[i] IN l1 THEN ; ELSE l1 := l1 + l2[i]; END_IF; END_REPEAT; RETURN (l1); END_FUNCTION;
-- diff_columns FUNCTION compatible_subclass (c1, c2: CLASS_BSU): LOGICAL; IF (NOT EXISTS(c1)) OR (NOT EXISTS(c2)) THEN RETURN(UNKNOWN); -- c1 or c2 indeterminate END_IF; IF c1 = c2 THEN RETURN (TRUE); END_IF; IF((c1.code = c2.code) AND (c1.version >= c2.version) AND (c1.defined_by.code = c2.defined_by.code)) THEN RETURN (TRUE); END_IF; IF SIZEOF (c2.definition) = 0 THEN RETURN(UNKNOWN); ELSE IF EXISTS(c2.definition[1]\CLASS.its_superclass) THEN RETURN(COMPATIBLE_SUBCLASS(c1, c2.definition[1] \CLASS.its_superclass)); ELSE RETURN(FALSE); END_IF; END_IF; END_FUNCTION; -- compatible_subclass
FUNCTION makes_sub_list(cla: LIST [1:?] OF CLASS_BSU; i, j: INTEGER): LIST [1:?] OF CLASS_BSU; LOCAL k: INTEGER; c: LIST [0:?] OF CLASS_BSU:=[]; END_LOCAL; REPEAT k := i TO j; c := c +cla[k]; END_REPEAT; RETURN(c); END_FUNCTION; -- makes_sub_list
FUNCTION makes_reference_outside ( p: AGGREGATE OF PROPERTY_OR_DATA_TYPE_BSU; l: LIST[1:?] OF CLASS_BSU): BOOLEAN; LOCAL j: INTEGER; bool: BOOLEAN := FALSE; temp: SET[0:1] OF CLASS_BSU; END_LOCAL; REPEAT j := 1 TO SIZEOF (p); IF ((('ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF (p[j])) AND (NOT (p[j]\PROPERTY_BSU.name_scope IN l))) OR (('ISO13584_G_M_IIM_SCHEMA.DATA_TYPE_BSU' IN TYPEOF (p[j])) AND (NOT (p[j]\DATA_TYPE_BSU.name_scope IN l)))) THEN bool := TRUE; RETURN(bool); END_IF; IF ((('ISO13584_G_M_IIM_SCHEMA.PROPERTY_BSU' IN TYPEOF (p[j])) AND (NOT (SIZEOF(p[j]\PROPERTY_BSU.definition)=0))) OR (('ISO13584_G_M_IIM_SCHEMA.DATA_TYPE_BSU' IN TYPEOF (p[j])) AND (NOT (SIZEOF(p[j]\DATA_TYPE_BSU.definition)=0)))) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_TYPE' IN DATA_TYPE_TYPEOF(p[j])) THEN IF NOT (temp[1] IN l) THEN bool := bool OR TRUE ; ELSE bool:= bool OR FALSE; END_IF; END_IF; IF SIZEOF (DATA_TYPE_NAMED_TYPE (p[j])) = 1 THEN bool := bool OR MAKES_REFERENCE_OUTSIDE (DATA_TYPE_NAMED_TYPE(p[j]), l); END_IF; END_IF; END_REPEAT; RETURN (bool); END_FUNCTION; -- makes_reference_outside
FUNCTION visible_types (cl: CLASS_BSU; typ: AGGREGATE OF DATA_TYPE_BSU): LOGICAL; LOCAL i: INTEGER; ok: BOOLEAN:=TRUE; END_LOCAL; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; REPEAT i:=1 TO SIZEOF(typ); IF NOT(typ[i] IN COMPUTE_KNOWN_VISIBLE_DATA_TYPES(cl)) THEN ok:=FALSE; END_IF; END_REPEAT; IF NOT(ok) AND NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN(UNKNOWN); END_IF; IF NOT(ok) AND ALL_CLASS_DESCRIPTIONS_REACHABLE(cl) THEN RETURN(FALSE); END_IF; RETURN(TRUE); END_FUNCTION; -- visible_types
FUNCTION applicable_types( cl: CLASS_BSU; typ: AGGREGATE OF DATA_TYPE_BSU): LOGICAL; IF SIZEOF(typ) = 0 THEN RETURN(TRUE); END_IF; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; typ := typ - cl.definition[1]\CLASS.defined_types; IF ('ISO13584_G_M_IIM_SCHEMA'+ '.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(cl.definition[1])) THEN typ := typ - cl.definition[1]\A_PRIORI_SEMANTICS_RELATIONSHIP .referenced_data_types; END_IF; IF SIZEOF(typ) = 0 THEN RETURN(TRUE); ELSE IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN(APPLICABLE_TYPES(cl.definition[1] \CLASS.its_superclass, typ)); ELSE RETURN(FALSE); END_IF; END_IF; END_FUNCTION; -- applicable_types
FUNCTION exists_super (cl: CLASS_BSU): LOGICAL; IF NOT EXISTS(cl) THEN RETURN (UNKNOWN); -- the class itself is indeterminate END_IF; IF (SIZEOF (cl.definition) = 0) THEN RETURN (UNKNOWN); ELSE IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; END_FUNCTION; -- exists_super
FUNCTION are_properties_not_in ( opt_or_mand: AGGREGATE OF OPT_OR_MAND_PROPERTY_BSU; prop: AGGREGATE OF PROPERTY_BSU) : BOOLEAN; IF (SIZEOF (QUERY (elt <* opt_or_mand| (elt.property IN prop))) = 0) THEN RETURN(TRUE); ELSE RETURN(FALSE); END_IF; END_FUNCTION; -- are_properties_not_in
FUNCTION provided_properties_list (cl: CLASS_BSU) : LIST OF PROPERTY_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_PROVIDED_PROPERTIES(cl, [])); END_IF; END_FUNCTION; -- provided_properties_list
FUNCTION super (cl: CLASS_BSU): SET [0:1] OF CLASS_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF (SIZEOF (cl.definition) = 1) THEN IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN ([cl.definition[1]\CLASS.its_superclass]); END_IF; END_IF; RETURN ([]); END_FUNCTION; -- super
FUNCTION selectable_properties_list(cl : CLASS_BSU) : LIST OF PROPERTY_BSU; LOCAL i : INTEGER; selec : LIST OF PROPERTY_BSU := []; --non redefined properties def : LIST OF PROPERTY_BSU; --selectable defined properties redef : SET OF PROPERTY_BSU; --derived redefined properties END_LOCAL; def := SELECTABLE_DEFINED_PROPERTIES(cl); redef := DERIVED_REDEFINED_PROPERTIES(cl); REPEAT i := 1 TO SIZEOF(def); IF NOT (def[i] IN redef) THEN selec := selec + def[i]; END_IF; END_REPEAT; RETURN (selec); END_FUNCTION;
-- selectable_properties_list FUNCTION optional_properties_list(cl : CLASS_BSU) : LIST OF PROPERTY_BSU; LOCAL i : INTEGER; opt : LIST OF PROPERTY_BSU := []; -- non redefined properties def : LIST OF PROPERTY_BSU; -- optional defined properties redef : SET OF PROPERTY_BSU; -- mandatory redefined properties END_LOCAL; def := OPTIONAL_DEFINED_PROPERTIES(cl); redef := MANDATORY_REDEFINED_PROPERTIES(cl); REPEAT i := 1 TO SIZEOF(def); IF NOT (def[i] IN redef) THEN opt := opt + def[i]; END_IF; END_REPEAT; RETURN (opt); END_FUNCTION;
-- optional_properties_list FUNCTION applicable_tables (cl: CLASS_BSU; tab: AGGREGATE OF TABLE_IDENTIFICATION): LOGICAL; IF SIZEOF(tab) = 0 THEN RETURN(TRUE); END_IF; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; tab := tab - RETRIEVE_TABLES (cl); IF 'ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(cl.definition[1]) THEN tab:= tab- cl.definition[1]\A_PRIORI_SEMANTICS_RELATIONSHIP.referenced_tables; END_IF; IF SIZEOF(tab) = 0 THEN RETURN(TRUE); ELSE IF EXISTS(cl.definition[1]\CLASS.its_Superclass) THEN RETURN( APPLICABLE_TABLES(cl.definition[1]\CLASS.its_superclass, tab)); ELSE RETURN(FALSE); END_IF; END_IF; END_FUNCTION; -- applicable_tables
FUNCTION applicable_documents (cl: CLASS_BSU; doc: AGGREGATE OF DOCUMENT_BSU): LOGICAL; IF SIZEOF(doc) = 0 THEN RETURN(TRUE); END_IF; IF NOT EXISTS(cl) THEN RETURN(UNKNOWN); END_IF; IF SIZEOF(cl.definition) = 0 THEN RETURN(UNKNOWN); END_IF; doc := doc - RETRIEVE_DOCUMENTS (cl); IF 'ISO13584_G_M_IIM_SCHEMA.A_PRIORI_SEMANTICS_RELATIONSHIP' IN TYPEOF(cl.definition[1]) THEN doc:= doc- cl.definition[1]\A_PRIORI_SEMANTICS_RELATIONSHIP.referenced_documents; END_IF; IF SIZEOF(doc) = 0 THEN RETURN(TRUE); ELSE IF EXISTS(cl.definition[1]\CLASS.its_superclass) THEN RETURN (APPLICABLE_DOCUMENTS(cl.definition[1] \CLASS.its_superclass, doc)); ELSE RETURN(FALSE); END_IF; END_IF; END_FUNCTION; -- applicable_documents
FUNCTION acyclic_class_extension_definition(cl : CLASS_BSU) : LOGICAL; LOCAL edges : SET OF DOMAIN_RESTRICTION; prop : LIST OF PROPERTY_BSU; i : INTEGER; END_LOCAL; IF NOT ALL_CLASS_DESCRIPTIONS_REACHABLE(cl) THEN RETURN (UNKNOWN); ELSE prop := PROVIDED_PROPERTIES_LIST(cl); edges := DEFINED_DOMAIN(cl) + DEFINED_DERIVATION_FUNCTION(cl); REPEAT i := LOBOUND(prop) TO HIBOUND(prop); IF NOT ACYCLIC_ORDER(prop[i],edges,[]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; END_FUNCTION;
-- acyclic_class_extension_definition FUNCTION derived_properties_list(cl : CLASS_BSU) : LIST OF PROPERTY_BSU; LOCAL i : INTEGER; deriv : LIST OF PROPERTY_BSU := []; --derived properties prov : LIST OF PROPERTY_BSU; --provided properties selec : LIST OF PROPERTY_BSU; --selectable properties END_LOCAL; prov := PROVIDED_PROPERTIES_LIST(cl); selec := SELECTABLE_PROPERTIES_LIST(cl); REPEAT i := 1 TO SIZEOF(prov); IF NOT (prov[i] IN selec) THEN deriv := deriv + prov[i]; END_IF; END_REPEAT; RETURN (deriv); END_FUNCTION;
-- derived_properties_list FUNCTION defined_derivation_function (cl: CLASS_BSU) : SET OF FUNCTIONAL_DOMAIN_RESTRICTION; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_DERIVATION_FUNCTION(cl, [])); END_IF; END_FUNCTION; -- defined_derivation_function
FUNCTION derive_dimensional_exponents(x : UNIT) : DIMENSIONAL_EXPONENTS; LOCAL i : INTEGER; result : DIMENSIONAL_EXPONENTS := DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0, 0.0,0.0); END_LOCAL; IF 'ISO13584_G_M_IIM_SCHEMA.DERIVED_UNIT' IN TYPEOF(x) THEN REPEAT i := LOINDEX(x.elements) TO HIINDEX(x.elements); result.length_exponent := result.length_exponent + (x.elements[i].exponent * x.elements[i].UNIT.dimensions.length_exponent ); result.mass_exponent := result.mass_exponent + (x.elements[i].exponent * x .elements[i].UNIT.dimensions.mass_exponent); result.time_exponent := result.time_exponent + (x.elements[i].exponent * x .elements[i].UNIT.dimensions.time_exponent); result.electric_current_exponent := result.electric_current_exponent + (x. elements[i].exponent * x.elements[i]. UNIT.dimensions. electric_current_exponent); result.thermodynamic_temperature_exponent := result. thermodynamic_temperature_exponent + (x.elements[i].exponent * x.elements[ i].UNIT.dimensions. thermodynamic_temperature_exponent); result.amount_of_substance_exponent := result.amount_of_substance_exponent + (x.elements[i].exponent * x. elements[i].UNIT.dimensions. amount_of_substance_exponent); result.luminous_intensity_exponent := result.luminous_intensity_exponent + (x.elements[i].exponent * x. elements[i].UNIT.dimensions. luminous_intensity_exponent); END_REPEAT; -- x is a unitless or a named unit ELSE result := x.dimensions; END_IF; RETURN (result); END_FUNCTION;
FUNCTION dimension_of(item : GEOMETRIC_REPRESENTATION_ITEM) : DIMENSION_COUNT; LOCAL x : SET OF REPRESENTATION; y : REPRESENTATION_CONTEXT; END_LOCAL; -- Find the set of representation in which the item is used. x := USING_REPRESENTATIONS(item); -- Determines the dimension_count of the -- geometric_representation_context. Note that the -- RULE compatible_dimension ensures that the context_of_items -- is of type geometric_representation_context and has -- the same dimension_count for all values of x. y := x[1].context_of_items; RETURN (y\GEOMETRIC_REPRESENTATION_CONTEXT.coordinate_space_dimension); END_FUNCTION;
FUNCTION orthogonal_complement(vec : DIRECTION) : DIRECTION; LOCAL result : DIRECTION; END_LOCAL; IF (vec.dim <> 2) OR NOT EXISTS(vec) THEN RETURN (?); ELSE result.direction_ratios[1] := - vec.direction_ratios[2]; result.direction_ratios[2] := vec.direction_ratios[1]; RETURN (result); END_IF; END_FUNCTION;
FUNCTION first_proj_axis(z_axis,arg : DIRECTION) : DIRECTION; LOCAL x_axis : DIRECTION; v : DIRECTION; z : DIRECTION; x_vec : VECTOR; END_LOCAL; IF (NOT EXISTS(z_axis)) OR (NOT EXISTS(arg)) OR (arg.dim <> 3) THEN x_axis := ?; ELSE z_axis := NORMALISE(z_axis); IF NOT EXISTS(arg) THEN IF (z_axis <> DIRECTION([1.0,0.0,0.0])) THEN v := DIRECTION([1.0,0.0,0.0]); ELSE v := DIRECTION([0.0,1.0,0.0]); END_IF; ELSE IF ((CROSS_PRODUCT(arg,z).magnitude) = 0.0) THEN RETURN (?); ELSE v := NORMALISE(arg); END_IF; END_IF; x_vec := SCALAR_TIMES_VECTOR(DOT_PRODUCT(v,z),z_axis); x_axis := VECTOR_DIFFERENCE(v,x_vec).orientation; x_axis := NORMALISE(x_axis); END_IF; RETURN (x_axis); END_FUNCTION;
FUNCTION bag_to_set(the_bag : BAG OF GENERIC : intype) : SET OF GENERIC : intype; LOCAL the_set : SET OF GENERIC : intype := []; i : INTEGER; END_LOCAL; IF SIZEOF(the_bag) > 0 THEN REPEAT i := 1 TO HIINDEX(the_bag); the_set := the_set + the_bag[i]; END_REPEAT; END_IF; RETURN (the_set); END_FUNCTION;
FUNCTION superclass_of_item_is_item ( cl : ITEM_CLASS) : LOGICAL; IF NOT EXISTS (cl\CLASS.its_superclass) THEN RETURN (TRUE); END_IF; IF SIZEOF (cl\CLASS.its_superclass.definition) = 0 THEN RETURN (UNKNOWN); END_IF; RETURN ( ('ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS') IN TYPEOF (cl\CLASS.its_superclass.definition[1])); END_FUNCTION; -- superclass_of_item_is_item
FUNCTION acyclic(arg1 : GENERIC_EXPRESSION;arg2 : SET OF GENERIC_EXPRESSION) : BOOLEAN; LOCAL result : BOOLEAN; END_LOCAL; IF ('ISO13584_G_M_IIM_SCHEMA.SIMPLE_GENERIC_EXPRESSION' IN TYPEOF(arg1)) THEN RETURN (TRUE); END_IF; IF arg1 IN arg2 THEN RETURN (FALSE); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.UNARY_GENERIC_EXPRESSION' IN TYPEOF(arg1) THEN RETURN (ACYCLIC(arg1\UNARY_GENERIC_EXPRESSION.operand,arg2 + [arg1])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BINARY_GENERIC_EXPRESSION' IN TYPEOF(arg1) THEN RETURN (ACYCLIC(arg1\BINARY_GENERIC_EXPRESSION.operands[1],arg2 + [arg1]) AND ACYCLIC(arg1\BINARY_GENERIC_EXPRESSION.operands[2],arg2 + [arg1])); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.MULTIPLE_ARITY_GENERIC_EXPRESSION' IN TYPEOF (arg1) THEN result := TRUE; REPEAT i := 1 TO SIZEOF(arg1\MULTIPLE_ARITY_GENERIC_EXPRESSION.operands); result := result AND ACYCLIC(arg1\MULTIPLE_ARITY_GENERIC_EXPRESSION. operands[i],arg2 + [arg1]); END_REPEAT; RETURN (result); END_IF; END_FUNCTION;
-- acyclic FUNCTION free_defined_characteristics (cl: CLASS_BSU) : LIST OF PROPERTY_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_GM_FREE_CHARACTERISTICS(cl, [])); END_IF; END_FUNCTION; -- free_defined_characteristics
FUNCTION derived_redefined_properties(cl : CLASS_BSU) : SET OF PROPERTY_BSU; IF NOT (ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_DERIVED_REDEFINED_PROPERTIES(cl,[])); END_IF; END_FUNCTION;
-- derived_redefined_properties FUNCTION compatible_column_and_variable (col: COLUMN; v: GENERIC_VARIABLE) : LOGICAL; (* The following express statements deal with simple types *) IF 'ISO13584_G_M_IIM_SCHEMA.INT_NUMERIC_VARIABLE' IN TYPEOF(v) THEN RETURN (('ISO13584_G_M_IIM_SCHEMA.INTEGER_COLUMN' IN TYPEOF (col)) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_COLUMN' IN TYPEOF (col)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.REAL_COLUMN' IN TYPEOF (col)))); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.REAL_NUMERIC_VARIABLE' IN TYPEOF(v) THEN RETURN (('ISO13584_G_M_IIM_SCHEMA.REAL_COLUMN' IN TYPEOF (col)) OR (('ISO13584_G_M_IIM_SCHEMA.NUMBER_COLUMN' IN TYPEOF (col)) AND NOT ('ISO13584_G_M_IIM_SCHEMA.INTEGER_COLUMN' IN TYPEOF (col)))); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.BOOLEAN_VARIABLE' IN TYPEOF(v) THEN RETURN ('ISO13584_G_M_IIM_SCHEMA.BOOLEAN_COLUMN' IN TYPEOF (col)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.STRING_VARIABLE' IN TYPEOF(v) THEN RETURN ('ISO13584_G_M_IIM_SCHEMA.STRING_COLUMN' IN TYPEOF (col)); END_IF; (* The following express statements deal with complex types *) IF 'ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_VARIABLE' IN TYPEOF(v) THEN RETURN (('ISO13584_G_M_IIM_SCHEMA.ENTITY_INSTANCE_COLUMN' IN TYPEOF (col)) AND (v\ENTITY_INSTANCE_VARIABLE.type_name <= col\ENTITY_INSTANCE_COLUMN.type_name)); END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_VARIABLE' IN TYPEOF(v) THEN IF ('ISO13584_G_M_IIM_SCHEMA.CLASS_INSTANCE_COLUMN' IN TYPEOF (col)) THEN RETURN (COMPATIBLE_CLASS_AND_CLASS (v\CLASS_INSTANCE_EXPRESSION.expr_type, col\CLASS_INSTANCE_COLUMN.class_ref)); ELSE RETURN(FALSE); END_IF; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_VARIABLE' IN TYPEOF(v) THEN IF ('ISO13584_G_M_IIM_SCHEMA.LEVEL_SPEC_COLUMN' IN TYPEOF (col)) THEN IF LIST_TO_SET(v\LEVEL_SPEC_VARIABLE.levels) = LIST_TO_SET(col\LEVEL_SPEC_COLUMN.levels) THEN IF (('ISO13584_G_M_IIM_SCHEMA' +'.INT_LEVEL_SPEC_VARIABLE' IN TYPEOF(v)) AND NOT('ISO13584_G_M_IIM_SCHEMA'+ '.INT_LEVEL_SPEC_COLUMN' IN TYPEOF(col))) THEN RETURN (FALSE); END_IF; IF (('ISO13584_G_M_IIM_SCHEMA' +'.REAL_LEVEL_SPEC_VARIABLE' IN TYPEOF(v)) AND NOT('ISO13584_G_M_IIM_SCHEMA'+ '.REAL_LEVEL_SPEC_COLUMN' IN TYPEOF(col))) THEN RETURN (FALSE); END_IF; RETURN (TRUE); ELSE RETURN (FALSE); END_IF; ELSE RETURN (FALSE); END_IF; END_IF; RETURN (FALSE); END_FUNCTION; -- compatible_column_and_variable
FUNCTION retrieve_provided_properties (cl: CLASS_BSU; pr: LIST OF PROPERTY_BSU) : LIST OF PROPERTY_BSU; LOCAL i: INTEGER; prop: LIST OF PROPERTY_BSU := pr; --end of the list END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties defined at this -- level THEN REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derived_properties) TO 1 BY -1; prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derived_properties[i].property+prop; END_REPEAT; -- derived properties of this class REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.required_properties) TO 1 BY -1; prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.required_properties[i].property + prop; -- required properties of this class END_REPEAT; REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties) TO 1 BY -1; prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties[i].property + prop; -- selectable properties of this class END_REPEAT; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_PROVIDED_PROPERTIES( cl.definition[1]\CLASS.its_superclass,prop)); END_IF; END_FUNCTION; -- retrieve_provided_properties
FUNCTION selectable_defined_properties (cl: CLASS_BSU) : LIST OF PROPERTY_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT (ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_SELECTABLE_PROPERTIES(cl, [])); END_IF; END_FUNCTION; -- selectable_defined_properties
FUNCTION optional_defined_properties (cl: CLASS_BSU) : LIST OF PROPERTY_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT (ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_OPTIONAL_PROPERTIES(cl, [])); END_IF; END_FUNCTION; -- optional_defined_properties
FUNCTION mandatory_redefined_properties (cl: CLASS_BSU) : SET OF PROPERTY_BSU; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT(ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_MANDATORY_REDEFINED_PROPERTIES(cl, [])); END_IF; END_FUNCTION; -- mandatory_redefined_properties
FUNCTION retrieve_tables (cl: CLASS_BSU): SET[0:?] OF TABLE_BSU; -- requires: { SIZEOF (cl.definition) <> O } LOCAL i: INTEGER; s: SET[0:?] OF TABLE_BSU; END_LOCAL; s := []; REPEAT i:= 1 TO SIZEOF(cl.definition[1]\CLASS.associated_items); IF 'ISO13584_G_M_IIM_SCHEMA' +'.CLASS_TABLE_RELATIONSHIP' IN TYPEOF(cl.definition[1]\CLASS.associated_items[i]) THEN s := s + cl.definition[1]\CLASS.associated_items[i] \CLASS_TABLE_RELATIONSHIP.related_tokens; END_IF; END_REPEAT; RETURN(s); END_FUNCTION; -- retrieve_tables
FUNCTION retrieve_documents (cl: CLASS_BSU): SET[0:?] OF DOCUMENT_BSU; -- requires: { SIZEOF (cl.definition) <> O } LOCAL i: INTEGER; s: SET[0:?] OF DOCUMENT_BSU; END_LOCAL; s := []; REPEAT i := 1 TO SIZEOF(cl.definition[1]\CLASS.associated_items); IF 'ISO13584_G_M_IIM_SCHEMA'+ '.CLASS_DOCUMENT_RELATIONSHIP' IN TYPEOF(cl.definition[1]\CLASS.associated_items[i]) THEN s := s+ cl.definition[1]\CLASS.associated_items[i] \CLASS_DOCUMENT_RELATIONSHIP.related_tokens; END_IF; END_REPEAT; RETURN(s); END_FUNCTION; -- retrieve_documents
FUNCTION defined_domain (cl: CLASS_BSU): SET OF DOMAIN_RESTRICTION; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF NOT (ALL_CLASS_DESCRIPTIONS_REACHABLE(cl)) THEN RETURN ([]); -- some dictionary_element are not available ELSE RETURN (RETRIEVE_DOMAIN(cl, [])); END_IF; END_FUNCTION; -- defined_domain
FUNCTION acyclic_order(p : PROPERTY_BSU;edges : SET OF DOMAIN_RESTRICTION; nodes : SET OF PROPERTY_BSU) : BOOLEAN; LOCAL succ : SET OF PROPERTY_BSU; -- set of property_BSU that depends (recursively) on p out_edges : SET OF DOMAIN_RESTRICTION; -- set of domain_restrictions that contain one of the -- property_BSU of the set nodes in the the_property attribute -- of one of their assumes variable_semantics i,j : INTEGER; END_LOCAL; out_edges := QUERY(e <* edges | (QUERY(v <* e.assumes | v\PROPERTY_SEMANTICS. the_property IN nodes) <> [])); succ := []; REPEAT i := LOBOUND(out_edges) TO HIBOUND(out_edges); REPEAT j := LOBOUND(out_edges[i].defines) TO HIBOUND(out_edges[i].defines); succ := succ + out_edges[i].defines[j]\PROPERTY_SEMANTICS.the_property; END_REPEAT; END_REPEAT; -- p depends on itself: IF p IN succ THEN RETURN (FALSE); END_IF; -- all the depending properties are reached IF succ <= nodes THEN RETURN (TRUE); END_IF; RETURN (ACYCLIC_ORDER(p,edges,nodes + succ)); END_FUNCTION;
-- acyclic_order FUNCTION retrieve_derivation_function (cl: CLASS_BSU; d: SET OF FUNCTIONAL_DOMAIN_RESTRICTION) : SET OF FUNCTIONAL_DOMAIN_RESTRICTION; LOCAL i: INTEGER; der: SET OF FUNCTIONAL_DOMAIN_RESTRICTION := d; -- existing set END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition)=0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new derivation_function defined at -- this level THEN REPEAT i := 1 TO SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derivation); der := der + cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derivation[i]; -- derivation_function of this class END_REPEAT; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (der); ELSE RETURN (RETRIEVE_DERIVATION_FUNCTION( cl.definition[1]\CLASS.its_superclass, der)); END_IF; END_FUNCTION; -- retrieve_derivation_function
FUNCTION scalar_times_vector(scalar : REAL;vec : VECTOR_OR_DIRECTION) : VECTOR ; LOCAL v : DIRECTION; mag : REAL; result : VECTOR; END_LOCAL; IF NOT EXISTS(scalar) OR NOT EXISTS(vec) THEN result := ?; ELSE IF 'ISO13584_G_M_IIM_SCHEMA.VECTOR' IN TYPEOF(vec) THEN v := vec.orientation; mag := scalar * vec.magnitude; ELSE v := vec; mag := scalar; END_IF; IF (mag < 0.0) THEN REPEAT i := 1 TO SIZEOF(v.direction_ratios); v.direction_ratios[i] := - v.direction_ratios[i]; END_REPEAT; mag := - mag; END_IF; result.orientation := NORMALISE(v); result.magnitude := mag; END_IF; RETURN (result); END_FUNCTION;
FUNCTION dot_product(arg1,arg2 : DIRECTION) : REAL; LOCAL scalar : REAL; vec1,vec2 : DIRECTION; ndim : INTEGER; END_LOCAL; IF NOT EXISTS(arg1) OR NOT EXISTS(arg2) THEN scalar := ?; ELSE IF (arg1.dim <> arg2.dim) THEN scalar := ?; ELSE BEGIN vec1 := NORMALISE(arg1); vec2 := NORMALISE(arg2); ndim := arg1.dim; scalar := 0.0; REPEAT i := 1 TO ndim; scalar := scalar + vec1.direction_ratios[i] * vec2.direction_ratios[i]; END_REPEAT; END; END_IF; END_IF; RETURN (scalar); END_FUNCTION;
FUNCTION vector_difference(arg1,arg2 : VECTOR_OR_DIRECTION) : VECTOR; LOCAL result : VECTOR; res,vec1,vec2 : DIRECTION; mag,mag1,mag2 : REAL; ndim : INTEGER; END_LOCAL; IF ((NOT EXISTS(arg1)) OR (NOT EXISTS(arg2))) OR (arg1.dim <> arg2.dim) THEN result := ?; ELSE BEGIN IF 'ISO13584_G_M_IIM_SCHEMA.VECTOR' IN TYPEOF(arg1) THEN mag1 := arg1.magnitude; vec1 := arg1.orientation; ELSE mag1 := 1.0; vec1 := arg1; END_IF; IF 'ISO13584_G_M_IIM_SCHEMA.VECTOR' IN TYPEOF(arg2) THEN mag2 := arg2.magnitude; vec2 := arg2.orientation; ELSE mag2 := 1.0; vec2 := arg2; END_IF; vec1 := NORMALISE(vec1); vec2 := NORMALISE(vec2); ndim := SIZEOF(vec1.direction_ratios); mag := 0.0; REPEAT i := 1 TO ndim; res.direction_ratios[i] := mag1 * vec1.direction_ratios[i] - mag2 * vec2. direction_ratios[i]; mag := mag + (res.direction_ratios[i] * res.direction_ratios[i]); END_REPEAT; IF (mag > 0.0) THEN result.magnitude := SQRT(mag); result.orientation := res; ELSE result.magnitude := 0.0; result.orientation := vec1; END_IF; END; END_IF; RETURN (result); END_FUNCTION;
FUNCTION no_extension_for_superclass ( cl : CLASS_EXTENSION) : LOGICAL; IF SIZEOF ( cl\CONTENT_ITEM.dictionary_definition.definition) = 0 THEN RETURN (UNKNOWN); END_IF; RETURN ( cl\CONTENT_ITEM.dictionary_definition.definition[1] \CLASS.subclasses=[]); END_FUNCTION; -- no_extension_for_superclass
FUNCTION retrieve_gm_free_characteristics (cl: CLASS_BSU; pr: LIST OF PROPERTY_BSU) : LIST OF PROPERTY_BSU; LOCAL i: INTEGER; prop: LIST OF PROPERTY_BSU := pr; --end of the list END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties defined at this -- level THEN IF NOT ('ISO13584_G_M_IIM_SCHEMA.ITEM_CLASS_EXTENSION' IN TYPEOF(cl.referenced_by[1])) -- anormal case THEN RETURN([]); -- anormal case END_IF; REPEAT i := SIZEOF (cl.referenced_by[1] \ITEM_CLASS_EXTENSION.free_characteristics) TO 1 BY -1; prop := cl.referenced_by[1] \ITEM_CLASS_EXTENSION.free_characteristics[i].property + prop; -- free characteristics of this class END_REPEAT; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_GM_FREE_CHARACTERISTICS( cl.definition[1]\CLASS.its_superclass, prop)); END_IF; END_FUNCTION; -- retrieve_gm_free_characteristics
FUNCTION retrieve_derived_redefined_properties (cl: CLASS_BSU; pr:SET OF PROPERTY_BSU) : SET OF PROPERTY_BSU; LOCAL prop: SET OF PROPERTY_BSU := pr; -- already computed set END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties redefined at -- this level THEN prop := prop + cl.referenced_by[1] \MODEL_CLASS_EXTENSION.new_derived_prop; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_DERIVED_REDEFINED_PROPERTIES( cl.definition[1]\CLASS.its_superclass, prop)); END_IF; END_FUNCTION; -- retrieve_derived_redefined_properties
FUNCTION retrieve_selectable_properties (cl: CLASS_BSU; pr: LIST OF PROPERTY_BSU) : LIST OF PROPERTY_BSU; LOCAL i: INTEGER; prop: LIST OF PROPERTY_BSU := pr; -- end of the list END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties defined at this --level THEN REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties) TO 1 BY -1; prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties[i].property + prop; -- selectable properties of this class END_REPEAT; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_SELECTABLE_PROPERTIES( cl.definition[1]\CLASS.its_superclass, prop)); END_IF; END_FUNCTION; -- retrieve_selectable_properties
FUNCTION retrieve_optional_properties (cl: CLASS_BSU; pr: LIST OF PROPERTY_BSU) : LIST OF PROPERTY_BSU; LOCAL i: INTEGER; prop: LIST OF PROPERTY_BSU := pr; -- end of the list END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties defined at this -- level THEN REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derived_properties) TO 1 BY -1; IF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derived_properties[i].is_optional) THEN prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.derived_properties[i].property + prop; END_IF; END_REPEAT; -- derived optional properties of this class REPEAT i := SIZEOF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties) TO 1 BY - 1; IF (cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties[i].is_optional) THEN prop := cl.referenced_by[1] \MODEL_CLASS_EXTENSION.selectable_properties[i].property + prop; --selectable optional properties END_IF; END_REPEAT; END_IF; IF NOT (EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_OPTIONAL_PROPERTIES( cl.definition[1]\CLASS.its_superclass,prop)); END_IF; END_FUNCTION; -- retrieve_optional_properties
FUNCTION retrieve_mandatory_redefined_properties ( cl: CLASS_BSU; pr: SET OF PROPERTY_BSU) : SET OF PROPERTY_BSU; LOCAL prop: SET OF PROPERTY_BSU := pr; --already computed set END_LOCAL; IF NOT EXISTS(cl) THEN RETURN ([]); -- the class itself is indeterminate END_IF; IF SIZEOF(cl.definition) = 0 -- anormal case THEN RETURN([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 -- new properties redefined at this --level THEN prop := prop + cl.referenced_by[1] \MODEL_CLASS_EXTENSION.new_mandatory_prop; END_IF; IF NOT(EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (prop); ELSE RETURN (RETRIEVE_MANDATORY_REDEFINED_PROPERTIES( cl.definition[1]\CLASS.its_superclass, prop)); END_IF; END_FUNCTION; -- retrieve_mandatory_redefined_properties
FUNCTION retrieve_domain(cl : CLASS_BSU;d : SET OF DOMAIN_RESTRICTION) : SET OF DOMAIN_RESTRICTION; LOCAL i : INTEGER; dom : SET OF DOMAIN_RESTRICTION := d; -- existing set END_LOCAL; IF SIZEOF(cl.definition) = 0 THEN RETURN ([]); END_IF; IF SIZEOF(cl.referenced_by) = 1 THEN REPEAT i := 1 TO SIZEOF(cl.referenced_by[1]\MODEL_CLASS_EXTENSION. CLASS_EXTENSION); dom := dom + cl.referenced_by[1]\MODEL_CLASS_EXTENSION.CLASS_EXTENSION[i]; -- domain of this class END_REPEAT; END_IF; IF NOT (EXISTS(cl.definition[1]\CLASS.its_superclass)) THEN RETURN (dom); ELSE RETURN (RETRIEVE_DOMAIN(cl.definition[1]\CLASS.its_superclass,dom)); END_IF; END_FUNCTION;
-- retrieve_domain FUNCTION sub_list_until(cla: LIST [1:?] OF CLASS_BSU; cl: CLASS_BSU): LIST [1:?] OF CLASS_BSU; LOCAL k: INTEGER := 1; c: LIST [0:?] OF CLASS_BSU := []; END_LOCAL; REPEAT k := 1 TO SIZEOF(cla); c := c + cla[k]; IF cla[k] = cl THEN ESCAPE; END_IF; END_REPEAT; RETURN(c); END_FUNCTION; -- sub_list_until
FUNCTION item_in_context(item : REPRESENTATION_ITEM;cntxt : REPRESENTATION_CONTEXT) : BOOLEAN; LOCAL i : INTEGER; y : BAG OF REPRESENTATION_ITEM; END_LOCAL; -- If there is one or more representation using both the item -- and cntxt return true. IF SIZEOF(USEDIN(item,'ISO13584_G_M_IIM_SCHEMA.REPRESENTATION.ITEMS') * cntxt.representations_in_context) > 0 THEN RETURN (TRUE); -- Determine the bag of representation_items that reference -- item. ELSE y := QUERY(z <* USEDIN(item,'') | 'ISO13584_G_M_IIM_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(z)); -- Ensure that the set is not empty. IF SIZEOF(y) > 0 THEN REPEAT i := 1 TO HIINDEX(y); IF ITEM_IN_CONTEXT(y[i],cntxt) THEN RETURN (TRUE); END_IF; END_REPEAT; END_IF; END_IF; -- Return false when all possible branches have been checked -- with no success. RETURN (FALSE); END_FUNCTION;
RULE single_language_assignment FOR (GLOBAL_LANGUAGE_ASSIGNMENT); WHERE SIZEOF(GLOBAL_LANGUAGE_ASSIGNMENT) <= 1; END_RULE;
RULE no_forward_reference_from_table_rule FOR (DICTIONARY,TABLE_ELEMENT); WHERE wr1 : QUERY(dic <* DICTIONARY | QUERY(tab <* TABLE_ELEMENT | MAKES_REFERENCE_OUTSIDE(GET_PROPERTY_BSU_FROM_PROPERTY_SEMANTICS(tab\ TABLE_SPECIFICATION.column_meaning),SUB_LIST_UNTIL(dic. contained_classes,tab\TABLE_SPECIFICATION.table_identifier\TABLE_BSU. name_scope))) <> []) = []; END_RULE;
-- no_forward_reference_from_table_rule RULE assert_oneof_for_table FOR (TABLE_ELEMENT); WHERE wr1 : QUERY(temp <* TABLE_ELEMENT | NOT ( 'ISO13584_G_M_IIM_SCHEMA.RDB_TABLE_ELEMENT' IN TYPEOF (temp)) AND ('ISO13584_G_M_IIM_SCHEMA.RDB_TABLE_SPECIFICATION' IN TYPEOF(temp))) = []; END_RULE;
-- assert_oneof_for_table RULE assert_oneof_for_library FOR (LIBRARY); WHERE wr1 : QUERY(temp <* LIBRARY | NOT ('ISO13584_G_M_IIM_SCHEMA.LIBRARY_IN_STANDARD_FORMAT' IN TYPEOF(temp)) AND ( 'ISO13584_G_M_IIM_SCHEMA.DICTIONARY_IN_STANDARD_FORMAT' IN TYPEOF(temp))) = []; END_RULE;
-- assert_oneof_for_library RULE unique_http_directory_name_per_supplier_rule FOR (HTTP_CLASS_DIRECTORY); WHERE wr1 : QUERY(dir_1 <* HTTP_CLASS_DIRECTORY | QUERY(dir_2 <* HTTP_CLASS_DIRECTORY | (dir_1.name = dir_2.name) AND (dir_1.CLASS. defined_by = dir_2.CLASS.defined_by)) <> [dir_1]) = []; END_RULE;
-- unique_http_directory_name_per_supplier_rule RULE http_directory_refers_to_bsu_related_class_rule FOR (HTTP_FILE, CLASS_BSU_RELATED_CONTENT); WHERE wr1 : QUERY(http_f <* HTTP_FILE | (( 'ISO13584_G_M_IIM_SCHEMA.CLASS_BSU_RELATED_CONTENT' IN TYPEOF( http_f\EXTERNAL_FILE_UNIT.unit_of.content_of.content_of)) AND (http_f. http_directory.CLASS <> http_f\EXTERNAL_FILE_UNIT.unit_of.content_of. content_of\CONTENT_ITEM.dictionary_definition))) = []; END_RULE;
-- http_directory_refers_to_bsu_related_class_rule RULE http_directory_refers_to_class_extension_rule FOR (HTTP_FILE, CLASS_EXTENSION_EXTERNAL_ITEM); WHERE wr1 : QUERY(http_f <* HTTP_FILE | ( 'ISO13584_G_M_IIM_SCHEMA.CLASS_EXTENSION_EXTERNAL_ITEM' IN TYPEOF (http_f\EXTERNAL_FILE_UNIT.unit_of.content_of.content_of)) AND (http_f .http_directory.CLASS <> http_f\EXTERNAL_FILE_UNIT.unit_of.content_of. content_of\CLASS_EXTENSION_EXTERNAL_ITEM.belongs_to\CONTENT_ITEM. dictionary_definition)) = []; END_RULE;
-- http_directory_refers_to_class_extension_rule RULE unambiguous_not_translated_content_rule FOR ( NOT_TRANSLATED_EXTERNAL_CONTENT,GLOBAL_LANGUAGE_ASSIGNMENT); WHERE wr1 : (SIZEOF(NOT_TRANSLATED_EXTERNAL_CONTENT) = 0) OR (SIZEOF( GLOBAL_LANGUAGE_ASSIGNMENT) = 1); END_RULE;
-- unambiguous_not_translated_content_rule RULE compatible_dimension FOR (CARTESIAN_POINT,DIRECTION, REPRESENTATION_CONTEXT, GEOMETRIC_REPRESENTATION_CONTEXT); WHERE wr1 : SIZEOF(QUERY(x <* CARTESIAN_POINT | SIZEOF(QUERY(y <* GEOMETRIC_REPRESENTATION_CONTEXT | ITEM_IN_CONTEXT(x,y) AND (HIINDEX(x .coordinates) <> y.coordinate_space_dimension))) > 0)) = 0; wr2 : SIZEOF(QUERY(x <* DIRECTION | SIZEOF(QUERY(y <* GEOMETRIC_REPRESENTATION_CONTEXT | ITEM_IN_CONTEXT(x,y) AND (HIINDEX(x .direction_ratios) <> y.coordinate_space_dimension))) > 0)) = 0; END_RULE;
-- compatible_dimension RULE no_content_without_DET_rule FOR (BASIC_SEMANTIC_UNIT); WHERE wr1 : QUERY (bsu <* BASIC_SEMANTIC_UNIT |(SIZEOF (bsu.referenced_by) = 1) AND (SIZEOF (bsu.definition) = 0)) = []; END_RULE;
-- no_content_without_DET_rule RULE illustration_is_not_a_referenced_graphics_rule FOR (GRAPHICS ); WHERE WR1: QUERY (icon <* GRAPHICS| ('ISO13584_G_M_IIM_SCHEMA.REFERENCED_GRAPHICS' IN TYPEOF( icon)) AND ('ISO13584_G_M_IIM_SCHEMA.ILLUSTRATION' IN TYPEOF( icon))) = []; END_RULE; -- illustration_is_not_a_referenced_graphics_rule END_SCHEMA; -- iso13584_g_m_iim_schema
