4 Representation schema

4.1 General

The subjects of the representation_schema are the structures that relate a collection of elements of product data to a context. These structures are representations. Representations are used to describe aspects of products. The associations between representations and the aspects of products they describe are specified in annotated EXPRESS schemas that use or specialize this schema. Representations can be used to:

• describe a property or a relationship between two properties, in which the properties are associated with a complete product or with a part of a product;

  NOTE 1   The use of representations to collect elements of product data in order to describe the properties of a product is specified in ISO 10303-41, and can be specified in annotated EXPRESS schemas that use or specialize the constructs specified in this part of ISO 10303 and in ISO 10303-41.

• describe a picture.

  NOTE 2   The use of representations to collect elements of product data in order to describe a picture of a product is specified in ISO 10303-46 [6], and can be specified in annotated EXPRESS schemas that use or specialize the constructs specified in this part of ISO 10303 and in ISO 10303-46 [6].

One representation can be part of another representation.

EXAMPLE 1   A collection of lines and points describes the shape of a wall. This representation can be used as part of the description of the shape of the building, of which the wall is a part.

Each representation has a context and a collection of elements specified in that context.

EXAMPLE 2   For the representation of geometric elements, the context is a coordinate space.

A context can be related to other contexts.

EXAMPLE 3   Local coordinate spaces can be defined for each building in a factory complex. These coordinate spaces can be related to each other, and to the coordinate space of the factory complex itself.

Transformations between representations can be specified.

Each implementation of an AP that uses this schema and that encodes entity names shall use the encoding specified in Annex A. Each reference to this schema in an open system shall use the identifier encoding specified in Annex B. This schema is illustrated in Annex D using the EXPRESS-G notation.

REFERENCE FROM basic_attribute_schema    --  ISO 10303-41
  (description_attribute,
   description_attribute_select,
   get_description_value,
   get_id_value,
   id_attribute,
   id_attribute_select);



REFERENCE FROM measure_schema    --  ISO 10303-41
  (measure_value,
   measure_with_unit);



REFERENCE FROM support_resource_schema    --  ISO 10303-41
  (bag_to_set,
   identifier,
   label,
   text);
