ISO/TS 10303-1453:2014-02 Function based behaviour


Application module: Function based behaviour	ISO/TS 10303-1453:2014-02(E) © ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
3.1 Terms and definitions
3.2 Abbreviated terms

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

A MIM short names
B Information object registration
C ARM EXPRESS-G
D MIM EXPRESS-G
E Computer interpretable listings
F Application module implementation and usage guide
G Change history
Bibliography
Index


         (*
ISO TC184/SC4/WG3 N2730 - ISO/TS 10303-1453 Function based behaviour - EXPRESS ARM Long form
Supersedes 
         ISO TC184/SC4/WG3 N2483
*)



SCHEMA Function_based_behaviour_arm_LF;


TYPE activity_item =
         
         
         SELECT

            (Activity_method, 
    Assigned_property, 
    Behaviour_description_association, 
    Condition, 
    File, 
    Product, 
    Product_version, 
    Product_version_relationship, 
    Product_view_definition, 
    Required_resource, 
    Required_resource_assignment, 
    Resource_item, 
    Resource_item_realization, 
    Resource_property, 
    Task_io, 
    Task_io_hierarchy);

         END_TYPE;


TYPE activity_method_item =
         
         
         SELECT

            (Activity_method, 
    Assigned_property, 
    Behaviour_description_association, 
    Condition, 
    File, 
    Product, 
    Product_version, 
    Product_version_relationship, 
    Product_view_definition, 
    Required_resource, 
    Required_resource_assignment, 
    Resource_item, 
    Resource_item_realization, 
    Resource_property, 
    Task_io, 
    Task_io_hierarchy);

         END_TYPE;


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

            (Function_based_behaviour_model);

         END_TYPE;


TYPE characterized_activity_definition =
         
         
         SELECT

            (Activity, 
    Activity_method, 
    Activity_method_relationship);

         END_TYPE;


TYPE characterized_resource_select =
         
         
         SELECT

            (Required_resource, 
    Resource_item, 
    Resource_item_realization, 
    Resource_item_relationship);

         END_TYPE;


TYPE classification_item =
         
         
         SELECT

            (Activity_method, 
    Activity_method_relationship, 
    Applied_activity_method_assignment, 
    Assigned_property, 
    Class, 
    Condition, 
    Condition_assignment, 
    Condition_parameter, 
    Condition_relationship, 
    Constrained_general_parameter_relationship, 
    Expression, 
    Expression_assignment, 
    External_class_library, 
    External_source_identification, 
    File, 
    General_model_parameter, 
    Identification_assignment, 
    Identification_relationship, 
    Independent_property, 
    Independent_property_relationship, 
    Independent_property_representation, 
    Parameter_value_representation_item, 
    Product, 
    Product_relationship, 
    Product_version, 
    Product_version_relationship, 
    Product_view_definition, 
    Property_representation, 
    Representation, 
    Representation_context, 
    Representation_item, 
    Representation_relationship, 
    Required_resource, 
    Required_resource_assignment, 
    Required_resource_relationship, 
    Resource_item, 
    Resource_item_assignment, 
    Resource_item_realization, 
    Resource_item_relationship, 
    Resource_property, 
    Resource_property_representation, 
    Text_based_representation, 
    Unit, 
    Value_with_unit, 
    View_definition_context);

         END_TYPE;


TYPE collection_assignment_select =
         
         
         SELECT

            (Activity_method, 
    Product, 
    Product_version, 
    Product_view_definition);

         END_TYPE;


