AP scope  |  AP module  |  AP contents  |  AP index
Application module: State based behaviour ISO/WD 10303-1371

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviations

4 Information requirements
   4.1 Required AM ARMs
   4.2 ARM type definitions
5 Module interpreted model
   5.1 Mapping specification
   5.2 MIM EXPRESS short listing
     5.2.1 MIM type definitions
     5.2.2 MIM entity definitions
6 Module reference data

A MIM short names
B Information object registration
C ARM EXPRESS-G   EXPRESS-G
D MIM EXPRESS-G   EXPRESS-G
E Computer interpretable listings
Bibliography
Index

(*
ISO TC184/SC4/WG3 N2103 - ISO/WD 10303-1371 State based behaviour - EXPRESS ARM Long form
*)



SCHEMA State_based_behaviour_arm_LF;


TYPE any_number_value = NUMBER;
END_TYPE;

TYPE any_string_value = STRING;
END_TYPE;

TYPE assigned_name_select = SELECT
   (External_class_library);
END_TYPE;

TYPE behaviour_item = SELECT
   (Behaviour_view_definition);
END_TYPE;

TYPE behaviour_model = SELECT
   (State_based_behaviour_model);
END_TYPE;

TYPE classification_item = SELECT
   (Activity_method,
    Applied_state_definition_assignment,
    Behaviour,
    Behaviour_view_definition,
    Condition,
    Condition_assignment,
    Condition_parameter,
    Condition_relationship,
    Constrained_general_parameter_relationship,
    Description_text,
    Description_text_assignment,
    External_source_identification,
    File,
    General_model_parameter,
    Parameter_value_representation_item,
    Product,
    Product_version,
    Product_view_definition,
    Representation,
    Representation_context,
    State_based_behaviour_model,
    State_definition,
    State_definition_relationship,
    Text_based_representation);
END_TYPE;

TYPE condition_item = SELECT
   (State_transition_definition);
END_TYPE;

TYPE condition_parameter_item = SELECT
   (Condition_relationship,
    parameter_value_select);
END_TYPE;

TYPE description_item = SELECT
   (Activity_method,
    Behaviour,
    Behaviour_version,
    Behaviour_view_definition,
    Condition,
    General_model_parameter,
    Product,
    Product_version,
    Product_view_definition,
    Representation,
    State_based_behaviour_model,
    State_definition,
    State_definition_relationship);
END_TYPE;

TYPE expression_assignment_item = SELECT
   (Condition);
END_TYPE;

TYPE external_identification_item = SELECT
   (File);
END_TYPE;

TYPE identification_item = SELECT
   (Activity_method,
    Behaviour,
    Behaviour_version,
    Behaviour_view_definition,
    Condition,
    Description_text_assignment,
    External_source_identification,
    File,
    General_model_parameter,
    Product,
    Product_version,
    Product_view_definition,
    Representation,
    State_based_behaviour_model,
    State_definition,
    State_transition_definition);
END_TYPE;

TYPE length_measure = REAL;
END_TYPE;

TYPE list_of_text_based_item = LIST[1:?] OF Textual_expression_representation_item;
END_TYPE;

TYPE list_or_set_of_text_based_item = SELECT
   (list_of_text_based_item,
    set_of_text_based_item);
END_TYPE;

TYPE measure_value = SELECT
   (any_number_value,
    any_string_value,
    length_measure,
    plane_angle_measure);
END_TYPE;

TYPE parameter_value_select = SELECT
   (Generic_expression,
    Product_view_definition,
    Value_with_unit);
END_TYPE;

TYPE plane_angle_measure = REAL;
END_TYPE;

TYPE property_assignment_select = SELECT
   (Activity_method,
    Behaviour_view_definition,
    Product_view_definition);
END_TYPE;

TYPE represented_definition = SELECT
   (Assigned_property,
    Independent_property);
END_TYPE;

TYPE set_of_text_based_item = SET[1:?] OF Textual_expression_representation_item;
END_TYPE;

TYPE state_based_behaviour_element = SELECT
   (State_definition,
    State_definition_relationship);