(*



NOTE 3   The schemas referenced above are specified in the following parts:

basic_attribute_schema	ISO 10303-41
measure_schema	ISO 10303-41
support_resource_schema	ISO 10303-41

NOTE 4   See Annex D for a graphical representation of this schema.

4.2 Fundamental concepts and assumptions

The following concepts and assumptions apply to the portions of this schema that deal with representation:

• A representation consists of a collection of elements of representation and a context. A representation corresponds to an instance of the representation entity data type. By structuring the elements in this way, relationships between elements can be established. Elements of representation are related if:
  1. they are elements in the same representation, or
  2. they are elements in different representations that have the same context, or
  3. they are elements in different representations that have different contexts, if the contexts are related

  EXAMPLE 1   Consider two points with coordinate values of (0,0,0) and (1,0,0). It is not possible to calculate the distance between these points until it is established that they are in the same coordinate space. The specification of a point by itself does not contain enough data to state which coordinate space it is in and what other elements also share that coordinate space. In this part of ISO 10303, a point is an example of an element of representation, and a coordinate space is an example of a context.

• A representation can be used more than once. A representation is separate from its use.

  EXAMPLE 2   Consider a collection of points and lines in a coordinate space. This collection can be used to describe the shape of a product. The collection can also be used, possibly with some transformation, to describe a drawing or picture of the product. Neither of these uses is part of the definition of the collection itself.

NOTE 1   Representations can be specialized further in annotated EXPRESS schemas that use or specialize this schema.

The following assumptions apply to the portions of this schema that deal with the context of representation:

• A representation has a context. It is the context in which the elements of the representation are related. The context of a representation corresponds to an instance of the representation_context entity data type.
• The context of a representation exists only as a basis for the representations that use it. Therefore, representation contexts are related only if representations using the contexts are related.

NOTE 2   Representation contexts can be specialized further in annotated EXPRESS schemas that use or specialize this schema.

EXAMPLE 3   Possible specializations include contexts for geometry, topology, finite element modelling and kinematic modelling.

The following concepts and assumptions apply to the portions of this schema that deal with elements of representation:

• Elements of representation participate directly in a representation, or support the definition of another element of representation, or both.

  EXAMPLE 4   A point could be the only element in the representation of the location of a product, or it could serve as the end point of a line that is the only element in the representation of the edge of a product. In the first case the point itself is an element in a representation directly. In the second case, the point serves only to provide definition for the line entity.

  EXAMPLE 5   An element of representation that specifies the presentation of a text string could be part of the description of a drawing. In this case it participates directly in a representation. The same element of representation could, alternatively, be part of a dimension callout. In this second case the text is part of the callout, and participates indirectly in the description of the drawing.

  NOTE 3   Elements of representation that describe the presentation of text strings are specified in ISO 10303-46 [6]. Elements of representation that describe dimension callouts are described in ISO 10303-101 [8].

• Elements of representation can refer to each other, thereby forming graphs of such elements in which each graph has an identifiable root. The association of a root element with a context associates all elements in the graph with the context.

  EXAMPLE 6   A curve is defined by a number of points. These points are all in the same coordinate space as the curve by virtue of their reference from the curve.

• Elements of representation are collected into representations and associated with contexts as a basis for establishing relationships between elements.
• An element of representation corresponds to an instance of the representation_item entity data type.
• An association of one or more elements of representation with a context corresponds to an instance of the representation entity data type.

The following concepts and assumptions apply to the portions of this schema that deal with the association of representations:

• A representation can be related to another representation.
• One representation can be related to another representation such that they both participate in the association, but one does not define the other. This type of association corresponds to the representation_relationship entity data type.
• One representation can be related to another representation such that the first is part of the definition of the second. This type of association corresponds to the mapped_item and representation_map entity data types.

The following concepts and assumptions apply to the portions of this schema that deal with the association of items within representations:

• Two collections of representation elements can be in two separate, unrelated, contexts, and yet be related in a third context, or be related only as they both participate in a relating structure.

EXAMPLE 7   Two collections of points and lines each represent the shape of different parts. Each of those representations exists in a context independent and completely unrelated to the other. A third context exists for the shape of an assembly of which these parts are components. In this third context, all of the elements are related through a collection of associations of the representation of each part with the representation of the assembly. There is an association of the representation of a part with the representation of an assembly for each usage of that part in the assembly.

EXAMPLE 8   Two collections of points and lines each represent the shape of different parts. Each of those representations exists in a context independent and completely unrelated to the other. A third context exists for the shape of an assembly of which these parts are components. In this third context, all of the elements are related through a third collection of those elements that specifies that assembly context.

The following concepts and assumptions apply to the portions of this schema that deal with the association of items within representations using an individual relationship structure:

• Each representation_item in one representation can be transformed to a corresponding representation_item in another representation using a single transformation.
• A transformation corresponds to a representation_relationship_with_transformation, where that member of representation_relationship_with_transformation specifies either an item_defined_transformation or a functionally_defined_transformation by the attribute transformation_operator.
• An explicit transformation can be defined by a member of representation_relationship_with_transformation when that member specifies a functionally_defined_transformation in the defined type transformation by the attribute transformation_operator.
• An implicit transformation can be defined by a member of representation_relationship_with_transformation when that member specifies an item_defined_transformation in the defined type transformation by the attribute transformation_operator.

NOTE 4   Association of items within representations using an individual relationship structure can be specified in annotated EXPRESS schemas that use or specialize this schema.

The following concepts and assumptions apply to the portions of this schema that deal with the association of items within representations using an aggregate structure:

• A pair of representation_items so related have no mathematical relationship to each other as a consequence of being so related.
• A pair of representation_items so related can be included in an aggregate set_item_defined_transformation in the defined data type transformation that is specified by a member of representation_relationship_with_transformation.

EXAMPLE 9   Two collections of representation_items each represent different properties of a part. One representation is for functional properties. The second representation is for shape properties. Functional and shape properties are unrelated. Each collection is a representation. It is desired to efficiently specify a user defined association between a user selected representation_item in the functional collection and a user selected representation_item in the shape collection. The aggregate set_item_defined_transformation specifies a set of item_defined_transformation members that the user populated to associate corresponding representation_items. The aggregate set_item_defined_transformation is referenced by a member of representation_relationship_with_transformation in the role of transformation_operator.

NOTE 5   Association of items within representations using an aggregate structure can be specified in annotated EXPRESS schemas that use or specialize this schema.

The following concepts and assumptions apply to the portions of this schema that deal with transformations:

• Elements in different representations can be compared if:
  1. the representations have the same context, or
  2. a transformation is defined that relates the representations to each other.
• A transformation takes each element a in A and maps it to an element b in B using a transformation operator (->).
• The complete specification of a transformation requires the following:
  1. the set of elements a to be transformed;
  2. the set of elements b resulting from the transformations;
  3. the definition of the context A that is common to the set of elements a;
  4. the definition of the context B that is common to the set of elements b;
  5. the definition of the transformation operator (->).

The domain A and the range B are instances of the representation_context entity data type. The elements a and b are instances of the representation_item entity data type. The element a is an element in a representation whose context is A; the element b is an element in a representation whose context is B

Two different approaches are used in this document to specify transformation operators.

1. The transformation operator can be specified. This type of transformation uses a transformation operator that corresponds to the functionally_defined_transformation entity data type.

   EXAMPLE 10   Two representations are related such that one is rotated and skewed with respect to the other. This can be represented by a transformation that specifies a functionally_defined_transformation that is represented by a matrix.

   NOTE 6   The data structures for particular kinds of functionally_defined_transformation, such as matrices, are not specified in this part of ISO 10303.

   EXAMPLE 11   Two representations exist: one consists of a three-dimensional surface that represents the surface of the earth; the other consists of points on a two-dimensional picture. They are related by a transformation (that includes a functionally_defined_transformation) that transforms the three-dimensional surface to a two-dimensional picture, and applies a scaling factor.

2. An element a in context A and an element b in context B that are sufficient to derive the transformation can be specified. This type of transformation uses a transformation operator that corresponds to the item_defined_transformation entity data type, or to the mapping defined by the mapped_item entity data type.

   EXAMPLE 12   A translation between coordinate spaces can be uniquely determined by two instances of representation r1 and r2, two instances of representation_context A and B (A referenced by r1 and B referenced by r2), and two instances of axis2_placement_3d a1 and b1 (a1in r1 and b1in r2), such that the transformation operator specifies a1 and b1. A receiving application would calculate an appropriate transform from that data population and apply it to each of the elements in r1 to create an updated model in the application memory.

   NOTE 7   The axis2_placement_3d entity data type is defined in ISO 10303-42 [4].

Numeric values that are measured or calculated can be imprecise. Uncertainty is a measure of the interval of confidence associated with this imprecision. In this International Standard, uncertainty can be specified for:

1. multiple representations that share a common context;
2. individual representations;
3. individual elements of representation.

This part of ISO 10303 supports (1) and (2).

NOTE 8   (3) is supported by ISO 10303-45 [5].

NOTE 9   Uncertainty is unrelated to the subject of tolerances or permitted variations. These are supported by ISO 10303-47 [7].

The following concepts and assumptions apply to the portions of this schema that deal with uncertainty:

• The uncertainty for numeric values can be specified for all the representations that share a context. This is specified using the global_uncertainty_assigned_context entity data type.
• The uncertainty for numeric values can be specified for a representation in a given context. This is specified using the uncertainty_assigned_representation entity data type.

If uncertainties are specified more than once, the following precedence rules shall apply. The uncertainty specified for an individual element of representation shall have precedence over the uncertainty specified by any uncertainty_assigned_representation in which the item participates. The uncertainty specified by an uncertainty_assigned_representation shall have precedence over the uncertainty specified by any global_uncertainty_assigned_context in which the representation participates.

NOTE 10   Uncertainty for an individual element of representation is specified by the qualified_representation_item entity data type, defined in ISO 10303-45 [5].

4.3 representation_schema type definitions

4.3.1 compound_item_definition   

EXPRESS specification:

*)
TYPE compound_item_definition = SELECT
   (list_representation_item,
    set_representation_item);
END_TYPE;
(*

4.3.2 founded_item_select   

EXPRESS specification:

*)
TYPE founded_item_select = SELECT
   (founded_item,
    representation_item);
END_TYPE;
(*

4.3.3 list_representation_item   

EXPRESS specification:

*)
TYPE list_representation_item = LIST[1:?] OF representation_item;
END_TYPE;
(*

4.3.4 representation_or_representation_reference   

EXPRESS specification:

*)
TYPE representation_or_representation_reference = SELECT
   (representation,
    representation_reference);