TYPE collection_member_select =
         
         
         SELECT

            (Activity_method, 
    Activity_method_relationship, 
    Applied_activity_method_assignment, 
    Assigned_property, 
    Class, 
    Classification_assignment, 
    Collection_assignment, 
    Collection_membership, 
    Condition, 
    Condition_assignment, 
    Condition_parameter, 
    Condition_relationship, 
    Derived_unit_element, 
    External_source, 
    External_source_identification, 
    File, 
    Identification_assignment, 
    Identification_relationship, 
    Independent_property, 
    Independent_property_relationship, 
    Name_assignment, 
    Product, 
    Product_relationship, 
    Product_version, 
    Product_version_relationship, 
    Product_view_definition, 
    Property_definition_representation, 
    Representation, 
    Representation_context, 
    Representation_item, 
    Representation_relationship, 
    Required_resource, 
    Required_resource_assignment, 
    Required_resource_relationship, 
    Required_resource_requirement, 
    Resource_item, 
    Resource_item_assignment, 
    Resource_item_realization, 
    Resource_item_relationship, 
    Resource_property, 
    Resource_property_representation, 
    Same_as_external_item, 
    Unit, 
    Value_with_unit, 
    View_definition_context);

         END_TYPE;


TYPE condition_item =
         
         
         SELECT

            (Activity_method, 
    Activity_method_relationship, 
    Applied_activity_method_assignment, 
    Assigned_property, 
    Expression_assignment, 
    Required_resource, 
    Required_resource_assignment, 
    Required_resource_relationship, 
    Resource_item, 
    Resource_item_assignment, 
    Resource_item_realization, 
    Resource_item_relationship, 
    Resource_property);

         END_TYPE;


TYPE condition_parameter_item =
         
         
         SELECT

            (Activity_method, 
    Activity_method_relationship, 
    Applied_activity_method_assignment, 
    Assigned_property, 
    Classification_assignment, 
    Condition_relationship, 
    Expression, 
    Identification_assignment, 
    Independent_property, 
    Independent_property_representation, 
    parameter_value_select, 
    Product, 
    Product_version, 
    Product_view_definition, 
    Property_representation, 
    Representation, 
    Required_resource, 
    Required_resource_assignment, 
    Required_resource_relationship, 
    Resource_item, 
    Resource_item_assignment, 
    Resource_item_realization, 
    Resource_item_relationship, 
    Resource_property, 
    Resource_property_representation);

         END_TYPE;


TYPE expression_assignment_item =
         
         
         SELECT

            (Condition);

         END_TYPE;


TYPE external_identification_item =
         
         
         SELECT

            (File);

         END_TYPE;


TYPE identification_item =
         
         
         SELECT

            (Activity_method, 
    Activity_method_relationship, 
    Applied_activity_method_assignment, 
    Assigned_property, 
    Behaviour, 
    Behaviour_version, 
    Behaviour_view_definition, 
    Class, 
    Condition, 
    External_class_library, 
    External_source_identification, 
    File, 
    Identification_relationship, 
    Independent_property, 
    Independent_property_relationship, 
    Product, 
    Product_relationship, 
    Product_version, 
    Product_view_definition, 
    Representation, 
    Representation_item, 
    Required_resource, 
    Required_resource_relationship, 
    Requirement, 
    Requirement_version, 
    Requirement_version_relationship, 
    Resource_item, 
    Resource_item_realization, 
    Resource_property, 
    View_definition_context);

         END_TYPE;


TYPE identifier =
         STRING;

         END_TYPE;


TYPE label =
         STRING;

         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, 
    Value_with_unit);

         END_TYPE;


TYPE plane_angle_measure =
         REAL;

         END_TYPE;


TYPE property_assignment_select =
         
         
         SELECT

            (Applied_activity_method_assignment, 
    Condition_parameter, 
    File, 
    Generic_expression, 
    Independent_property_relationship, 
    Product, 
    Product_version, 
    Product_version_relationship, 
    Product_view_definition, 
    Property_definition_representation, 
    Representation, 
    Representation_context, 
    Representation_item, 
    Task_io_hierarchy);

         END_TYPE;


TYPE represented_definition =
         
         
         SELECT

            (Assigned_property, 
    Independent_property);

         END_TYPE;


TYPE required_resource_item =
         
         
         SELECT

            (Activity_method, 
    Product, 
    Product_version, 
    Product_view_definition);

         END_TYPE;