END_TYPE;

TYPE state_definition_of_item = SELECT
   (Product_view_definition);
END_TYPE;

TYPE text_based_item_select = SELECT
   (Included_text_based_representation,
    Textual_expression_composition,
    Textual_expression_representation_item);
END_TYPE;

ENTITY Abs_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Acos_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Activity_method;
  name : STRING;
  description : OPTIONAL STRING;
  consequence : OPTIONAL STRING;
  purpose : STRING;
END_ENTITY;

ENTITY Alias_identification
  SUBTYPE OF (Identification_assignment);
DERIVE
  SELF\Identification_assignment.role : STRING := 'alias';
WHERE
  WR1: SIZEOF (QUERY(item <* SELF\Identification_assignment.items | NOT ('STATE_BASED_BEHAVIOUR_ARM_LF.ALIAS_IDENTIFICATION_ITEM' IN TYPEOF(item)))) = 0;
END_ENTITY;

ENTITY Amount_of_substance_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY And_expression
  SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;

ENTITY Applied_independent_property
  SUBTYPE OF (Assigned_property);
  base_independent_property : Independent_property;
DERIVE
  SELF\Assigned_property.name : STRING := base_independent_property.property_type;
END_ENTITY;

ENTITY Applied_state_definition_assignment;
  assigned_to : state_definition_of_item;
  described_state_definition : State_definition;
  role : State_definition_role;
END_ENTITY;

ENTITY Asin_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Assigned_property;
  id : OPTIONAL STRING;
  name : STRING;
  description : OPTIONAL STRING;
  described_element : property_assignment_select;
END_ENTITY;

ENTITY Atan_function
  SUBTYPE OF (Binary_function_call);
END_ENTITY;

ENTITY Behaviour
  SUBTYPE OF (Product);
END_ENTITY;

ENTITY Behaviour_description_association;
  description : OPTIONAL STRING;
  representation : behaviour_model;
  represented_item : behaviour_item;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Behaviour_version
  SUBTYPE OF (Product_version);
  SELF\Product_version.of_product : Behaviour;
END_ENTITY;

ENTITY Behaviour_version_sequence
  SUBTYPE OF (Product_version_relationship);
  SELF\Product_version_relationship.relating_version : Behaviour_version;
  SELF\Product_version_relationship.related_version : Behaviour_version;
DERIVE
  predecessor : BEHAVIOUR_VERSION := SELF\Product_version_relationship.relating_version;
  successor : BEHAVIOUR_VERSION := SELF\Product_version_relationship.related_version;
END_ENTITY;

ENTITY Behaviour_view_definition
  SUBTYPE OF (Product_view_definition);
  SELF\Product_view_definition.defined_version : Behaviour_version;
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_function_call
  ABSTRACT SUPERTYPE OF (ATAN_FUNCTION)
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Binary_generic_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Generic_expression);
  operands : LIST[2: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 Boolean_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Defined_function, Boolean_expression);
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 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 Class
  SUPERTYPE OF (ONEOF (CLASS_BY_EXTENSION,
                       CLASS_BY_INTENSION));
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Class_by_extension
  SUBTYPE OF (Class);
END_ENTITY;

ENTITY Class_by_intension
  SUBTYPE OF (Class);
END_ENTITY;