END_TYPE;
(*

4.3.5 rs_description_attribute_select   

EXPRESS specification:

*)
TYPE rs_description_attribute_select = SELECT BASED_ON description_attribute_select WITH
   (representation);
END_TYPE;
(*

4.3.6 rs_id_attribute_select   

EXPRESS specification:

*)
TYPE rs_id_attribute_select = SELECT BASED_ON id_attribute_select WITH
   (representation);
END_TYPE;
(*

4.3.7 set_item_defined_transformation   

EXPRESS specification:

*)
TYPE set_item_defined_transformation = SET[1:?] OF item_defined_transformation;
END_TYPE;
(*

4.3.8 set_representation_item   

EXPRESS specification:

*)
TYPE set_representation_item = SET[1:?] OF representation_item;
END_TYPE;
(*

4.3.9 transformation   

EXPRESS specification:

*)
TYPE transformation = SELECT
   (item_defined_transformation,
    functionally_defined_transformation,
    set_item_defined_transformation);
END_TYPE;
(*

4.4 representation_schema entity definitions

4.4.1 binary_representation_item   

EXPRESS specification:

*)
ENTITY binary_representation_item
  SUBTYPE OF (representation_item);
  binary_value : BINARY;
END_ENTITY;
(*

Attribute definitions:

binary_value: the value of the element of representation.

4.4.2 bytes_representation_item   

EXPRESS specification:

*)
ENTITY bytes_representation_item
  SUBTYPE OF (binary_representation_item);
DERIVE
  no_of_bytes : INTEGER := BLENGTH(SELF\binary_representation_item.binary_value) DIV 8;
WHERE
  WR1: BLENGTH(SELF\binary_representation_item.binary_value) MOD 8 = 0;
END_ENTITY;
(*

Attribute definitions:

no_of_bytes: the number of bytes of the element of representation.

Formal propositions:

WR1: The number of bits in binary_value shall be a multiple of 8.

4.4.3 compound_representation_item   

NOTE 1   A compound_representation_item supports the description of aspects of product data using structured collections.

NOTE 2   The meaning and usage of a structured collection of instances of representation_item can be specified in an annotated EXPRESS listing that uses or specializes this entity data type.

EXAMPLE    In an application protocol in the domain of ship design, hydrostatic properties of the ship hull can be represented using a tabular structure composed of instances of list_representation_item.

EXPRESS specification:

*)
ENTITY compound_representation_item
  SUBTYPE OF (representation_item);
  item_element : compound_item_definition;
END_ENTITY;
(*

Attribute definitions:

item_element: the list_representation_item or set_representation_item whose component instances of representation_item define the compound_representation_item.

4.4.4 definitional_representation   

EXPRESS specification:

*)
ENTITY definitional_representation
  SUBTYPE OF (representation);
WHERE
  WR1: 'REPRESENTATION_SCHEMA.PARAMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF (SELF\representation.context_of_items );
END_ENTITY;
(*

Formal propositions:

WR1: The context of the definitional_representation shall be a parametric_representation_context.

4.4.5 definitional_representation_relationship   

NOTE    A representation_relationship by itself is not making one representation part of the definition of the other like it is the case with mapped_item. The definitional_representation_relationship acts in a similar way as mapped_item.

EXPRESS specification:

*)
ENTITY definitional_representation_relationship
  SUBTYPE OF (representation_relationship);
WHERE
  WR1: acyclic_representation_relationship(SELF, [SELF\representation_relationship.rep_2], 'REPRESENTATION_SCHEMA.'+'REPRESENTATION');
END_ENTITY;
(*

Formal propositions:

WR1: The definitional_representation_relationship shall not participate in cycles.

4.4.6 definitional_representation_relationship_with_same_context   

EXPRESS specification:

*)
ENTITY definitional_representation_relationship_with_same_context
  SUBTYPE OF (definitional_representation_relationship);
WHERE
  WR1: SELF\representation_relationship.rep_1.context_of_items :=: SELF\representation_relationship.rep_2.context_of_items;
END_ENTITY;
(*

Formal propositions:

WR1: Two referenced representations shall have the same context instance.

4.4.7 founded_item   

NOTE 1   This entity data type allows errors in other parts of ISO 10303 to be corrected in an upwardly compatible manner. Specifically, it is a supertype of the entity data types composite_curve_segment and surface_patch, defined in ISO 10303-42 [4], and view_volume, defined in ISO 10303-46 [6].

NOTE 2   This entity data type is not intended to be instantiated as a complex instance of two or more of its defined subtypes composite_curve_segment, surface_patch, and view_volume.

NOTE 3   This entity data type is not intended for any other use apart from the correction of the errors in other parts of ISO 10303 listed in NOTE 1 above.

EXAMPLE    A bounded_curve that is the parent curve of a composite_curve_segment is founded as a result of the composite_curve_segment being a founded_item that is part of a representation_item (a composite_curve).

NOTE 4   The bounded_curve, composite_curve, and geometric_representation_context entity types are defined in ISO 10303-42 [4].

EXPRESS specification:

*)
ENTITY founded_item;
DERIVE
  users : SET[0:?] OF founded_item_select := using_items(SELF,[]);
WHERE
  WR1: SIZEOF(users) > 0;
  WR2: NOT(SELF IN users);
END_ENTITY;
(*

Attribute definitions:

users: the set of representation_item or other founded_item that directly or indirectly uses this instance.

Formal propositions:

WR1: There shall be at least one user. Together with WR2 this ensures that a founded_item will be used by at least one representation_item.

WR2: The graph of all users shall be acyclic.

4.4.8 functionally_defined_transformation   

NOTE 1   The transformation operator can be specified in an annotated EXPRESS schema that uses or specializes this entity data type, or in an agreement of common understanding between the partners sharing this information.

NOTE 2   The transformation function is represented by the representation_relationship_with_transformation that references a functionally_defined_transformation in the role of transformation_operator.

EXAMPLE 1   Let f be the transformation function between domain A and range B. The function f:A->B takes each element a in A and maps it to an element b in B, i.e., f(a)=b, using the transformation operator (->).

EXAMPLE 2   An annotated EXPRESS schema defines a subtype x_y_plane_mirror_transformation_operator of this entity type; the definition of the subtype would state that the nature of the x_y_plane_mirror_transformation_operator is to mirror all instances of representation_item in the x-y plane, when referenced by a member of representation_relationship_with_transformation.

EXAMPLE 3   An annotated EXPRESS schema associates different natural language translation functions with the values ‘English to French’ and ‘French to English’, where these are populations of the description attribute of functionally_defined_transformation when referenced by a member of representation_relationship_with_transformation.

EXPRESS specification:

*)
ENTITY functionally_defined_transformation;
  name : label;
  description : OPTIONAL text;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the functionally_defined_transformation is known.