TYPE resource_assignment_item =
         
         
         SELECT

            (Activity_method, 
    Product, 
    Product_version, 
    Product_view_definition);

         END_TYPE;


TYPE resource_item_select =
         
         
         SELECT

            (File, 
    Product, 
    Product_version, 
    Product_view_definition);

         END_TYPE;


TYPE resource_requirement_select =
         
         
         SELECT

            (Requirement_version);

         END_TYPE;


TYPE same_as_item =
         
         
         SELECT

            (Activity_method, 
    Condition, 
    Condition_parameter, 
    Derived_unit_element, 
    External_source, 
    External_source_identification, 
    Independent_property, 
    Product, 
    Product_version, 
    Product_view_definition, 
    Representation_context, 
    Required_resource, 
    Required_resource_requirement, 
    Resource_item, 
    Resource_property, 
    Unit, 
    Value_with_unit, 
    View_definition_context);

         END_TYPE;


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

         END_TYPE;


TYPE task_item =
         activity_method_item
               
               
               
               
               
               ;
WHERE

           wr1: NOT ('TASK_ELEMENT_ARM.ACTIVITY_METHOD' IN TYPEOF(SELF));

           wr2: NOT ('TASK_ELEMENT_ARM.BEHAVIOUR_DESCRIPTION_ASSOCIATION' IN TYPEOF(SELF));

           wr3: NOT ('TASK_ELEMENT_ARM.CONDITION' IN TYPEOF(SELF));

           wr4: NOT ('TASK_ELEMENT_ARM.RESOURCE_ITEM_REALIZATION' IN TYPEOF(SELF));

           wr5: NOT ('TASK_ELEMENT_ARM.TASK_IO' IN TYPEOF(SELF));

           wr6: NOT ('TASK_ELEMENT_ARM.TASK_IO_HIERARCHY' IN TYPEOF(SELF));

         END_TYPE;


TYPE text =
         STRING;

         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;

           id : STRING;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           chosen_method : Activity_method;

         
         END_ENTITY;


ENTITY Activity_method;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           consequence : 
         OPTIONAL 
         STRING;

           purpose : STRING;

         
         END_ENTITY;


ENTITY Activity_method_relationship;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           relating_method : Activity_method;

           related_method : Activity_method;

         
         END_ENTITY;


ENTITY Activity_property;

           name : STRING;

           description : STRING;

           described_element : characterized_activity_definition;

         
         END_ENTITY;


ENTITY Activity_property_representation;

           description : 
         OPTIONAL 
         STRING;

           property : Activity_property;

           rep : Representation;

           role : STRING;

         
         END_ENTITY;


ENTITY Activity_relationship;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           relating_activity : Activity;

           related_activity : Activity;

         
         END_ENTITY;


ENTITY Activity_status;

           assigned_activity : Activity;

           status : STRING;

         
         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_activity_assignment;

           assigned_activity : Activity;

           items : SET[1:?] OF activity_item;

           role : STRING;

         
         END_ENTITY;


ENTITY Applied_activity_method_assignment;

           assigned_activity_method : Activity_method;

           items : SET[1:?] OF activity_method_item;

           role : STRING;

         
         END_ENTITY;


ENTITY Applied_independent_activity_property

           SUBTYPE OF (Activity_property);

           base_element_property : Independent_property;
DERIVE

           SELF\Activity_property.name : STRING := base_element_property.property_type;

         
         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_independent_resource_property

           SUBTYPE OF (Resource_property);

           base_element_property : Independent_property;
DERIVE

           SELF\Resource_property.name : STRING := base_element_property.property_type;

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

           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 Collection

           SUBTYPE OF (Product);

         
         END_ENTITY;


ENTITY Collection_assignment;

           collection : Collection_view_definition;

           is_assigned_to : collection_assignment_select;

         
         END_ENTITY;


