Integrated generic resource: Fundamentals of product description and support ISO 10303-41:2021(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 Action
   4.1 General
   4.2 Fundamental concepts and assumptions
   4.3 Action type definitions
   4.4 Action entity definitions
   4.5 Action function definitions
5 Application context
   5.1 General
   5.2 Fundamental concepts and assumptions
   5.3 Application context type definitions
   5.4 Application context entity definitions
6 Approval
   6.1 General
   6.2 Fundamental concepts and assumptions
   6.3 Approval type definitions
   6.4 Approval entity definitions
   6.5 Approval function definitions
7 Basic attribute
   7.1 General
   7.2 Fundamental concepts and assumptions
   7.3 Basic attribute type definitions
   7.4 Basic attribute entity definitions
   7.5 Basic attribute function definitions
8 Certification
   8.1 General
   8.2 Fundamental concepts and assumptions
   8.3 Certification entity definitions
9 Contract
   9.1 General
   9.2 Fundamental concepts and assumptions
   9.3 Contract entity definitions
   9.4 Contract function definitions
10 Date time
   10.1 General
   10.2 Fundamental concepts and assumptions
   10.3 Date time type definitions
   10.4 Date time entity definitions
   10.5 Date time function definitions

11 Document
   11.1 General
   11.2 Fundamental concepts and assumptions
   11.3 Document type definition
   11.4 Document entity definitions
   11.5 Document function definitions
12 Effectivity
   12.1 General
   12.2 Fundamental concepts and assumptions
   12.3 Effectivity type definitions
   12.4 Effectivity entity definitions
   12.5 Effectivity function definitions
13 Experience
   13.1 General
   13.2 Fundamental concepts and assumptions
   13.3 Experience entity definitions
   13.4 Experience function definitions
14 External reference
   14.1 General
   14.2 Fundamental concepts and assumptions
   14.3 External reference type definitions
   14.4 External reference entity definitions
   14.5 External reference function definitions
15 Group
   15.1 General
   15.2 Fundamental concepts and assumptions
   15.3 Group type definition
   15.4 Group entity definitions
   15.5 Group function definitions
16 Language
   16.1 General
   16.2 Fundamental concepts and assumptions
   16.3 Language entity definition
17 Location
   17.1 General
   17.2 Fundamental concepts and assumptions
   17.3 Location entity definitions
   17.4 Location function definitions
18 Management resources
   18.1 General
   18.2 Fundamental concepts and assumptions
   18.3 Management resources type definitions
   18.4 Management resources entity definitions
   18.5 Management resources function definitions

19 Measure
   19.1 General
   19.2 Fundamental concepts and assumptions
   19.3 Measure type definitions
   19.4 Measure entity definitions
   19.5 Measure function definitions
20 Person organization
   20.1 General
   20.2 Fundamental concepts and assumptions
   20.3 Person organization type definitions
   20.4 Person organization entity definitions
   20.5 Person organization function definitions
21 Product definition
   21.1 General
   21.2 Fundamental concepts and assumptions
   21.3 Product definition type definitions
   21.4 Product definition entity definitions
   21.5 Product definition function definitions
22 Product property definition
   22.1 General
   22.2 Fundamental concepts and assumptions
   22.3 Product property definition type definitions
   22.4 Product property definition entity definitions
   22.5 Product property definition function definitions
23 Product property representation
   23.1 General
   23.2 Fundamental concepts and assumptions
   23.3 Product property representation type definitions
   23.4 Product property representation entity definitions
   23.5 Product property representation function definitions
24 Qualifications
   24.1 General
   24.2 Fundamental concepts and assumptions
   24.3 Qualifications entity definitions
   24.4 Qualifications function definitions
25 Security classification
   25.1 General
   25.2 Fundamental concepts and assumptions
   25.3 Security classification entity definitions
26 Support resource
   26.1 General
   26.2 Fundamental concepts and assumptions
   26.3 Support resource type definitions
   26.4 Support resource function definitions
A Short names of entities
B Information object registration
C Computer interpretable listings
D EXPRESS-G diagrams
E Technical discussion
F Examples
G Change history
Bibliography
Index

(*
ISO/TC 184/SC 4/WG 12 N10355 - ISO 10303-41 Fundamentals of product description and support - EXPRESS
Supersedes ISO/TC 184/SC 4/WG 12 N9685
*)



SCHEMA product_property_representation_schema;

REFERENCE FROM basic_attribute_schema   -- ISO 10303-41
  (description_attribute,
   description_attribute_select,
   get_description_value,
   get_name_value,
   name_attribute,
   name_attribute_select);

REFERENCE FROM material_property_definition_schema   -- ISO 10303-45
  (property_definition_relationship);

REFERENCE FROM product_definition_schema   -- ISO 10303-41
  (product_definition,
   product_definition_relationship);

REFERENCE FROM product_property_definition_schema   -- ISO 10303-41
  (characterized_object,
   characterized_definition,
   general_property,
   product_definition_shape,
   property_definition,
   shape_aspect,
   shape_aspect_relationship);

REFERENCE FROM product_structure_schema   -- ISO 10303-44
  (product_definition_specified_occurrence);

REFERENCE FROM representation_schema   -- ISO 10303-43
  (representation,
   representation_item,
   representation_relationship,
   representation_reference,
   using_representations,
   mapped_item,
   representation_context,
   representation_map,
   list_representation_item,
   set_representation_item,
   get_representations_for_items);

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


TYPE pprs_description_attribute_select = SELECT BASED_ON description_attribute_select WITH
   (context_dependent_shape_representation,
    property_definition_representation);
END_TYPE;

TYPE pprs_name_attribute_select = SELECT BASED_ON name_attribute_select WITH
   (context_dependent_shape_representation,
    property_definition_representation);
END_TYPE;

TYPE chained_representation_link = SELECT
   (mapped_item,
    representation_context,
    representation_relationship);
END_TYPE;

TYPE represented_definition = SELECT
   (general_property,
    property_definition,
    property_definition_relationship,
    shape_aspect,
    shape_aspect_relationship);
END_TYPE;

TYPE item_identified_representation_usage_definition = EXTENSIBLE GENERIC_ENTITY SELECT
   (represented_definition);
END_TYPE;

TYPE item_identified_representation_usage_select = SELECT
   (representation_item,
    list_representation_item,
    set_representation_item);
END_TYPE;

ENTITY chain_based_item_identified_representation_usage
  SUBTYPE OF (item_identified_representation_usage);
  nodes : LIST[2:?] OF UNIQUE representation;
  undirected_link : LIST[1:?] OF chained_representation_link;
DERIVE
  root : representation := nodes[1];
  SELF\item_identified_representation_usage.used_representation RENAMED leaf : representation := nodes[HIINDEX(nodes)];
  directed_link : LIST[1:?] OF representation_relationship := get_directed_link(nodes, undirected_link);
WHERE
  WR1: EXISTS(directed_link);
END_ENTITY;

ENTITY characterized_chain_based_item_within_representation
  SUBTYPE OF (characterized_item_within_representation);
  nodes : LIST[2:?] OF UNIQUE representation;
  undirected_link : LIST[1:?] OF chained_representation_link;
DERIVE
  root : representation := nodes[1];
  SELF\characterized_item_within_representation.rep RENAMED leaf : representation := nodes[HIINDEX(nodes)];
  directed_link : LIST[1:?] OF representation_relationship := get_directed_link(nodes, undirected_link);
WHERE
  WR1: EXISTS(directed_link);
END_ENTITY;

ENTITY characterized_item_within_representation
  SUBTYPE OF (characterized_object);
  item : representation_item;
  rep : representation;
UNIQUE
  UR1: item, rep;
WHERE
  WR1: rep IN using_representations(item);
END_ENTITY;

ENTITY context_dependent_shape_representation;
  representation_relation : shape_representation_relationship;
  represented_product_relation : product_definition_shape;
DERIVE
  description : text := get_description_value(SELF);
  name : label := get_name_value(SELF);
WHERE
  WR1: 'PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_RELATIONSHIP' IN TYPEOF(represented_product_relation\property_definition.definition);
  WR2: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
  WR3: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
END_ENTITY;

ENTITY item_identified_representation_usage;
  name : label;
  description : OPTIONAL text;
  definition : item_identified_representation_usage_definition;
  used_representation : representation;
  identified_item : item_identified_representation_usage_select;
UNIQUE
  UR1: used_representation, identified_item;
  UR2: used_representation, definition;
WHERE
  WR1: valid_identified_item_in_representation(identified_item, used_representation);
END_ENTITY;

ENTITY property_definition_representation;
  definition : represented_definition;
  used_representation : representation;
DERIVE
  description : text := get_description_value(SELF);
  name : label := get_name_value(SELF);
WHERE
  WR1: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
  WR2: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
END_ENTITY;

ENTITY shape_definition_representation
  SUBTYPE OF (property_definition_representation);
  SELF\property_definition_representation.definition : property_definition;
  SELF\property_definition_representation.used_representation : shape_representation;
WHERE
  WR1: ('PRODUCT_PROPERTY_DEFINITION_SCHEMA.PRODUCT_DEFINITION_SHAPE' IN TYPEOF(definition)) OR ('PRODUCT_PROPERTY_DEFINITION_SCHEMA.SHAPE_DEFINITION' IN TYPEOF(definition\property_definition.definition));
END_ENTITY;

ENTITY shape_representation
  SUBTYPE OF (representation);
END_ENTITY;

ENTITY shape_representation_reference
  SUBTYPE OF (representation_reference);
END_ENTITY;

ENTITY shape_representation_relationship
  SUBTYPE OF (representation_relationship);
WHERE
  WR1: SIZEOF(['PRODUCT_PROPERTY_REPRESENTATION_SCHEMA.SHAPE_REPRESENTATION', 'PRODUCT_PROPERTY_REPRESENTATION_SCHEMA.SHAPE_REPRESENTATION_REFERENCE'] * (TYPEOF(SELF\representation_relationship.rep_1) + TYPEOF(SELF\representation_relationship.rep_2))) >= 1;
END_ENTITY;

ENTITY specified_occurrence_context_dependent_shape_representation
  SUBTYPE OF (context_dependent_shape_representation);
  sub_element : product_definition_specified_occurrence;
WHERE
  WR1: 'PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_OCCURRENCE' IN TYPEOF(SELF.represented_product_relation.definition.related_product_definition);
  WR2: sub_element IN represented_product_relation.definition.related_product_definition.descendant_occurrences;
END_ENTITY;

FUNCTION get_directed_link
 (nodes : LIST OF representation; undirected_link : LIST OF chained_representation_link) : LIST OF representation_relationship;
  LOCAL
  directed_link : LIST OF representation_relationship := [];
    END_LOCAL;
      IF (SIZEOF(nodes) <> SIZEOF(undirected_link) + 1) OR (VALUE_UNIQUE(nodes) = FALSE)
  THEN
    RETURN(?);
  END_IF;
      REPEAT i := 1 TO SIZEOF(undirected_link);
    CASE TRUE OF
      ('REPRESENTATION_SCHEMA.REPRESENTATION_CONTEXT' IN TYPEOF(undirected_link[i])) : BEGIN  
                                                                                              IF ((nodes[i]\representation.context_of_items :=:
                                                                                                   undirected_link[i]) AND
                                                                                                  (nodes[i +
                                                                                                         1]\representation.context_of_items :=:
                                                                                                   undirected_link[i]))
                                                                                              THEN
                                                                                                INSERT(directed_link,
                                                                                                       representation_relationship('',
                                                                                                                                   '',
                                                                                                                                   nodes[i +
                                                                                                                                         1],
                                                                                                                                   nodes[i]),
                                                                                                       (i - 1));
                                                                                              ELSE
                                                                                                RETURN(?);
                                                                                              END_IF;
      END;
      ('REPRESENTATION_SCHEMA.REPRESENTATION_RELATIONSHIP' IN TYPEOF(undirected_link[i])) : BEGIN  
                                                                                                   IF (((nodes[i] :=:
                                                                                                         undirected_link[i]\representation_relationship.rep_1) AND
                                                                                                        (nodes[i +
                                                                                                               1] :=:
                                                                                                         undirected_link[i]\representation_relationship.rep_2)) OR
                                                                                                       ((nodes[i] :=:
                                                                                                         undirected_link[i]\representation_relationship.rep_2) AND
                                                                                                        (nodes[i +
                                                                                                               1] :=:
                                                                                                         undirected_link[i]\representation_relationship.rep_1)))
                                                                                                   THEN
                                                                                                     INSERT(directed_link,
                                                                                                            representation_relationship('',
                                                                                                                                        '',
                                                                                                                                        nodes[i +
                                                                                                                                              1],
                                                                                                                                        nodes[i]),
                                                                                                            (i - 1));
                                                                                                   ELSE
                                                                                                     RETURN(?);
                                                                                                   END_IF;
      END;
      ('REPRESENTATION_SCHEMA.MAPPED_ITEM' IN TYPEOF(undirected_link[i])) : BEGIN  
                                                                                   IF ((nodes[i] IN
                                                                                        using_representations(undirected_link[i])) AND
                                                                                       (nodes[i + 1] :=:
                                                                                        undirected_link[i]\mapped_item.mapping_source\representation_map.mapped_representation))
                                                                                   THEN
                                                                                     INSERT(directed_link,
                                                                                            representation_relationship('',
                                                                                                                        '',
                                                                                                                        nodes[i +
                                                                                                                              1],
                                                                                                                        nodes[i]),
                                                                                            (i - 1));
                                                                                   ELSE
                                                                                     RETURN(?);
                                                                                   END_IF;
      END;
      OTHERWISE: RETURN(?);
    END_CASE;
  END_REPEAT;
      IF (VALUE_UNIQUE(directed_link) = FALSE)
  THEN
    RETURN(?);
  END_IF;
      RETURN(directed_link);
END_FUNCTION;

FUNCTION relatives_of_product_definitions
 (definition_set : SET OF product_definition; relation_subtype : STRING) : SET OF product_definition;
FUNCTION local_relatives_of_product_definitions(definition_set : SET OF product_definition;
                                                                 total_definitions : SET OF product_definition;
                                                                 relation_subtype : STRING) : SET OF product_definition;
  LOCAL
    local_def   : SET OF product_definition              := [];
    local_pdr   : SET OF product_definition_relationship := [];
    local_total : SET OF product_definition              := [];
  END_LOCAL;
    REPEAT i := 1 TO HIINDEX(definition_set);
      local_pdr := local_pdr + bag_to_set(USEDIN(definition_set[i], relation_subtype + '.RELATING_PRODUCT_DEFINITION'));
    END_REPEAT;
    REPEAT i := 1 TO HIINDEX(local_pdr);
      local_def := local_def + local_pdr[i].related_product_definition;
    END_REPEAT;
    IF (SIZEOF(local_def) - SIZEOF(total_definitions)) = 0
    THEN
      RETURN(local_def);
    ELSE
      local_total := total_definitions + local_def;
      RETURN(local_def +
             (local_relatives_of_product_definitions(local_def - total_definitions, local_total, relation_subtype)));
    END_IF;
  END_FUNCTION;
      RETURN(local_relatives_of_product_definitions(definition_set, definition_set, relation_subtype));
END_FUNCTION;

FUNCTION relatives_of_shape_representations
 (shape_representation_set : SET OF shape_representation) : SET OF shape_representation;
FUNCTION local_relatives_of_shape_representations(shape_representation_set : SET OF shape_representation;
                                                                   total_reps : SET OF shape_representation) : SET OF shape_representation;
  LOCAL
    local_shape_rep : SET OF shape_representation              := [];
    local_srr       : SET OF shape_representation_relationship := [];
    local_total     : SET OF shape_representation              := [];
  END_LOCAL;
    REPEAT i := 1 TO HIINDEX(shape_representation_set);
      local_srr := local_srr +
                   QUERY(rr
                         <* bag_to_set(USEDIN(shape_representation_set[i], 'REPRESENTATION_SCHEMA.REPRESENTATION_RELATIONSHIP.REP_1'))
                         | 'PRODUCT_PROPERTY_REPRESENTATION_SCHEMA.SHAPE_REPRESENTATION_RELATIONSHIP' IN TYPEOF(rr));
    END_REPEAT;
    REPEAT i := 1 TO HIINDEX(local_srr);
      IF 'PRODUCT_PROPERTY_REPRESENTATION_SCHEMA.SHAPE_REPRESENTATION_RELATIONSHIP' IN TYPEOF(local_srr[i])
      THEN
        local_shape_rep := local_shape_rep + local_srr[i].rep_2;
      END_IF;
    END_REPEAT;
    IF SIZEOF(local_shape_rep - total_reps) = 0
    THEN
      RETURN(shape_representation_set);
    ELSE
      local_total := total_reps + local_shape_rep;
      RETURN(local_shape_rep + (local_relatives_of_shape_representations(local_shape_rep - total_reps, local_total)));
    END_IF;
  END_FUNCTION;
      RETURN(local_relatives_of_shape_representations(shape_representation_set, shape_representation_set));
END_FUNCTION;

FUNCTION get_property_definition_representations
 (c_def_instance : characterized_definition) : SET OF property_definition_representation;
  LOCAL
  pd_set : SET OF property_definition := [];
  pdr_set : SET OF property_definition_representation := [];
    END_LOCAL;
      pd_set := bag_to_set(USEDIN(c_def_instance, 'PRODUCT_PROPERTY_DEFINITION_SCHEMA.PROPERTY_DEFINITION.DEFINITION'));
      IF (SIZEOF(pd_set) < 1)
  THEN
    RETURN(pdr_set);
  END_IF;
      REPEAT i := 1 TO HIINDEX(pd_set);
    pdr_set := pdr_set +
               bag_to_set(USEDIN(pd_set[i], 'PRODUCT_PROPERTY_REPRESENTATION_SCHEMA.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION'));
  END_REPEAT;
      RETURN(pdr_set);
END_FUNCTION;

FUNCTION valid_identified_item_in_representation
 (identified_item : item_identified_representation_usage_select; used_representation : representation) : BOOLEAN;
  LOCAL
  i : INTEGER := 1;
    END_LOCAL;
      IF 'REPRESENTATION_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(identified_item)
  THEN
    RETURN(used_representation IN using_representations(identified_item));
  END_IF;
      IF ('REPRESENTATION_SCHEMA.LIST_REPRESENTATION_ITEM' IN TYPEOF(identified_item)) OR
         ('REPRESENTATION_SCHEMA.SET_REPRESENTATION_ITEM' IN TYPEOF(identified_item))
  THEN
    REPEAT WHILE (EXISTS(identified_item[i]));
      IF NOT (used_representation IN using_representations(identified_item[i]))
      THEN
        RETURN(FALSE);
      END_IF;
      i := i + 1;
    END_REPEAT;
    RETURN(TRUE);
  END_IF;
      RETURN(?);
END_FUNCTION;

END_SCHEMA;  -- product_property_representation_schema


© ISO 2021 — All rights reserved