description: the text that characterizes the functionally_defined_transformation. The value of the description need not be specified.

4.4.9 global_uncertainty_assigned_context   

NOTE    The precedence rules that apply to uncertainties in numeric quantities are specified in Clause Fundamental concepts and assumptions, Uncertainty.

EXAMPLE    An instance of global_uncertainty_assigned_context specifies uncertainty of 0.01m with respect to lengths. Unless modified by the precedence rules specified in 4.2, this uncertainty applies to each length that occurs in each representation_item associated with a representation that has this global_uncertainty_assigned_context.

EXPRESS specification:

*)
ENTITY global_uncertainty_assigned_context
  SUBTYPE OF (representation_context);
  uncertainty : SET[1:?] OF uncertainty_measure_with_unit;
END_ENTITY;
(*

Attribute definitions:

uncertainty: the instances of uncertainty_measure_with_unit that apply in the representation_context.

4.4.10 item_defined_transformation   

NOTE 1   A member of representation_relationship_with_transformation provides the transformation context and directly references an item_defined_transformation in the role of transformation_operator.

EXPRESS specification:

*)
ENTITY item_defined_transformation;
  name : label;
  description : OPTIONAL text;
  transform_item_1 : representation_item;
  transform_item_2 : representation_item;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the item_defined_transformation is known.

NOTE 2   The name could designate a particular instance of item_defined_transformation, or the kind of information that an instance of item_defined_transformation conveys.

description: the text that characterizes the item_defined_transformation. The value of the description need not be specified.

transform_item_1: the first instance of representation_item that describes the transformation operator.

transform_item_2: the second instance of representation_item that describes the transformation operator.

EXAMPLE 1   This is an example of interpretation one. Consider one representation having a set of instances of representation_item and a context that is a cartesian coordinate space and a second representation with another set of instances of representation_item and a context that is a second cartesian coordinate space. These instances of representation are related by rigid motion in a representation_relationship_with_transformation that uses an item_defined_transformation. The transform_item_1 and transform_item_2 might each be an axis2_placement_3d where each is in the respective cartesian coordinate space. The meaning of such a representation_relationship would be to relate the two instances of representation such that the transformation between the two instances of axis2_placement_3d applies to every element in the representations.

EXAMPLE 2   This is an example of interpretation two. Consider a graph model having a representation with a set of instances of representation_item (representing node names) and a context that is an ISO/IEC 10646[N] character set (cells 21-7E), and a second representation that contains a set of advanced_faces with a context that is a cartesian coordinate space. These instances of representation are related in a representation_relationship_with_transformation that uses an aggregate of item_defined_transformation through set_item_defined_transformation. For one member in the set, the transform_item_1 is a descriptive_representation_item d1 with a name value of ‘1’ and a description attribute value of ‘node name’. The transform_item_2 is an advanced_face af1 in the cartesian coordinate space c2. The meaning of such a representation_relationship would be to relate the two instances of representation such that the node ‘1’ is associated with af1.

4.4.11 mapped_item   

NOTE 1   See 4.2 for the fundamental concepts and assumptions that apply to this entity data type.

NOTE 2   The mapping includes a transformation that is derived from the mapping_source.mapping_origin and the mapping_target attributes. See 4.2 for the fundamental concepts and assumptions that apply to transformation.

NOTE 3   The precise meaning of the mapping can be specified in an annotated EXPRESS schema that uses or specializes this entity data type and the representation_map entity data type, or in an agreement of common understanding between the partners sharing this information.

EXAMPLE    Figure 2 illustrates the use of the mapped_item and representation_map entity data types. Three instances of representation are shown. The first representation R1 consists of geometry G1 and an axis2_placement_3d A1. The second representation R2 consists of geometry G2 and an axis2_placement_3d A2. For the purpose of this example, the nature and structure of G1 and G2 are not relevant. R1 represents the shape of a roof. R2 represents the shape of some walls.

Two instances of representation_map allow R1 and R2 to be used as elements in a third representation, R3. R3 represents the shape of the building. The first instance of representation_map RM1 references R1 as its mapped_representation and A1 as its mapping_origin. The second instance of representation_map RM2 references R2 as its mapped_representation and A2 as its mapping_origin.

R3 contains as its items an axis2_placement_3d and two instances of mapped_item, M1 and M2. M1 references RM1 as its mapping_source and A3 as its mapping_target. M2 references RM2 as its mapping_source and A3 as its mapping_target. The result is that R3 uses R1 and R2 as parts of its definition. As it is used in R3, R1 is transformed so that A1 is mapped onto A3. As it is used in R3, R2 is transformed so that A2 is mapped onto A3.

This example shows how the mapped_item and representation_map entity data types can be used to describe the composition of one representation from other instances of representation. See 4.4.14 for an example of the use of representation_relationship to describe whole-part associations between instances of representation.

EXPRESS specification:

*)
ENTITY mapped_item
  SUBTYPE OF (representation_item);
  mapping_source : representation_map;
  mapping_target : representation_item;
WHERE
  WR1: acyclic_mapped_representation(SELF);
END_ENTITY;
(*

Attribute definitions:

mapping_source: the representation_map that specifies the source and the origin of the mapped_item.

mapping_target: the representation_item that is the target onto which the mapping_source is mapped.

Formal propositions:

WR1: A mapped_item shall not be self-defining by participating in the definition of the representation being mapped.

4.4.12 parametric_representation_context   

NOTE 1   The definition of the parametric space can be specified in an annotated EXPRESS schema that uses or specializes this entity data type.

NOTE 2   In a parametric_representation_context, length units are dimensionless.

EXPRESS specification:

*)
ENTITY parametric_representation_context
  SUBTYPE OF (representation_context);