ENTITY Collection_membership;

           member : collection_member_select;

           of_collection : Collection_view_definition;

         
         END_ENTITY;


ENTITY Collection_relationship

           SUBTYPE OF (Product_relationship);

           SELF\Product_relationship.relating_product : Collection;

           SELF\Product_relationship.related_product : Collection;
DERIVE

           related_collection : Collection := SELF\Product_relationship.related_product;

           relating_collection : Collection := SELF\Product_relationship.relating_product;

         
         END_ENTITY;


ENTITY Collection_version

           SUBTYPE OF (Product_version);

           SELF\Product_version.of_product : Collection;
DERIVE

           of_collection : Collection := SELF\Product_version.of_product;

         
         END_ENTITY;


ENTITY Collection_version_relationship

           SUBTYPE OF (Product_version_relationship);

           SELF\Product_version_relationship.relating_version : Collection_version;

           SELF\Product_version_relationship.related_version : Collection_version;

         
         END_ENTITY;


ENTITY Collection_version_sequence_relationship

           SUBTYPE OF (Collection_version_relationship);
DERIVE

           predecessor : Collection_version := SELF\Product_version_relationship.relating_version;

           successor : Collection_version := SELF\Product_version_relationship.related_version;

         
         END_ENTITY;


ENTITY Collection_view_definition

           SUBTYPE OF (Product_view_definition);

           SELF\Product_view_definition.defined_version : Collection_version;

         
         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 Concat_expression

           SUBTYPE OF (String_expression, Multiple_arity_generic_expression);

           SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF String_expression;

         
         END_ENTITY;


ENTITY Concurrent_elements

           SUBTYPE OF (Structured_task_element);

           elements : SET[2:?] OF Task_element;

         
         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 Decision_path;

           condition : Condition;

           defined_in : Multiple_decision_point;

           path_element : Task_element;

         
         END_ENTITY;


ENTITY Decision_point

           SUBTYPE OF (Structured_task_element);

           condition : Condition;

           true_case_element : 
         OPTIONAL 
         Task_element;

           false_case_element : 
         OPTIONAL 
         Task_element;

           unknown_case_element : 
         OPTIONAL 
         Task_element;

         
         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 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: 'FUNCTION_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 End_task

           SUBTYPE OF (Task_element);

         
         END_ENTITY;


ENTITY Environment;

           syntactic_representation : Generic_variable;

           semantics : Variable_semantics;

         
         END_ENTITY;


ENTITY Equals_expression

           SUBTYPE OF (Binary_boolean_expression);

         
         END_ENTITY;


ENTITY Exit_loop

           SUBTYPE OF (Task_element);

         
         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;

           items : SET[1:?] OF expression_assignment_item;

         
         END_ENTITY;


ENTITY External_class

           SUBTYPE OF (Class);

           external_source : External_class_library;

         
         END_ENTITY;


ENTITY External_class_library

           SUBTYPE OF (External_source);

         
         END_ENTITY;


ENTITY External_functional_model

           SUBTYPE OF (Function_based_behaviour_model);

           external_file : Digital_file;

         
         END_ENTITY;


ENTITY External_item_identification

           SUBTYPE OF (External_source_identification);

           external_id : STRING;

         
         END_ENTITY;


ENTITY External_source;

           id : STRING;

           description : 
         OPTIONAL 
         STRING;

         
         END_ENTITY;


ENTITY External_source_identification;

           source_id : STRING;

           source_type : STRING;

           item : external_identification_item;

           description : 
         OPTIONAL 
         STRING;

         
         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: 'FUNCTION_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: (('FUNCTION_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION') IN TYPEOF(value_to_format)) AND (('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION')
            IN TYPEOF(format_string));

         
         END_ENTITY;


ENTITY Function_based_behaviour_model

           SUBTYPE OF (Representation);

           SELF\Representation.context_of_items : Function_based_behaviour_representation_context;

           SELF\Representation.items : SET[1:?] OF Function_based_behaviour_representation_item;

         
         END_ENTITY;


