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 N10693 - ISO 10303-41 Fundamentals of product description and support - EXPRESS
Supersedes ISO/TC 184/SC 4/WG 12 N10230
*)


SCHEMA action_schema;

 REFERENCE FROM basic_attribute_schema   -- ISO 10303-41
  (description_attribute,
   description_attribute_select,
   get_description_value,
   get_id_value,
   get_name_value,
   get_role,
   id_attribute,
   id_attribute_select,
   name_attribute,
   name_attribute_select,
   object_role,
   role_select,
   role_association);

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


TYPE as_description_attribute_select = SELECT BASED_ON description_attribute_select WITH
   (action_request_solution);
END_TYPE;

TYPE as_id_attribute_select = SELECT BASED_ON id_attribute_select WITH
   (action);
END_TYPE;

TYPE as_name_attribute_select = SELECT BASED_ON name_attribute_select WITH
   (action_request_solution);
END_TYPE;

TYPE as_role_select = SELECT BASED_ON role_select WITH
   (directed_action_assignment);
END_TYPE;

TYPE supported_item = SELECT
   (action_directive,
    action,
    action_method);
END_TYPE;

ENTITY action;
  name : label;
  description : OPTIONAL text;
  chosen_method : action_method;
DERIVE
  id : identifier := get_id_value(SELF);
WHERE
  WR1: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
END_ENTITY;

ENTITY action_directive;
  name : label;
  description : OPTIONAL text;
  analysis : text;
  comment : text;
  requests : SET[1:?] OF versioned_action_request;
END_ENTITY;

ENTITY action_directive_relationship;
  name : label;
  description : OPTIONAL STRING;
  relating : action_directive;
  related : action_directive;
  relation_type : STRING;
WHERE
  WR1: acyclic_action_directive_relationship(SELF, [related], 'ACTION_SCHEMA.ACTION_DIRECTIVE_RELATIONSHIP');
END_ENTITY;

ENTITY action_method;
  name : label;
  description : OPTIONAL text;
  consequence : text;
  purpose : text;
END_ENTITY;

ENTITY action_method_relationship;
  name : label;
  description : OPTIONAL text;
  relating_method : action_method;
  related_method : action_method;
END_ENTITY;

ENTITY action_relationship;
  name : label;
  description : OPTIONAL text;
  relating_action : action;
  related_action : action;
END_ENTITY;

ENTITY action_request_solution;
  method : action_method;
  request : versioned_action_request;
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 action_request_status;
  status : label;
  assigned_request : versioned_action_request;
END_ENTITY;

ENTITY action_resource;
  name : label;
  description : OPTIONAL text;
  usage : SET[1:?] OF supported_item;
  kind : action_resource_type;
END_ENTITY;

ENTITY action_resource_relationship;
  name : label;
  description : OPTIONAL text;
  relating_resource : action_resource;
  related_resource : action_resource;
END_ENTITY;

ENTITY action_resource_type;
  name : label;
END_ENTITY;

ENTITY action_status;
  status : label;
  assigned_action : executed_action;
END_ENTITY;

ENTITY directed_action
  SUBTYPE OF (executed_action);
  directive : action_directive;
END_ENTITY;

ENTITY directed_action_assignment
  ABSTRACT SUPERTYPE ;
  assigned_directed_action : directed_action;
DERIVE
  role : object_role := get_role(SELF);