END_ENTITY;
(*

4.4.13 representation   

NOTE 1   The use of a representation, i.e., that which is being represented, is not specified in this part of ISO 10303. It can be specified in an annotated EXPRESS schema that uses or specializes this entity data type.

The relationship of representation_item to representation_context is the basis for distinguishing which representation_item entities are related.

EXAMPLE 1   Two cartesian points P and Q (described by instances of representation_item) are related in a context A (they are elements in the same representation in context A, or are elements in different representations that share context A). It is therefore possible to calculate the distance between these points. A third cartesian point R (also described by an instance of representation_item) is not related to context A. It is not possible to determine the distance between R and P, or between R and Q.

A representation_item can be related to a representation_context directly, when it occurs as an element in a representation, or indirectly, when it is referenced through any number of intervening entities, each of type representation_item or founded_item.

A representation relates a representation_context to trees of representation_item instances each tree being rooted in one member of the set of items. A representation_item or founded_item is one node in the tree; a relationship between one representation_item or founded_item and another is an edge.

NOTE 2   Instances of representation_item_relationship do not form either nodes or edges in this tree; an instance of representation_item is not part of the tree solely because it is associated with an element in the tree by an instance of representation_item_relationship.

NOTE 3   A representation can be incomplete in that it need not fully model the concept that is represented, although it could be adequate for a given application.

EXAMPLE 2   Consider a collection of two-dimensional representation_item instances used to represent the shape of a machined part. It is not a complete description of the shape, but is suitable for certain applications such as computer-aided draughting.

NOTE 4   Two instances of representation are not related solely because the same instance of representation_item is referenced directly or indirectly from their sets of items.

EXAMPLE 3   Consider a surface that is used in the respective representations of the shape of a casting die and of the shape of the part cast in that die. The same surface is related to two distinct instances of representation_context (i.e., coordinate spaces): one for the die and one for the part by the two instances of representation. However, the two instances of representation are not related; they simply share a common representation_item.

NOTE 5   Two instances of representation are not related solely because instances of representation_item in their sets of items are related by an instance of representation_item_relationship.

EXPRESS specification:

*)
ENTITY representation;
  name : label;
  items : SET[1:?] OF representation_item;
  context_of_items : representation_context;
DERIVE
  id : identifier := get_id_value (SELF);
  description : text := get_description_value (SELF);