ENTITY Function_based_behaviour_representation_context

           SUBTYPE OF (Representation_context);

         
         END_ENTITY;


ENTITY Function_based_behaviour_representation_item

           SUBTYPE OF (Representation_item);

           item : Task_element;

         
         END_ENTITY;


ENTITY Function_parameter_value

           SUPERTYPE OF 
         (Int_value_function)

           SUBTYPE OF (Numeric_expression, Unary_generic_expression);

           SELF\Unary_generic_expression.operand : String_expression;

         
         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 Identification_relationship;

           relating_identification_assignment : Identification_assignment;

           related_identification_assignment : Identification_assignment;

         
         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: ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('FUNCTION_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 (Function_parameter_value);

         
         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: ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.EXPRESSION' IN TYPEOF(interval_low)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.EXPRESSION'
            IN TYPEOF(interval_item)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.EXPRESSION' IN TYPEOF(interval_high));

           WR2: (('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF.interval_low)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION'
            IN TYPEOF(SELF.interval_high)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF.interval_item))) OR
            (('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF.interval_low)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION'
            IN TYPEOF(SELF.interval_item)) AND ('FUNCTION_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: ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(SELF\Comparison_expression.operands[1])) AND ('FUNCTION_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 Looping_element

           SUPERTYPE OF 
         (ONEOF (Repeat_count,
                       Repeat_until,
                       Repeat_while))

           SUBTYPE OF (Structured_task_element);

           repeated_element : Task_element;

         
         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 Multiple_decision_point

           SUBTYPE OF (Structured_task_element);
INVERSE

           paths : SET[2:?] OF Decision_path FOR defined_in;

         
         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: ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(SELF)) OR ('FUNCTION_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 : STRING;

           description : 
         OPTIONAL 
         STRING;

         
         END_ENTITY;


ENTITY Product_relationship;

           relation_type : STRING;

           description : 
         OPTIONAL 
         STRING;

           relating_product : Product;

           related_product : Product;

         
         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 Repeat_count

           SUBTYPE OF (Looping_element);

           count : INTEGER;

         
         END_ENTITY;


ENTITY Repeat_until

           SUBTYPE OF (Looping_element);

           condition : Condition;

         
         END_ENTITY;


ENTITY Repeat_while

           SUBTYPE OF (Looping_element);

           condition : Condition;

         
         END_ENTITY;


ENTITY Representation;

           id : 
         OPTIONAL 
         identifier;

           name : 
         OPTIONAL 
         label;

           description : 
         OPTIONAL 
         text;

           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 : identifier;

           kind : text;
INVERSE

           representations_in_context : SET[1:?] OF Representation FOR context_of_items;

         
         END_ENTITY;


ENTITY Representation_item

           ABSTRACT SUPERTYPE
         ;

           name : 
         OPTIONAL 
         label;

         
         END_ENTITY;


ENTITY Representation_relationship;

           relation_type : 
         OPTIONAL 
         label;

           description : 
         OPTIONAL 
         text;

           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 Required_resource

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (Required_resource_by_reference,
                                Required_resource_by_requirement,
                                Required_resource_by_resource_item));

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           required_quantity : 
         OPTIONAL 
         Value_with_unit;

         
         END_ENTITY;


ENTITY Required_resource_assignment;

           assigned_resource : Required_resource;

           item : required_resource_item;

         
         END_ENTITY;


ENTITY Required_resource_by_reference

           SUBTYPE OF (Required_resource);

           item : resource_item_select;

         
         END_ENTITY;


ENTITY Required_resource_by_requirement

           SUBTYPE OF (Required_resource);

         
         END_ENTITY;


ENTITY Required_resource_by_resource_item

           SUBTYPE OF (Required_resource);

           resource_item : Resource_item;

         
         END_ENTITY;


ENTITY Required_resource_relationship;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           relating : Required_resource;

           related : Required_resource;

         
         END_ENTITY;


ENTITY Required_resource_requirement;

           item : resource_requirement_select;

           resource_requirement : Required_resource_by_requirement;

         
         END_ENTITY;


ENTITY Requirement

           SUBTYPE OF (Product);

         
         END_ENTITY;


ENTITY Requirement_version

           SUBTYPE OF (Product_version);

           SELF\Product_version.of_product : Requirement;

         
         END_ENTITY;


ENTITY Requirement_version_relationship

           SUBTYPE OF (Product_version_relationship);

           SELF\Product_version_relationship.relating_version : Requirement_version;

           SELF\Product_version_relationship.related_version : Requirement_version;
DERIVE

           predecessor : Requirement_version := SELF\Product_version_relationship.relating_version;

           successor : Requirement_version := SELF\Product_version_relationship.related_version;

         
         END_ENTITY;


ENTITY Resource_group_relationship

           SUBTYPE OF (Resource_item_relationship);

           quantity : 
         OPTIONAL 
         Value_with_unit;

         
         END_ENTITY;


ENTITY Resource_item;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

         
         END_ENTITY;


ENTITY Resource_item_assignment;

           assigned_resource : Resource_item;

           item : resource_assignment_item;

         
         END_ENTITY;


ENTITY Resource_item_realization;

           item : resource_item_select;

           resource_item : Resource_item;

         
         END_ENTITY;


ENTITY Resource_item_relationship;

           name : STRING;

           description : 
         OPTIONAL 
         STRING;

           relating : Resource_item;

           related : Resource_item;

         
         END_ENTITY;


ENTITY Resource_property;

           name : STRING;

           description : STRING;

           described_element : characterized_resource_select;

         
         END_ENTITY;


ENTITY Resource_property_representation;

           description : 
         OPTIONAL 
         STRING;

           property : Resource_property;

           rep : Representation;

           role : STRING;

         
         END_ENTITY;


ENTITY Same_as_external_item;

           external_item_id : STRING;

           description : 
         OPTIONAL 
         STRING;

           role : STRING;

           external_source : External_source;

           items : SET[0:?] OF same_as_item;

         
         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 Start_task

           SUBTYPE OF (Task_element);

         
         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 Structured_task_element

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (Concurrent_elements,
                                Decision_point,
                                Looping_element,
                                Task_element_sequence))

           SUBTYPE OF (Task_element);

         
         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: ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.NUMERIC_EXPRESSION'
            IN TYPEOF(index1)) AND ('FUNCTION_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 Task_element

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (End_task,
                                Exit_loop,
                                Structured_task_element,
                                Task_step))

           SUBTYPE OF (Activity_method);

         
         END_ENTITY;