ENTITY Classification_assignment;
  assigned_class : Class;
  items : SET[1:?] OF classification_item;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Comparison_equal
  SUBTYPE OF (Comparison_expression);
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: (('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR(('BOOLEAN_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND('BOOLEAN_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR(('STRING_EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND('STRING_EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2])));
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 Composition_of_state_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  part : SET[1:?] OF STATE_DEFINITION := SELF\State_definition_relationship.related;
  whole : SET[1:?] OF STATE_DEFINITION := SELF\State_definition_relationship.relating;
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 Condition;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Condition_assignment;
  assigned_condition : Condition;
  item : condition_item;
END_ENTITY;

ENTITY Condition_parameter;
  name : STRING;
  description : OPTIONAL STRING;
  condition : Condition;
  parameter : OPTIONAL condition_parameter_item;
END_ENTITY;

ENTITY Condition_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  relating_condition : Condition;
  related_condition : Condition;
END_ENTITY;

ENTITY Constrained_general_parameter_relationship
  SUBTYPE OF (Independent_property_relationship);
  SELF\Independent_property_relationship.relating : General_model_parameter;
  SELF\Independent_property_relationship.related : General_model_parameter;
  required_class : Class;
WHERE
  WR1: (required_class.id IN CLASSOF(related)) AND (required_class.id IN CLASSOF(relating));
END_ENTITY;

ENTITY Context_dependent_unit
  SUBTYPE OF (Unit);
WHERE
  WR1: EXISTS(SELF\Unit.name);
END_ENTITY;

ENTITY Conversion_based_unit
  SUBTYPE OF (Unit);
  conversion_factor : Value_with_unit;
WHERE
  WR1: EXISTS(SELF\Unit.name);
END_ENTITY;

ENTITY Cos_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Defined_function
  ABSTRACT SUPERTYPE ;
END_ENTITY;

ENTITY Derived_unit
  SUBTYPE OF (Unit);
  elements : SET[1:?] OF Derived_unit_element;
END_ENTITY;

ENTITY Derived_unit_element;
  base_unit : Unit;
  exponent : REAL;
END_ENTITY;

ENTITY Description_text;
  description : STRING;
END_ENTITY;

ENTITY Description_text_assignment;
  description : Description_text;
  items : SET[1:?] OF description_item;
END_ENTITY;

ENTITY Digital_file
  SUBTYPE OF (File);
END_ENTITY;

ENTITY Div_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Duration
  SUBTYPE OF (Value_with_unit);
WHERE
  WR1: 'STATE_BASED_BEHAVIOUR_ARM_LF.' + 'TIME_UNIT' IN TYPEOF(SELF\Value_with_unit.unit);
END_ENTITY;

ENTITY Electric_current_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Environment;
  syntactic_representation : Generic_variable;
  semantics : Variable_semantics;
END_ENTITY;

ENTITY Equals_expression
  SUBTYPE OF (Binary_boolean_expression);
END_ENTITY;

ENTITY Exp_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Expression
  ABSTRACT SUPERTYPE OF (ONEOF (NUMERIC_EXPRESSION,
                                BOOLEAN_EXPRESSION,
                                STRING_EXPRESSION))
  SUBTYPE OF (Generic_expression);
END_ENTITY;

ENTITY Expression_assignment;
  expression : Expression;
  item : expression_assignment_item;
END_ENTITY;

ENTITY External_class
  SUBTYPE OF (Class);
  external_source : External_class_library;
END_ENTITY;

ENTITY External_class_library;
  id : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY External_item_identification
  SUBTYPE OF (External_source_identification);
  external_id : STRING;
END_ENTITY;

ENTITY External_source_identification;
  source_id : STRING;
  source_type : STRING;
  item : external_identification_item;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY External_state_based_behaviour_model
  SUBTYPE OF (State_based_behaviour_model);
  external_file : Digital_file;
END_ENTITY;

ENTITY File
  ABSTRACT SUPERTYPE OF (ONEOF (DIGITAL_FILE,
                                HARDCOPY));
  id : STRING;
  version : OPTIONAL STRING;
  contained_data_type : OPTIONAL STRING;
END_ENTITY;

ENTITY File_location_identification
  SUBTYPE OF (External_item_identification);
WHERE
  WR1: 'STATE_BASED_BEHAVIOUR_ARM_LF.FILE' IN TYPEOF(SELF\External_source_identification.item);
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: (('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION') IN TYPEOF(value_to_format)) AND (('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION') IN TYPEOF(format_string));
END_ENTITY;

ENTITY General_model_parameter
  SUBTYPE OF (Independent_property);
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 Generic_literal
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Simple_generic_expression);
END_ENTITY;

ENTITY Generic_variable
  ABSTRACT SUPERTYPE OF (VARIABLE)
  SUBTYPE OF (Simple_generic_expression);
INVERSE
  interpretation : Environment FOR syntactic_representation;
END_ENTITY;

ENTITY Hardcopy
  SUBTYPE OF (File);
END_ENTITY;

ENTITY Identification_assignment;
  identifier : STRING;
  role : STRING;
  description : OPTIONAL STRING;
  items : SET[1:?] OF identification_item;
END_ENTITY;

ENTITY Included_text_based_representation
  SUBTYPE OF (Representation_item);
  source : Text_based_representation;
END_ENTITY;

ENTITY Independent_property;
  id : STRING;
  property_type : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Independent_property_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating : Independent_property;
  related : Independent_property;
END_ENTITY;

ENTITY Independent_property_representation
  SUBTYPE OF (Property_definition_representation);
  SELF\Property_definition_representation.definition : Independent_property;
DERIVE
  property : INDEPENDENT_PROPERTY := SELF\Property_definition_representation.definition;
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: ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION' IN TYPEOF(index));
  WR2: is_int_expr (index);
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 Integer_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Numeric_defined_function);
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: ('STATE_BASED_BEHAVIOUR_ARM_LF.EXPRESSION' IN TYPEOF(interval_low)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.EXPRESSION' IN TYPEOF(interval_item)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.EXPRESSION' IN TYPEOF(interval_high));
  WR2: (('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_low)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_high)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_item))) OR(('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF.Interval_low)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_item)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_high)));