WHERE
  WR1: SIZEOF (USEDIN (SELF, 'BASIC_ATTRIBUTE_SCHEMA.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
  WR2: SIZEOF (USEDIN (SELF, 'BASIC_ATTRIBUTE_SCHEMA.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the representation is known.

NOTE 6   The name could designate a particular instance of representation, or the kind of information that an instance of representation conveys.

items: a set of representation_items that are related in the context_of_items.

context_of_items: a representation_context in which the items are related to form a representation of some concept.

id: the identifier that distinguishes the representation.

NOTE 7   This attribute is an upwardly compatible addition to representation as specified in the first edition of this part of ISO 10303.

description: the text that characterizes the representation.

NOTE 8   This attribute is an upwardly compatible addition to representation as specified in the first edition of this part of ISO 10303.

Formal propositions:

WR1: Each representation shall be the identified_item in at most one id_attribute.

NOTE 9   The id_attribute entity data type is defined in the basic_attribute_schema in ISO 10303-41.

WR2: Each representation shall be the named_item in at most one name_attribute.

NOTE 10   The name_attribute entity data type is defined in the basic_attribute_schema in ISO 10303-41.

NOTE 11   A template for constraining the population of the entity data types defined in the basic_attribute_schema is described in Annex E of ISO 10303-41.

Informal propositions:

IP1: A set_item_defined_transformation is in the role of transformation_operator, the ordering of the instances of representation given for the inherited attributes of representation_relationship shall be consistent with the ordering of the two instances of representation_item given as attributes of members of item_defined_transformation that are in the set_item_defined_transformation.

4.4.14 representation_context   

NOTE 1   Two instances of representation_context are separate and have no relationship unless a relationship is explicitly specified between them in an annotated EXPRESS schema that uses or specializes this entity data type.

EXPRESS specification:

*)
ENTITY representation_context;
  context_identifier : identifier;
  context_type : text;
INVERSE
  representations_in_context : SET[1:?] OF representation FOR context_of_items;
END_ENTITY;
(*

Attribute definitions:

context_identifier: the identifier that distinguishes the representation_context.

context_type: a description of the type of the representation_context.

NOTE 2   Constraints on the uniqueness of context_identifier, or the allowed values of context_type, can be specified in an annotated EXPRESS schema that uses or specializes this entity data type.

representations_in_context: the instances of representation that refer to the representation_context.

4.4.15 representation_context_reference   

EXPRESS specification:

*)
ENTITY representation_context_reference;
  context_identifier : identifier;
INVERSE
  representations_in_context : SET[1:?] OF representation_reference FOR context_of_items;
END_ENTITY;
(*

Attribute definitions:

context_identifier: the identifier that distinguishes the representation_context_reference.

representations_in_context: the instances of representation that refer to the representation_context_reference.

4.4.16 representation_item   

NOTE 1   One representation_item contributes to the definition of a second representation_item if the first is referenced by the second.

NOTE 2   The same representation_item could be related multiple times to the same representation_context by being used directly or indirectly in several instances of representation, each referencing the same representation_context. This does not have the meaning that each representation is creating a new instance of the same representation_item in the same representation_context. Rather, each representation reasserts the use of the same instance of representation_item in the representation_context for different uses.

EXAMPLE 1   Consider two instances of representation, each having the same value for context_of_items. One is a representation of the shape of a cube and indirectly references a line as one of its edges. The second simply references the line as one of its items. There are not two occurrences of the line and its sub-tree of referenced instances of representation_item in the representation_context. Rather, the use of the line in that geometric_representation_context has been asserted twice, once in each representation.

EXAMPLE 2   The compound_representation_item entity data type provides a general capability to define one representation_item using other instances of representation_item. This can be used to create tabular structures: each cell in the table is a representation_item (such as a measure_representation_item that provides a name-value-unit tuple), and the table is itself a representation_item that participates in the representation of a product property. The representation_item instances that are the cells in the table do not participate directly in the representation.

EXPRESS specification:

*)
ENTITY representation_item
  SUPERTYPE OF (ONEOF (binary_representation_item,
                       compound_representation_item,
                       mapped_item,
                       value_representation_item));
  name : label;
WHERE
  WR1: SIZEOF(using_representations(SELF)) > 0;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the representation_item is known.

NOTE 3   The name could designate a particular instance of representation_item or the kind of information that an instance of representation_item conveys.

Formal propositions:

WR1: The representation_item shall participate in at least one representation, either as an item in that representation or being directly or indirectly referenced by an item in the representation.

4.4.17 representation_item_relationship   

NOTE 1   The meaning of the association can be specified in an annotated EXPRESS schema that uses or specializes this entity, or in an agreement of common understanding between the partners sharing this information.

EXPRESS specification:

*)
ENTITY representation_item_relationship;
  name : label;
  description : OPTIONAL text;
  relating_representation_item : representation_item;
  related_representation_item : representation_item;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the representation_item_relationship is known.

NOTE 2   The name could designate a particular instance of representation_item_relationship or the kind of information that an instance of representation_item_relationship conveys.

description: the text that characterizes the representation_item_relationship. The value of the description need not be specified.

relating_representation_item: one of the instances of representation_item that participates in the association.

NOTE 3   The role of this attribute can be defined in an annotated EXPRESS schema that uses or specializes this entity data type.

related_representation_item: the other instance of representation_item that participates in the association. If one element of the association is dependent upon the other, this attribute shall be the dependent one.

NOTE 4   The role of this attribute can be defined in an annotated EXPRESS schema that uses or specializes this entity data type.

4.4.18 representation_map   

NOTE    An instance of representation_map is used as the source of a mapping by an instance of mapped_item. See 4.4.7 for an example of the use of these two entity data types.

EXPRESS specification:

*)
ENTITY representation_map;
  mapping_origin : representation_item;
  mapped_representation : representation;
INVERSE
  map_usage : SET[1:?] OF mapped_item FOR mapping_source;
WHERE
  WR1: item_in_context(mapping_origin, mapped_representation\representation.context_of_items);
END_ENTITY;
(*

Attribute definitions:

mapping_origin: a representation_item from which the mapped_representation is to be mapped.

mapped_representation: a representation that is to be mapped to at least one mapped_item.

map_usage: the set of one or more instances of mapped_item to which the representation_map is mapped.

Formal propositions:

WR1: The mapping_origin shall be in the representation_context of the mapped_representation.

4.4.19 representation_reference   

EXPRESS specification:

*)
ENTITY representation_reference;
  id : identifier;
  context_of_items : representation_context_reference;
END_ENTITY;
(*

Attribute definitions:

id: the identifier that distinguishes the representation_reference.

context_of_items: the representation_context_reference in which the items are related to form a representation_reference of some concept.

4.4.20 representation_relationship   

NOTE 1   The meaning of the association can be specified in an annotated EXPRESS schema that uses or specializes this entity, or in an agreement of common understanding between the partners sharing this information.

EXAMPLE    Two instances of representation_or_representation_reference each describe a property of a product. The second of these instances is a more complete and accurate description of the property. An instance of representation_relationship can be used to denote the second instance of representation_or_representation_reference as being the successor of the first.

NOTE 2   A combination of instances of representation_or_representation_reference and representation_relationship can form a graph of related instances of representation_or_representation_reference. In such a graph, instances of representation are the nodes and instances of representation_relationship are the branches connecting the nodes.

NOTE 3   Constraints can be specified that ensure that such a graph is acyclic, i.e., that no instance of representation_or_representation_reference is its own ancestor. Such constraints are outside the scope of this part of ISO 10303.

EXPRESS specification:

*)
ENTITY representation_relationship;
  name : label;
  description : OPTIONAL text;
  rep_1 : representation_or_representation_reference;
  rep_2 : representation_or_representation_reference;
END_ENTITY;
(*

Attribute definitions:

name: the label by which the representation_relationship is known.

NOTE 4   The name could designate a particular instance of representation_relationship or the kind of information that an instance of representation_relationship conveys.

description: the text that characterizes the representation_relationship. The value of the description need not be specified.

rep_1: the first of two representations that are related.

rep_2: the second of two representations that are related.

NOTE 5   There is no significance to the ordering of the two related instances of representation. The names rep_1 and rep_2 serve only to distinguish the attributes. If any significance to the ordering is needed in any specialization of representation_relationship, this significance can be defined in the specialization.

4.4.21 representation_relationship_with_transformation   

NOTE 1   The interpretation of the relationship between the two contexts depends on the value of the transformation_operator attribute.

EXAMPLE 1   Figure 3 illustrates the use of the representation_relationship_with_transformation entity data type where the transformation_operator is an item_defined_transformation Three instances of representation are shown. The first representation R1 contains some geometry G1 and an axis2_placement_3d A1. The second representation contains some geometry G2 and an axis2_placement_3d A2. For the purpose of this example, the nature and structure of G1 and G2 are not relevant. R1 represents the shape of a roof. R2 represents the shape of some walls.

Two instances of representation_relationship_with_transformation allow R1 and R2 to be associated with a third representation, R3. R3 represents the shape of the building. R3 contains a single item: an axis2_placement_3d. The associations between R1 and R3, and between R2 and R3, do not make R1 and R2 parts of R3. However, the associations between R1 and R3, and between R2 and R3, allow an application to infer that G1 and G2 can be combined and used to describe the shape of the building. An application can make use of the specified transformations to compose the overall shape from G1 and G2.

NOTE 2   See the example given for mapped_item and its use of representation_map to describe the composition of one representation from other instances of representation. .

EXAMPLE 2   This example illustrates the use of the representation_relationship_with_transformation entity data types where the transformation_operator is a functionally_defined_transformation. Two instances of representation contain instances of descriptive_representation_item, an element of representation that specifies the use of a text string for representation, and two references to representation_context instances that define human languages for context. The first instance of representation contains descriptions in the English language; and the second contains descriptions in the French language. An instance of representation_relationship_with_transformation could be used to assert an association between these instances of representation, where the referenced functionally_defined_transformation is a language translation table. The descriptive_representation_item entity data type is defined in ISO 10303-45 [5].

EXPRESS specification:

*)
ENTITY representation_relationship_with_transformation
  SUBTYPE OF (representation_relationship);
  transformation_operator : transformation;
WHERE
  WR1: SELF\representation_relationship.rep_1.context_of_items :<>: SELF\representation_relationship.rep_2.context_of_items;
  WR2: NOT('REPRESENTATION_SCHEMA.ITEM_DEFINED_TRANSFORMATION' IN TYPEOF(transformation_operator)) OR (SELF\representation_relationship.rep_1 IN using_representations(transformation_operator\item_defined_transformation.transform_item_1)) AND (SELF\representation_relationship.rep_2 IN using_representations(transformation_operator\item_defined_transformation.transform_item_2));
END_ENTITY;
(*

Attribute definitions:

transformation_operator: a transformation that relates the context_of_items of the two related representations.

Formal propositions:

WR1: The two related representations shall not have the same representation_context.

WR2: If the transformation_operator is an item_defined_transformation, the ordering of the instances of representation given for the inherited attributes of representation_relationship shall be consistent with the ordering of the two instances of representation_item given as attributes of item_defined_transformation.

Informal propositions:

IP1: If the transformation is an item_defined_transformation, then transform_item_1 shall be in the context of rep_1 and transform_item_2 shall be in the context of rep_2.

IP2: If a set_item_defined_transformation is in the role of transformation_operator, no item_defined_transformation that is a member of the set shall reference a placement type in both the transform_item_1 attribute and the transform_item_2 attribute.

4.4.22 uncertainty_assigned_representation   

EXAMPLE    This entity data type can be used to specify the uncertainties that apply to the numeric values used to represent a property. For example, in an application protocol whose domain is acoustical engineering, there could be an uncertainty of 1 decibel in the values that represent the relative loudness of sounds.

NOTE    The precedence rules that apply to uncertainty in numeric quantities are specified in 4.2.

EXPRESS specification:

*)
ENTITY uncertainty_assigned_representation
  SUBTYPE OF (representation);
  uncertainty : SET[1:?] OF uncertainty_measure_with_unit;
END_ENTITY;
(*

Attribute definitions:

uncertainty: the set of instances of uncertainty_measure_with_unit that apply to instances of representation_item in the uncertainty_assigned_representation.

4.4.23 uncertainty_measure_with_unit   

• the representation_item is part of an uncertainty_assigned_representation;
• the representation_item is founded in a global_unit_assigned_context; or
• the representation_item is a qualified_representation_item.

NOTE    The qualified_representation_item entity data type is defined in ISO 10303-45 [5].

EXPRESS specification:

*)
ENTITY uncertainty_measure_with_unit
  SUBTYPE OF (measure_with_unit);
  name : label;
  description : OPTIONAL text;
WHERE
  WR1: valid_measure_value (SELF\measure_with_unit.value_component);
END_ENTITY;
(*

Attribute definitions:

name: the label by which the uncertainty_measure_with_unit is known.

description: the text that characterizes the uncertainty_measure_with_unit. The value of the description need not be specified.

Formal propositions:

WR1: The value_component of the uncertainty_measure_with_unit shall be a positive number if the type of the value_component is a number.

4.4.24 value_representation_item   

NOTE 1   The global_unit_assigned_context entity data type, subtype of representation_context, is defined in ISO 10303-41.

NOTE 2   The measure_representation_item entity data type, specified in ISO 10303-45 [5], is an element of representation that consists of a value and a unit.

EXPRESS specification:

*)
ENTITY value_representation_item
  SUBTYPE OF (representation_item);
  value_component : measure_value;
WHERE
  WR1: SIZEOF (QUERY (rep <* using_representations (SELF) | NOT ('MEASURE_SCHEMA.GLOBAL_UNIT_ASSIGNED_CONTEXT' IN TYPEOF (rep.context_of_items) ))) = 0;
END_ENTITY;
(*

Attribute definitions:

value_component: the value of the element of representation when expressed with in the unit specified in the global_unit_assigned_context.

Formal propositions:

WR1: Every value_representation_item shall be an item in a representation whose context_of_items attribute references an instance of representation_context that is a global_unit_assigned_context, or shall participate in the definition of such a representation_item.

Informal propositions:

IP1: If a value_representation_item is an item in more than one representation, each representation shall specify the same unit, either by referencing the same global_unit_assigned_context, or by referencing different instances of global_unit_assigned_context that specify the same unit.

4.5 representation_schema function definitions

4.5.1 acyclic_mapped_representation

The function acyclic_mapped_representation determines if a given mapped_item is self-defining by virtue of mapping a representation in which the mapped_item is used. The function checks both the mapped_representation and the mapped_representation.items recursively for any instances of mapped_item, or representation_item referencing a mapped_item, that might cause a self defining reference.

This function returns TRUE if the input candidate representation_item does not cause self definition. It returns FALSE otherwise. The type of the function is BOOLEAN.

NOTE    This function is used to constrain the entity mapped_item.

EXPRESS specification:

LOCAL
      rms : SET OF representation_map;
      mis : SET OF mapped_item;
      rs1, rs2 : SET OF representation;
    END_LOCAL;
 
    rs1 := using_representations(mi);
    rs2 := [];
    -- loop as long as there are elements in rs1
    REPEAT WHILE SIZEOF(rs1) > 0; 
      REPEAT i := 1 TO HIINDEX(rs1);
        -- Determine the set of representation_map that reference the parent_set
        rms := bag_to_set(USEDIN(rs1[i], 'REPRESENTATION_SCHEMA.REPRESENTATION_MAP.MAPPED_REPRESENTATION'));
        IF SIZEOF(rms) > 0 THEN
          REPEAT j := 1 TO HIINDEX(rms);
            mis := bag_to_set(USEDIN(rms[i], 'REPRESENTATION_SCHEMA.MAPPED_ITEM.MAPPING_SOURCE'));
            IF SIZEOF(mis) > 0 THEN
              REPEAT j := 1 TO HIINDEX(mis);
                -- check mis members for instance equal with mi. If so then there is a cycle
                IF mis[i] :=: mi THEN
                  RETURN (FALSE);
                END_IF;
                rs2 := rs2 + using_representations(mis[i]);
              END_REPEAT;
            END_IF;
          END_REPEAT;
        END_IF;
      END_REPEAT;
      rs1 := rs2;
      rs2 := [];
    END_REPEAT;
    RETURN (TRUE);

Argument definitions:

mi: the specified mapped_items.

4.5.2 acyclic_representation_relationship

EXPRESS specification:

LOCAL
      x : SET OF representation_relationship;
    END_LOCAL;

    IF relation.rep_1 IN relatives THEN
      RETURN (FALSE);
    END_IF;
    x := QUERY(r <* bag_to_set(USEDIN(relation.rep_1, 'REPRESENTATION_SCHEMA.' + 'REPRESENTATION_RELATIONSHIP.' + 'REP_2')) | specific_relation IN TYPEOF(r));
    REPEAT i := 1 TO HIINDEX(x);
      IF NOT acyclic_representation_relationship(x[i], relatives + relation.rep_1, specific_relation) THEN
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
    RETURN (TRUE);

Argument definitions:

relation: the specified representation_relationship.

relatives: the specified representations.

specific_relation: the specified type of Representation_relationships to be considered.

4.5.3 get_representations_for_items

EXPRESS specification:

LOCAL
      r_set : SET OF representation := [];
    END_LOCAL;
    REPEAT i := LOINDEX(input) TO HIINDEX(input);
        r_set := r_set + using_representations(input[i]);
    END_REPEAT;
    RETURN (r_set);

Argument definitions:

input: the specified founded items.

4.5.4 item_in_context

The function item_in_context determines if a representation_item is related to a representation_context. The function returns TRUE if the item argument is related by a representation to the input cntxt argument. Function item_in_context returns FALSE otherwise. The type of the function is BOOLEAN.

A representation_item is related to a representation_context if it is:

• referenced in the set of items of a representation where cntxt appears as the context_of_items, or
• referenced by a representation_item that is an item_in_context of the cntxt.

NOTE 1   The second condition is a recursive check allowing for a representation_item to be related to a representation_context by being part of a tree of related instances of representation_item. The tree is rooted in an entity that is related to a representation_context by fulfilling the first or second condition.

NOTE 2   The function item_in_context only determines if an item is related to a specific representation_context. The relationship of the item to some other representation_context is not determined.

EXPRESS specification:

LOCAL
      y : BAG OF representation_item;
    END_LOCAL;
    -- If there is one or more representation using both the item
    -- and cntxt return true.
    IF SIZEOF(USEDIN(item,'REPRESENTATION_SCHEMA.REPRESENTATION.ITEMS')
      * cntxt.representations_in_context) > 0 THEN
      RETURN (TRUE);
      -- Determine the bag of representation_items that reference
      -- item
      ELSE y := QUERY(z <* USEDIN (item , '') |
             'REPRESENTATION_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(z));
        -- Ensure that the bag is not empty
        IF SIZEOF(y) > 0 THEN
        -- For each element in the bag
        REPEAT i := 1 TO HIINDEX(y);
          -- Check to see it is an item in the input cntxt.
          IF item_in_context(y[i], cntxt) THEN
            RETURN (TRUE);
          END_IF;
        END_REPEAT;
      END_IF;
    END_IF;
    -- Return false when all possible branches have been checked
    -- with no success.
    RETURN (FALSE);

Argument definitions:

item: the representation_item checked for relationship in cntxt. This is input to the function.

cntxt: the representation_context for which relationship to item is determined. This is input to the function.

4.5.5 using_items

EXPRESS specification:

LOCAL
      new_check_items    : SET OF founded_item_select;
      result_items       : SET OF founded_item_select;
      next_items         : SET OF founded_item_select;
    END_LOCAL;
    result_items := [];
    new_check_items := checked_items + item;
    -- Find the set of representation_items or founded_items
    -- in which item is used directly.
    next_items := QUERY(z <* bag_to_set( USEDIN(item , '')) |
      ('REPRESENTATION_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(z)) OR
      ('REPRESENTATION_SCHEMA.FOUNDED_ITEM'        IN TYPEOF(z)));
    -- If the set of next_items is not empty;
    IF SIZEOF(next_items) > 0 THEN
      -- For each element in the set, find the using_items recursively
      REPEAT i := 1 TO HIINDEX(next_items);
        -- Check for loop in data model, i.e. one of the next_items
        -- occurred earlier in the set of check_items;
        IF NOT(next_items[i] IN new_check_items) THEN
          result_items := result_items + next_items[i] +
                          using_items(next_items[i],new_check_items);
        END_IF;
      END_REPEAT;
    END_IF;
    -- return the set of representation_items or founded_items
    -- in which the input item is used directly and indirectly.
    RETURN (result_items);

Argument definitions:

item: the representation_item for which the referencing instances of representation_item and founded_item are determined. This is input to the function.

checked_items: the set of instances of representation_item and founded_item that have been checked already in order to ensure termination of the recursive function. This is input to the function.

4.5.6 using_representations

The function using_representations returns the set of representations in which a representation_item is used.

A representation_item is used in a representation if it is:

• referenced in the set of items of the representation,
• referenced by a representation_item used in the representation, or
• referenced by a founded_item used in the representation.

NOTE    The second and third conditions are checks allowing for a representation_item to be used in a representation by being part of a tree of related representation_items or founded_items. The tree is rooted in an entity used in a representation by fulfilling the first condition.

A founded_item or a representation_item is used in a representation if it is referenced directly, or indirectly, by a representation_item in the set of items of the representation.

EXPRESS specification:

LOCAL
      results            : SET OF representation;
      result_bag         : BAG OF representation;
      intermediate_items : SET OF founded_item_select;
    END_LOCAL;
    -- Find the representations in which the item is used and add to the
    -- results set.
    results := [];
    result_bag := USEDIN(item,'REPRESENTATION_SCHEMA.REPRESENTATION.ITEMS');
    IF SIZEOF(result_bag) > 0 THEN
      REPEAT i := 1 TO HIINDEX(result_bag);
        results := results + result_bag[i];
      END_REPEAT;
    END_IF;
    -- Find all representation_items or founded_items
    -- by which item is referenced directly or indirectly.
    intermediate_items := using_items(item,[]);
    -- If the set of intermediate items is not empty;
    IF SIZEOF(intermediate_items) > 0 THEN
      -- For each element in the set, add the
      -- representations of that element.
      REPEAT i := 1 TO HIINDEX(intermediate_items);
        result_bag := USEDIN(intermediate_items[i],
                      'REPRESENTATION_SCHEMA.REPRESENTATION.ITEMS');
        IF SIZEOF(result_bag) > 0 THEN
          REPEAT j := 1 TO HIINDEX(result_bag);
            results := results + result_bag[j];
          END_REPEAT;
        END_IF;
      END_REPEAT;
    END_IF;
    -- Return the set of representation in which the input item is
    -- used directly and indirectly (through intervening
    -- representation_items or founded items).
    RETURN (results);

Argument definitions:

item: the representation_item or founded_item for which using instances of representation are determined. This is input to the function.

4.5.7 valid_measure_value

EXPRESS specification:

IF ('REAL' IN TYPEOF (m)) THEN
    RETURN (m > 0.0);
    ELSE
     IF ('INTEGER' IN TYPEOF (m)) THEN
      RETURN (m > 0);
      ELSE
        RETURN (TRUE);
      END_IF;
    END_IF;

Argument definitions:

m: the measure_value to be checked. This is the input to the function.

© ISO 2021 — All rights reserved