ENTITY Task_element_assignment

           SUBTYPE OF (Applied_activity_method_assignment);

           SELF\Applied_activity_method_assignment.assigned_activity_method : Task_element;

           SELF\Applied_activity_method_assignment.items : SET[1:?] OF task_item;
DERIVE

           assigned_task_element : Task_element := SELF\Applied_activity_method_assignment.assigned_activity_method;

         
         END_ENTITY;


ENTITY Task_element_relationship

           SUBTYPE OF (Activity_method_relationship);

           SELF\Activity_method_relationship.relating_method : Task_element;

           SELF\Activity_method_relationship.related_method : Task_element;

         
         END_ENTITY;


ENTITY Task_element_sequence

           SUBTYPE OF (Structured_task_element);

           elements : LIST[2:?] OF Task_element;

         
         END_ENTITY;


ENTITY Task_io

           SUBTYPE OF (Task_element_assignment);

           SELF\Applied_activity_method_assignment.assigned_activity_method : Task_step;

         
         END_ENTITY;


ENTITY Task_io_hierarchy;

           child : Task_io;

           parent : Task_io;
WHERE

           wr1: child.role = parent.role;

         
         END_ENTITY;


ENTITY Task_step

           SUBTYPE OF (Task_element);

           SELF\Activity_method.description : STRING;