END_ENTITY;

ENTITY Length_function
  SUBTYPE OF (Numeric_expression, Unary_generic_expression);
  SELF\Unary_generic_expression.operand : String_expression;
END_ENTITY;

ENTITY Length_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Like_expression
  SUBTYPE OF (Comparison_expression);
WHERE
  WR1: ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF\Comparison_expression.operands[1])) AND('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF\Comparison_expression.operands[2]));
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 Log10_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Log2_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Log_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Luminous_intensity_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Mass_unit
  SUBTYPE OF (Unit);
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 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 Multiple_arity_function_call
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;

ENTITY Multiple_arity_generic_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Generic_expression);
  operands : LIST[2:?] OF Generic_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 Name_assignment;
  name : STRING;
  role : STRING;
  items : assigned_name_select;
END_ENTITY;

ENTITY Named_variable_semantics
  SUBTYPE OF (Variable_semantics);
  name : STRING;
  variable_context : Generic_expression;
END_ENTITY;

ENTITY Not_expression
  SUBTYPE OF (Unary_boolean_expression);
  SELF\Unary_generic_expression.operand : Boolean_expression;
END_ENTITY;

ENTITY Numeric_defined_function
  ABSTRACT SUPERTYPE OF (ONEOF (INTEGER_DEFINED_FUNCTION,
                                REAL_DEFINED_FUNCTION))
  SUBTYPE OF (Numeric_expression, Defined_function);
END_ENTITY;

ENTITY Numeric_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Expression);
DERIVE
  is_int : BOOLEAN := Is_int_expr (SELF);
  sql_mappable : BOOLEAN := Is_sql_mappable (SELF);
END_ENTITY;

ENTITY Numeric_variable
  SUPERTYPE OF (ONEOF (INT_NUMERIC_VARIABLE,
                       REAL_NUMERIC_VARIABLE))
  SUBTYPE OF (Simple_numeric_expression, Variable);