WHERE
  WR1: SIZEOF(USEDIN(SELF, 'BASIC_ATTRIBUTE_SCHEMA.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
END_ENTITY;

ENTITY executed_action
  SUBTYPE OF (action);
END_ENTITY;

ENTITY versioned_action_request;
  id : identifier;
  version : OPTIONAL label;
  purpose : text;
  description : OPTIONAL text;
END_ENTITY;

ENTITY versioned_action_request_relationship;
  id : identifier;
  name : label;
  description : OPTIONAL text;
  relating_versioned_action_request : versioned_action_request;
  related_versioned_action_request : versioned_action_request;
END_ENTITY;

FUNCTION acyclic_action_directive_relationship
 (relation : action_directive_relationship; relatives : SET[1:?] OF action_directive; specific_relation : STRING) : BOOLEAN; 
LOCAL 
		x : SET of action_directive_relationship;
	END_LOCAL;
	IF relation.relating IN relatives THEN 
		RETURN (FALSE);
	END_IF;
	x := QUERY(adr <* bag_to_set(USEDIN(relation.relating, 'ACTION_SCHEMA.' + 'ACTION_DIRECTIVE_RELATIONSHIP.' + 'RELATED')) | specific_relation IN TYPEOF(adr));
	REPEAT i := 1 TO HIINDEX(x);
		IF NOT acyclic_action_directive_relationship(x[i], relatives + relation.relating, specific_relation) THEN 
	 		RETURN (FALSE);
		END_IF;
	END_REPEAT;
	RETURN (TRUE);
END_FUNCTION;

FUNCTION acyclic_action_method_relationship
 (relation : action_method_relationship; relatives : SET[1:?] OF action_method; specific_relation : STRING) : BOOLEAN; 
LOCAL
      x : SET OF action_method_relationship;
    END_LOCAL;

    IF relation.relating_method IN relatives THEN
      RETURN (FALSE);
    END_IF;
    x := QUERY(am <* bag_to_set(USEDIN(relation.relating_method, 'ACTION_SCHEMA.' + 'ACTION_METHOD_RELATIONSHIP.' + 'RELATED_METHOD')) | specific_relation IN TYPEOF(am));
    REPEAT i := 1 TO HIINDEX(x);
      IF NOT acyclic_action_method_relationship(x[i], relatives + relation.relating_method, specific_relation) THEN
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
    RETURN (TRUE);
END_FUNCTION;

FUNCTION acyclic_action_relationship
 (relation : action_relationship; relatives : SET[1:?] OF action; specific_relation : STRING) : BOOLEAN; 
LOCAL
      x : SET OF action_relationship;
    END_LOCAL;

    IF relation.relating_action IN relatives THEN
      RETURN (FALSE);
    END_IF;
    x := QUERY(actn <* bag_to_set(USEDIN(relation.relating_action, 'ACTION_SCHEMA.' + 'ACTION_RELATIONSHIP.' + 'RELATED_ACTION')) | specific_relation IN TYPEOF(actn));
    REPEAT i := 1 TO HIINDEX(x);
      IF NOT acyclic_action_relationship(x[i], relatives + relation.relating_action, specific_relation) THEN
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
    RETURN (TRUE);
END_FUNCTION;

FUNCTION acyclic_action_resource_relationship
 (relation : action_resource_relationship; relatives : SET[1:?] OF action_resource; specific_relation : STRING) : BOOLEAN; 
LOCAL
      x : SET OF action_resource_relationship;
    END_LOCAL;

    IF relation.relating_resource IN relatives THEN
      RETURN (FALSE);
    END_IF;
    x := QUERY(ar <* bag_to_set(USEDIN(relation.relating_resource, 'ACTION_SCHEMA.' + 'ACTION_RESOURCE_RELATIONSHIP.' + 'RELATED_RESOURCE')) | specific_relation IN TYPEOF(ar));
    REPEAT i := 1 TO HIINDEX(x);
      IF NOT acyclic_action_resource_relationship(x[i], relatives + relation.relating_resource, specific_relation) THEN
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
    RETURN (TRUE);
END_FUNCTION;

FUNCTION acyclic_versioned_action_request_relationship
 (relation : versioned_action_request_relationship; relatives : SET[0:?] OF versioned_action_request; specific_relation : STRING) : BOOLEAN; 
LOCAL
      x : SET OF versioned_action_request_relationship;
    END_LOCAL;

    IF relation.relating_versioned_action_request IN relatives THEN
      RETURN (FALSE);
    END_IF;
    x := QUERY(varr <* bag_to_set(USEDIN(relation.relating_versioned_action_request, 'ACTION_SCHEMA.' + 'VERSIONED_ACTION_REQUEST_RELATIONSHIP.' + 'RELATED_VERSIONED_ACTION_REQUEST')) | specific_relation IN TYPEOF(varr));
    REPEAT i := 1 TO HIINDEX(x);
      IF NOT acyclic_versioned_action_request_relationship(x[i], relatives + relation.relating_versioned_action_request, specific_relation) THEN
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
    RETURN (TRUE);
END_FUNCTION;

END_SCHEMA;  -- action_schema


© ISO 2021 — All rights reserved