DERIVE

           step_text : STRING := SELF\Activity_method.description;

         
         END_ENTITY;


ENTITY Task_step_hierarchy

           SUBTYPE OF (Task_element_relationship);

           SELF\Task_element_relationship.related_method : Task_step;

           SELF\Task_element_relationship.relating_method : Task_step;
DERIVE

           child : Task_step := SELF\Task_element_relationship.related_method;

           parent : Task_step := SELF\Task_element_relationship.relating_method;

         
         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
         

           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_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, 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.' + 'PRODUCT_VIEW_DEFINITION.INITIAL_CONTEXT')) > 0) OR (SIZEOF(USEDIN(SELF,
            'FUNCTION_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 ('FUNCTION_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 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.UNARY_GENERIC_EXPRESSION' IN TYPEOF(arg1) THEN
    RETURN (Acyclic(arg1\Unary_generic_expression.operand, arg2 + [arg1]));
  END_IF;
  IF 'FUNCTION_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 'FUNCTION_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 : ininst) : SET OF STRING;

  LOCAL
    result : SET OF STRING;
    classifications : BAG OF Classification_assignment;
  END_LOCAL;

  result := TYPEOF(the_instance);
  classifications := USEDIN(the_instance, 'FUNCTION_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 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.INT_LITERAL' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.REAL_LITERAL' IN TYPEOF(arg) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.SIN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COS_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.TAN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ASIN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ACOS_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.Atan_function' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.EXP_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG2_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG10_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.PLUS_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MULT_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.DIV_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MOD_EXPRESSION' IN TYPEOF(arg)) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.SLASH_EXPRESSION' IN TYPEOF(arg) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.LENGTH_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.VALUE_FUNCTION' IN TYPEOF(arg) THEN
    IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.INT_VALUE_FUNCTION' IN TYPEOF(arg) THEN
      RETURN (TRUE);
    ELSE
      RETURN (FALSE);
    END_IF;
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.INTEGER_DEFINED_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_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 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.SIMPLE_NUMERIC_EXPRESSION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.SQL_MAPPABLE_DEFINED_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.MINUS_FUNCTION' IN TYPEOF(arg) THEN
    RETURN (Is_sql_mappable(arg\Unary_numeric_expression.operand));
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ABS_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.SIN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COS_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.TAN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ASIN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ACOS_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ATAN_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.EXP_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG2_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LOG10_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.VALUE_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.LENGTH_FUNCTION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.PLUS_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MULT_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.DIV_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.MOD_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.POWER_EXPRESSION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.SIMPLE_BOOLEAN_EXPRESSION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.NOT_EXPRESSION' IN TYPEOF(arg) THEN
    RETURN (Is_sql_mappable(arg\Unary_generic_expression.operand));
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.ODD_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.XOR_EXPRESSION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.AND_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_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 'FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_EQUAL' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_GREATER' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_GREATER_EQUAL' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_LESS' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_LESS_EQUAL' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.COMPARISON_NOT_EQUAL' IN TYPEOF(arg)) OR ('FUNCTION_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 'FUNCTION_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 ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.NUMERIC_DEFINED_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.STRING_DEFINED_FUNCTION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  IF 'FUNCTION_BASED_BEHAVIOUR_ARM_LF.SIMPLE_STRING_EXPRESSION' IN TYPEOF(arg) THEN
    RETURN (TRUE);
  END_IF;
  IF ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.INDEX_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.SUBSTRING_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.CONCAT_EXPRESSION' IN TYPEOF(arg)) OR ('FUNCTION_BASED_BEHAVIOUR_ARM_LF.FORMAT_FUNCTION' IN TYPEOF(arg)) THEN
    RETURN (FALSE);
  END_IF;
  RETURN (FALSE);


         END_FUNCTION;



         END_SCHEMA;  -- Function_based_behaviour_arm_LF