WHERE
  WR1: ('STATE_BASED_BEHAVIOUR_ARM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(SELF)) OR('STATE_BASED_BEHAVIOUR_ARM_LF.REAL_NUMERIC_VARIABLE' IN TYPEOF(SELF));
END_ENTITY;

ENTITY Numerical_representation_context
  SUBTYPE OF (Representation_context);
  units : OPTIONAL SET[1:?] OF Unit;
  accuracies : OPTIONAL SET[1:?] OF Uncertainty_with_unit;
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 Parameter_value_representation_item
  SUBTYPE OF (Representation_item);
  parameter_value : parameter_value_select;
END_ENTITY;

ENTITY Plane_angle_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Plus_expression
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;

ENTITY Power_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Product;
  id : STRING;
  name : OPTIONAL STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Product_category;
  id : OPTIONAL STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Product_category_assignment;
  category : Product_category;
  products : SET[1:?] OF Product;
END_ENTITY;

ENTITY Product_category_hierarchy;
  super_category : Product_category;
  sub_category : Product_category;
END_ENTITY;

ENTITY Product_version;
  id : STRING;
  description : OPTIONAL STRING;
  of_product : Product;
END_ENTITY;

ENTITY Product_version_relationship;
  relation_type : OPTIONAL STRING;
  description : OPTIONAL STRING;
  relating_version : Product_version;
  related_version : Product_version;
WHERE
  WR1: relating_version :<>: related_version;
  WR2: EXISTS(relation_type) OR (TYPEOF(SELF\Product_version_relationship) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Product_view_definition;
  id : OPTIONAL STRING;
  name : OPTIONAL STRING;
  additional_characterization : OPTIONAL STRING;
  initial_context : View_definition_context;
  additional_contexts : SET[0:?] OF View_definition_context;
  defined_version : Product_version;
WHERE
  WR1: NOT (initial_context IN additional_contexts);
  WR2: EXISTS(id) OR (TYPEOF(SELF\Product_view_definition) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Property_definition_representation
  ABSTRACT SUPERTYPE ;
  description : OPTIONAL STRING;
  definition : represented_definition;
  rep : Representation;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Property_representation
  SUBTYPE OF (Property_definition_representation);
  SELF\Property_definition_representation.definition : Assigned_property;
DERIVE
  property : ASSIGNED_PROPERTY := SELF\Property_definition_representation.definition;
END_ENTITY;

ENTITY Ratio_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Real_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Numeric_defined_function);
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 Representation;
  id : OPTIONAL STRING;
  name : OPTIONAL STRING;
  description : OPTIONAL STRING;
  context_of_items : Representation_context;
  items : SET[1:?] OF Representation_item;
WHERE
  WR1: EXISTS(name) OR (TYPEOF(SELF\Representation) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Representation_context;
  id : STRING;
  kind : STRING;
INVERSE
  representations_in_context : SET[1:?] OF Representation FOR context_of_items;
END_ENTITY;

ENTITY Representation_item
  ABSTRACT SUPERTYPE ;
  name : OPTIONAL STRING;
END_ENTITY;

ENTITY Representation_relationship;
  relation_type : OPTIONAL STRING;
  description : OPTIONAL STRING;
  rep_1 : Representation;
  rep_2 : Representation;
WHERE
  WR1: EXISTS(relation_type) OR (TYPEOF(SELF\Representation_relationship) <> TYPEOF(SELF));
  WR2: EXISTS(description) OR (TYPEOF(SELF\Representation_relationship) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Simple_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (BOOLEAN_LITERAL,
                                BOOLEAN_VARIABLE))
  SUBTYPE OF (Boolean_expression, Simple_generic_expression);
END_ENTITY;

ENTITY Simple_generic_expression
  ABSTRACT SUPERTYPE OF (ONEOF (GENERIC_LITERAL,
                                GENERIC_VARIABLE))
  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 Simple_string_expression
  ABSTRACT SUPERTYPE OF (ONEOF (STRING_LITERAL,
                                STRING_VARIABLE))
  SUBTYPE OF (String_expression, Simple_generic_expression);
END_ENTITY;

ENTITY Sin_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Slash_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Solid_angle_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Sql_mappable_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Defined_function);
END_ENTITY;

ENTITY Square_root_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY State_based_behaviour_model
  SUBTYPE OF (Representation);
  SELF\Representation.context_of_items : State_based_behaviour_representation_context;
  SELF\Representation.items : SET[1:?] OF State_based_behaviour_representation_item;
END_ENTITY;

ENTITY State_based_behaviour_representation_context
  SUBTYPE OF (Representation_context);
END_ENTITY;

ENTITY State_based_behaviour_representation_item
  SUBTYPE OF (Representation_item);
  item : State_based_behaviour_element;
END_ENTITY;

ENTITY State_definition;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_definition_relationship;
  name : STRING;
  relating : SET[1:?] OF State_definition;
  description : OPTIONAL STRING;
  related : SET[1:?] OF State_definition;
END_ENTITY;

ENTITY State_definition_role;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_transition_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  end_state : SET[1:?] OF STATE_DEFINITION := SELF\State_definition_relationship.relating;
  start_state : SET[1:?] OF STATE_DEFINITION := SELF\State_definition_relationship.related;
END_ENTITY;

ENTITY String_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Defined_function, String_expression);
END_ENTITY;

ENTITY String_expression
  ABSTRACT SUPERTYPE OF (ONEOF (SIMPLE_STRING_EXPRESSION,
                                INDEX_EXPRESSION,
                                SUBSTRING_EXPRESSION,
                                CONCAT_EXPRESSION,
                                FORMAT_FUNCTION,
                                STRING_DEFINED_FUNCTION))
  SUBTYPE OF (Expression);
END_ENTITY;

ENTITY String_literal
  SUBTYPE OF (Simple_string_expression, Generic_literal);
  the_value : STRING;
END_ENTITY;

ENTITY String_representation_item
  SUBTYPE OF (Representation_item);
  string_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: ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION' IN TYPEOF(index1)) AND ('STATE_BASED_BEHAVIOUR_ARM_LF.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 Supplied_part_relationship
  SUBTYPE OF (Product_version_relationship);
WHERE
  WR1: SELF\Product_version_relationship.relation_type IN ['supplied item', 'supplied document'];
END_ENTITY;

ENTITY Tan_function
  SUBTYPE OF (Unary_function_call);
END_ENTITY;

ENTITY Text_based_representation
  SUBTYPE OF (Representation);
  SELF\Representation.context_of_items : Text_based_representation_context;
  SELF\Representation.items : SET[1:1] OF text_based_item_select;
END_ENTITY;

ENTITY Text_based_representation_context
  SUBTYPE OF (Representation_context);
END_ENTITY;

ENTITY Textual_expression_composition
  SUBTYPE OF (Representation_item);
  content : list_or_set_of_text_based_item;
END_ENTITY;

ENTITY Textual_expression_representation_item
  SUBTYPE OF (String_representation_item);
END_ENTITY;

ENTITY Thermodynamic_temperature_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Time_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Unary_boolean_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Boolean_expression, Unary_generic_expression);
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 Unary_generic_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Generic_expression);
  operand : 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 Uncertainty_with_unit
  SUBTYPE OF (Value_with_unit);
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Unit
  SUPERTYPE OF (ONEOF (AMOUNT_OF_SUBSTANCE_UNIT,
                       ELECTRIC_CURRENT_UNIT,
                       LENGTH_UNIT,
                       LUMINOUS_INTENSITY_UNIT,
                       MASS_UNIT,
                       PLANE_ANGLE_UNIT,
                       RATIO_UNIT,
                       SOLID_ANGLE_UNIT,
                       THERMODYNAMIC_TEMPERATURE_UNIT,
                       TIME_UNIT));
  name : STRING;
  si_unit : BOOLEAN;
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 Value_with_unit;
  unit : Unit;
  value_component : measure_value;
END_ENTITY;

ENTITY Variable
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Generic_variable);
END_ENTITY;

ENTITY Variable_semantics
  ABSTRACT SUPERTYPE ;
END_ENTITY;

ENTITY View_definition_context;
  application_domain : STRING;
  life_cycle_stage : STRING;
  description : OPTIONAL STRING;
WHERE
  WR1: (SIZEOF (USEDIN(SELF, 'STATE_BASED_BEHAVIOUR_ARM_LF.' +'PRODUCT_VIEW_DEFINITION.INITIAL_CONTEXT')) > 0) OR(SIZEOF (USEDIN(SELF, 'STATE_BASED_BEHAVIOUR_ARM_LF.' +'PRODUCT_VIEW_DEFINITION.ADDITIONAL_CONTEXTS')) > 0);
END_ENTITY;

ENTITY Xor_expression
  SUBTYPE OF (Binary_boolean_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Boolean_expression;
END_ENTITY;

FUNCTION Acyclic
 (arg1 : Generic_expression; arg2 : SET OF Generic_expression) : BOOLEAN;
LOCAL
result: BOOLEAN;
END_LOCAL;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.SIMPLE_GENERIC_EXPRESSION'
IN TYPEOF (arg1))
THEN
RETURN (TRUE);
END_IF;
IF arg1 IN arg2
THEN
RETURN (FALSE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.UNARY_GENERIC_EXPRESSION'
IN TYPEOF (arg1)
THEN
RETURN
(Acyclic(arg1\Unary_generic_expression.operand,arg2+[arg1]));
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.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
'STATE_BASED_BEHAVIOUR_ARM_LF.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;

FUNCTION CLASSOF
 (the_instance : GENERIC) : SET OF STRING;
LOCAL
result : SET OF STRING;
classifications : BAG OF Classification_assignment;
END_LOCAL;
result := TYPEOF(the_instance);
classifications := USEDIN(the_instance,'STATE_BASED_BEHAVIOUR_ARM_LF.CLASSIFICATION_ASSIGNMENT.ITEMS');
REPEAT i := LOINDEX(classifications) TO HIINDEX(classifications);
result := result + classifications[i].ASSIGNED_CLASS.ID;
END_REPEAT;
RETURN (result);
                                                            
END_FUNCTION;

FUNCTION Is_Acyclic
 (arg : Generic_expression) : BOOLEAN;
RETURN (Acyclic (arg, []));
                                                            
END_FUNCTION;

FUNCTION Is_int_expr
 (arg : Numeric_expression) : BOOLEAN;
LOCAL
i: INTEGER;
END_LOCAL;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.INT_LITERAL' IN TYPEOF(arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.REAL_LITERAL' IN TYPEOF(arg)
THEN
RETURN (FALSE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg)
THEN
RETURN (FALSE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.ABS_FUNCTION' IN TYPEOF(arg)
THEN
RETURN (Is_int_expr(arg\Unary_numeric_expression.operand));
END_IF;
IF 'NUMERIC_FUNCTION.MINUS_FUNCTION' IN TYPEOF(arg)
THEN
RETURN (Is_int_expr(arg\Unary_numeric_expression.operand));
END_IF;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.SIN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COS_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.TAN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.ASIN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.ACOS_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.Atan_function' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.EXP_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG2_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG10_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.SQUARE_ROOT_FUNCTION'
IN TYPEOF(arg))
THEN
RETURN (FALSE);
END_IF;
IF 	('STATE_BASED_BEHAVIOUR_ARM_LF.PLUS_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.MULT_EXPRESSION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.MAXIMUM_FUNCTION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.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 	('STATE_BASED_BEHAVIOUR_ARM_LF.MINUS_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.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	('STATE_BASED_BEHAVIOUR_ARM_LF.DIV_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.MOD_EXPRESSION' IN TYPEOF(arg))
THEN
RETURN(TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.SLASH_EXPRESSION' IN TYPEOF(arg)
THEN
RETURN (FALSE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.LENGTH_FUNCTION' IN TYPEOF(arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.VALUE_FUNCTION' IN TYPEOF(arg)
THEN
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.INT_VALUE_FUNCTION'
IN TYPEOF(arg)
THEN
RETURN (TRUE);
ELSE
RETURN (FALSE);
END_IF;
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.INTEGER_DEFINED_FUNCTION'
IN TYPEOF(arg)
THEN
RETURN(TRUE) ;
END_IF;
IF'STATE_BASED_BEHAVIOUR_ARM_LF.REAL_DEFINED_FUNCTION' IN TYPEOF(arg)
THEN
RETURN(FALSE) ;
END_IF ;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.BOOLEAN_DEFINED_FUNCTION'
IN TYPEOF(arg)
THEN
RETURN(FALSE) ;
END_IF ;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.STRING_DEFINED_FUNCTION'
IN TYPEOF(arg)
THEN
RETURN (FALSE) ;
END_IF ;
RETURN (FALSE);
                                                            
END_FUNCTION;

FUNCTION Is_sql_mappable
 (arg : expression) : BOOLEAN;
LOCAL
i: INTEGER;
END_LOCAL;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.SIMPLE_NUMERIC_EXPRESSION'
IN TYPEOF (arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.SQL_MAPPABLE_DEFINED_FUNCTION'
IN TYPEOF (arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.MINUS_FUNCTION' IN TYPEOF(arg)
THEN
RETURN (Is_sql_mappable(arg\Unary_numeric_expression.operand));
END_IF;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.ABS_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.SIN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COS_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.TAN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.ASIN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.ACOS_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.ATAN_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.EXP_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG2_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LOG10_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.SQUARE_ROOT_FUNCTION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.VALUE_FUNCTION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.LENGTH_FUNCTION'
IN TYPEOF(arg))
THEN
RETURN (FALSE);
END_IF;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.PLUS_EXPRESSION' IN TYPEOF(arg))
OR('STATE_BASED_BEHAVIOUR_ARM_LF.MULT_EXPRESSION' IN TYPEOF(arg))
OR('STATE_BASED_BEHAVIOUR_ARM_LF.MAXIMUM_FUNCTION'
IN TYPEOF(arg))
OR('STATE_BASED_BEHAVIOUR_ARM_LF.MAXIMUM_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 ('STATE_BASED_BEHAVIOUR_ARM_LF.MINUS_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.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 ('STATE_BASED_BEHAVIOUR_ARM_LF.DIV_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.MOD_EXPRESSION' IN TYPEOF(arg))
OR('STATE_BASED_BEHAVIOUR_ARM_LF.POWER_EXPRESSION'
IN TYPEOF(arg))
THEN
RETURN (FALSE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.SIMPLE_BOOLEAN_EXPRESSION'
IN TYPEOF (arg)
THEN
RETURN (TRUE);
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.NOT_EXPRESSION' IN TYPEOF (arg)
THEN
RETURN (Is_sql_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND));
END_IF;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.ODD_FUNCTION'IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.XOR_EXPRESSION'
IN TYPEOF (arg))
THEN
RETURN (FALSE);
END_IF;
IF ('STATE_BASED_BEHAVIOUR_ARM_LF.AND_EXPRESSION' IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.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 'STATE_BASED_BEHAVIOUR_ARM_LF.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	('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_EQUAL' IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_GREATER'
IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_GREATER_EQUAL'
IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_LESS'
IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_LESS_EQUAL'
IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.COMPARISON_NOT_EQUAL'
IN TYPEOF (arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.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 'STATE_BASED_BEHAVIOUR_ARM_LF.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 ('STATE_BASED_BEHAVIOUR_ARM_LF.NUMERIC_DEFINED_FUNCTION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.BOOLEAN_DEFINED_FUNCTION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.STRING_DEFINED_FUNCTION'
IN TYPEOF(arg))
THEN
RETURN (FALSE) ;
END_IF;
IF 'STATE_BASED_BEHAVIOUR_ARM_LF.SIMPLE_STRING_EXPRESSION'
IN TYPEOF(ARG)
THEN
RETURN (TRUE);
END_IF;
IF 	('STATE_BASED_BEHAVIOUR_ARM_LF.INDEX_EXPRESSION' IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.SUBSTRING_EXPRESSION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.CONCAT_EXPRESSION'
IN TYPEOF(arg))
OR ('STATE_BASED_BEHAVIOUR_ARM_LF.FORMAT_FUNCTION'
IN TYPEOF(arg))
THEN
RETURN (FALSE);
END_IF;
RETURN (FALSE);
                                                            
END_FUNCTION;

END_SCHEMA;  -- State_based_behaviour_arm_LF


© ISO 2006 — All rights reserved