ISO 10303-23:2000

Industrial automation systems and integration - Product data representation and exchange - Part 23: Implementation methods: C++ language binding to the standard data access interface

This part of ISO 10303 specifies the implementation of the functional interface specified in the standard data access interface (SDAI), ISO 10303-22, in the C++ programming language. The following are within the scope of this part of ISO 10303: - access to and manipulation of data types and entities which are specified in ISO 10303-22; - convenience functions suitable to this language binding; - binding of functions to operations and attributes specified in ISO 10303-22 with the linking of application schema definition at either compile-time or run-time; - implementation mechanisms for the handling of errors as specified in ISO 10303-22; - implementation mechanisms for the validation of constraints as specified in ISO 10303-22. The following is outside the scope of this part of ISO 10303: - all items listed as out of scope in ISO 10303-22.

Systèmes d'automatisation industrielle et intégration — Représentation et échange de données de produits — Partie 23: Méthodes de mise en application: Liant de langage C++ à l'interface d'accès aux données normalisées

General Information

• Status: Published
• Publication Date: 20-Dec-2000
• ICS: 25.040.40 - Industrial process measurement and control
• Technical Committee: ISO/TC 184/SC 4 - Industrial data
• Drafting Committee: ISO/TC 184/SC 4/WG 11 - Implementation methods and conformance methods
• Current Stage: 9093 - International Standard confirmed
• Start Date: 28-Jun-2024
• Completion Date: 13-Dec-2025

Relations

• Consolidated By: ISO 21809-2:2007 - Petroleum and natural gas industries - External coatings for buried or submerged pipelines used in pipeline transportation systems - Part 2: Fusion-bonded epoxy coatings
• Effective Date: 06-Jun-2022

Overview - ISO 10303-23:2000 (C++ language binding to SDAI)

ISO 10303-23:2000 is the part of the STEP family that defines the C++ language binding to the Standard Data Access Interface (SDAI, ISO 10303-22). It specifies how the SDAI functional interface is implemented in C++ so applications can access, manipulate and validate product data described with EXPRESS schemas. The standard focuses on language-specific bindings, convenience functions, schema linking (compile-time or run-time), error handling and constraint validation for robust product data exchange.

Key topics and technical requirements

• C++ binding of SDAI operations - mapping SDAI concepts (sessions, repositories, models, schema instances, transactions) to C++ classes and functions.
• Data type mapping - representation of EXPRESS primitive, aggregate, enumeration, select, number and entity types in C++ with iterators and aggregate classes.
• Schema linking - mechanisms for binding functions to EXPRESS operations and attributes with either early (compile-time) or late (run-time) schema linkage.
• Error handling and events - implementation mechanisms for SDAI-specified error events and exception-like handling within the C++ binding.
• Validation of constraints - support for validating EXPRESS where-rules, uniqueness and other constraints per SDAI requirements.
• Convenience and language-specific features - naming, memory management, namespaces, and quality-of-life APIs tailored for C++ developers.
• Conformance levels and header definitions - guidance on conformance features, header files and indexing of aggregates for interoperable implementations.

Practical applications

• Building STEP-compliant C++ libraries for product data exchange and long-term archiving.
• Implementing PLM, CAD, CAM, CAE integrations that require programmatic access to EXPRESS-based product models.
• Creating model repositories, validation tools and converters that operate on SDAI model instances using a standardized C++ API.
• Enabling toolchains to bind application schemas either statically or dynamically, improving interoperability across systems.

Who should use this standard

• Software engineers and architects developing STEP / SDAI implementations in C++.
• Vendors of CAD/PLM/CAE systems implementing data exchange and validation features.
• Integrators and consultants working on interoperability, data migration and digital thread solutions.

Related standards

• ISO 10303-22 - Standard Data Access Interface (SDAI) (normative).
• ISO 10303-11 - EXPRESS language reference (data modeling).
• Other parts of the ISO 10303 (STEP) series covering exchange formats, conformance testing and application protocols.

Keywords: ISO 10303-23, C++ language binding, SDAI, STEP, EXPRESS, product data representation, data exchange, schema binding, PLM integration.

Standards Content (Sample)

INTERNATIONAL ISO
STANDARD 10303-23
First edition
2000-12-01
Industrial automation systems and
integration — Product data representation
and exchange —
Part 23:
Implementation methods: C++ language
binding to the standard data access
interface
Systèmes d'automatisation industrielle et intégration — Représentation et
échange de données de produits —
Partie 23: Méthodes de mise en application: Liant de langage C++ à
l'interface d'accès aux données normalisées
Reference number
©
ISO 2000
PDF disclaimer
This PDF file may contain embedded typefaces. In accordance with Adobe's licensing policy, this file may be printed or viewed but shall not
be edited unless the typefaces which are embedded are licensed to and installed on the computer performing the editing. In downloading this
file, parties accept therein the responsibility of not infringing Adobe's licensing policy. The ISO Central Secretariat accepts no liability in this
area.
Adobe is a trademark of Adobe Systems Incorporated.
Details of the software products used to create this PDF file can be found in the General Info relative to the file; the PDF-creation parameters
were optimized for printing. Every care has been taken to ensure that the file is suitable for use by ISO member bodies. In the unlikely event
that a problem relating to it is found, please inform the Central Secretariat at the address given below.
All rights reserved. Unless otherwise specified, no part of this publication may be reproduced or utilized in any form or by any means, electronic
or mechanical, including photocopying and microfilm, without permission in writing from either ISO at the address below or ISO's member body
in the country of the requester.
ISO copyright office
Case postale 56 � CH-1211 Geneva 20
Tel. + 41 22 749 01 11
Fax + 41 22 749 09 47
E-mail [e-mail]
Web www.iso.ch
Printed in Switzerland
ii © ISO 2000 – All rights reserved

Contents
Page
1 Scope . 1
2 Normative references . 1
3 Definitions and abbreviations . 2
3.1 Definitions . 2
3.1.1 Terms defined in ISO 10303-1 . 2
3.1.2 Terms defined in ISO 10303-11 . 3
3.1.3 Terms defined in ISO 10303-22 . 3
3.1.4 Terms defined in The Annotated C++ Reference Manual . 4
3.1.5 Term defined in IEEE standard . 5
3.1.6 Other definitions . 5
3.2 Abbreviations . 6
3.3 Typographical conventions . 6
4 Overall requirements . 6
4.1 Characteristics of the binding functions . 6
4.2 Language specific features . 8
4.2.1 Names of types and operations . 8
4.2.2 Memory management . 8
4.3 Binding styles . 8
5 Constants and data type definitions and global functions . 9
5.1 SDAI namespace . 9
5.2 EXPRESS built-in constants . 9
5.3 EXPRESS attribute data types . 10
5.3.1 Primitive data types . 10
5.3.2 Aggregate and iterator data types . 18
5.3.3 Enumeration data type . 20
5.3.4 Select data type . 22
5.3.5 Number data type . 28
5.3.6 Handles . 28
5.3.7 TYPE data type . 29
5.3.8 ENTITY data type . 30
5.3.9 Entity instance . 32
5.3.10 Persistent data and persistent object identifiers . 35
5.3.11 Domain equivalence for early binding . 42
5.3.12 Application instance . 43
5.3.13 Binding-specific data types . 52
5.4 EXISTS functions . 60
iii
6 Error handling . 61
6.1 Event . 63
6.2 Error event . 63
7 C++ binding of the SDAI operations . 64
7.1 Session classes . 64
7.1.1 Session_instance . 64
7.1.2 Session . 69
7.1.3 Implementation . 75
7.1.4 Transaction . 75
7.2 Schema_instance . 76
7.2.1 Rename schema instance . 77
7.2.2 Add SDAI-model . 77
7.2.3 Remove SDAI-model . 77
7.2.4 Validate global rule . 77
7.2.5 Validate uniqueness rule . 78
7.2.6 Validate instance reference domain . 78
7.2.7 Validate schema instance . 79
7.2.8 Is validation current . 79
7.2.9 SDAI query . 79
7.3 Schema-specific schema_instance (early binding) . 80
7.4 Repository classes . 80
7.4.1 Repository_contents . 80
7.4.2 Repository . 81
7.5 Model classes . 84
7.5.1 Model . 84
7.5.2 Model_contents_instances . 87
7.5.3 Model_contents . 87
7.5.4 Entity extent . 90
7.5.5 Model contents by schema . 91
7.5.6 Scope . 92
7.6 Aggregate and iterator classes . 93
7.6.1 Aggregate instance . 93
7.6.2 Array . 94
7.6.3 List . 100
7.6.4 Set . 105
7.6.5 Bag . 108
7.6.6 Iterator . 112
7.7 Dictionary Classes . 116
7.7.1 Named_type . 116
7.7.2 Dictionary_instance . 117
7.7.3 Schema_definition . 117
7.7.4 Defined_type . 119
7.7.5 Entity_definition . 120
iv
7.7.6 Attribute . 121
7.7.7 Derived_attribute . 122
7.7.8 Explicit_attribute . 122
7.7.9 Inverse_attribute . 123
7.7.10 Uniqueness_rule . 124
7.7.11 Where_rule . 124
7.7.12 Enumeration_type . 125
7.7.13 Select_type . 125
7.7.14 Global_rule . 126
7.7.15 Simple_type . 126
7.7.16 Number_type . 127
7.7.17 Integer_type . 127
7.7.18 Real_type . 128
7.7.19 String_type . 128
7.7.20 Binary_type . 129
7.7.21 Logical_type . 129
7.7.22 Boolean_type . 130
7.7.23 Bound . 130
7.7.24 Population_dependent_bound . 131
7.7.25 Integer_bound . 131
7.7.26 Aggregation_type . 132
7.7.27 Variable_size_aggregation_type . 132
7.7.28 Set_type . 133
7.7.29 Bag_type . 133
7.7.30 List_type . 134
7.7.31 Array_type . 134
7.7.32 Underlying_type . 135
7.7.33 Base_type . 136
7.7.34 Constructed_type . 137
7.7.35 Interface_specification . 138
7.7.36 Interfaced_item . 138
7.7.37 Explicit_item_id . 139
7.7.38 Used_item . 139
7.7.39 Referenced_item . 140
7.7.40 Implicit_item_id . 140
7.7.41 External_schema . 141
7.7.42 Domain_equivalent_type . 141
7.7.43 Type_or_rule . 142
7.7.44 Explicit_or_derived . 143
8 Conformance levels . 144
8.1 Conformance level features . 144
8.2 Header files . 144
8.3 Indexing of aggregates . 145
v
Annex A (normative) Information object registration . 146
Annex B (informative) Concept of operations . 147
B.1 Background . 147
B.2 Influence of IDL on this part of ISO 10303 . 148
B.3 IDL-C++ concepts . 149
B.4 Influence of POS on this part of ISO 10303 . 150
B.4.1 Object . 150
B.4.2 SessionInstance and DAObject . 150
B.4.3 SessionInstance . 151
B.4.4 ModelContents . 151
B.4.5 PID and PID_SDAI . 151
B.4.6 DAObject and DAObject_SDAI . 152
B.4.7 Application_instance and application_instance factory . 152
B.4.8 PID_DA . 152
B.5 Scenarios . 152
Bibliography . 154
Index . 155
Figures
Figure B.1 - Inheritance hierarchy . 151
Tables
Table 1 - Arguments and return values . 7
Table 2 - EXPRESS built-in constants . 10
Table 3 - Mapping of EXPRESS types to TypeCode values . 54
vi
Foreword
ISO (the International Organization for Standardization) is a worldwide federation of national
standards bodies (ISO member bodies). The work of preparing International Standards is normally
carried out through ISO technical committees. Each member body interested in a subject for which a
technical committee has been established has the right to be represented on that committee.
International organizations, governmental and non-governmental, in liaison with ISO, also take part in
the work. ISO collaborates closely with the International Electrotechnical Commission (IEC) on all
matters of electrotechnical standardization.
International Standards are drafted in accordance with the rules given in the ISO/IEC Directives,
Part 3.
Draft International Standards adopted by the technical committees are circulated to the member bodies
for voting. Publication as an International Standard requires approval by at least 75 % of the member
bodies casting a vote.
Attention is drawn to the possibility that some of the elements of this part of ISO 10303 may be the
subject of patent rights. ISO shall not be held responsible for identifying any or all such patent rights.
International Standard ISO 10303-23 was prepared by Technical Committee ISO/TC 184, Industrial
automation and systems and integration, Subcommittee SC 4, Industrial data.
ISO 10303 consists of the following parts, under the general title Industrial automation systems and
integration — Product data representation and exchange:
— Part 1, Overview and fundamental principles;
— Part 11, Description methods: The EXPRESS language reference manual;
— Part 12, Description method: The EXPRESS-I language reference manual;
— Part 21, Implementation methods: Clear text encoding of the exchange structure;
— Part 22, Implementation method: Standard data access interface specification;
— Part 23, Implementation method: C++ language binding to the standard data access interface;
— Part 24, Implementation method: C language binding to the standard data access interface;
— Part 26, Implementation method: Interface definition language binding to the standard data
access;
— Part 31, Conformance testing methodology and framework: General concepts;
— Part 32, Conformance testing methodology and framework: Requirements on testing laboratories
and clients;
vii
— Part 34, Conformance testing methodology and framework: Abstract test methods;
— Part 35, Conformance testing methodology and framework: Abstract test methods for SDAI
implementations;
— Part 41, Integrated generic resources: Fundamentals of product description and support;
— Part 42, Integrated generic resources: Geometric and topological representation;
— Part 43, Integrated generic resources: Representation structures;
— Part 44, Integrated generic resources: Product structure configuration;
— Part 45, Integrated generic resource: Materials;
— Part 46, Integrated generic resources: Visual presentation;
— Part 47, Integrated generic resource: Shape variation tolerances;
— Part 49, Integrated generic resource: Process structure and properties;
— Part 101, Integrated application resource: Draughting;
— Part 104, Integrated application resource: Finite element analysis;
— Part 105, Integrated application resource: Kinematics;
— Part 106, Integrated application resource: Building construction core model;
— Part 107, Engineering Analysis Core Application reference model (EA C-ARM);
— Part 201, Application protocol: Explicit draughting;
— Part 202, Application protocol: Associative draughting;
— Part 203, Application protocol: Configuration controlled design;
— Part 204, Application protocol: Mechanical design using boundary representation;
— Part 205, Application protocol: Mechanical design using surface representation;
— Part 207, Application protocol: Sheet metal die planning and design;
— Part 208, Application protocol: Life cycle management - Change process;
viii
— Part 209, Application protocol: Composite and metallic structural analysis and related design;
— Part 210, Application protocol: Electronic assembly, interconnect, and packaging design;
— Part 212, Application protocol: Electrotechnical design and installation
— Part 213, Application protocol: Numerical control process plans for machined parts;
— Part 214, Application protocol: Core data for automotive design;
— Part 215, Application protocol: Ship arrangement;
— Part 216, Application protocol: Ship moulded forms;
— Part 217, Application protocol: Ship piping;
— Part 218, Application protocol: Ship structures;
— Part 221, Application protocol: Functional data and their schematic representation for process
plant;
— Part 222, Application protocol: Exchange of product data for composite structures;
— Part 223, Application protocol: Exchange of design and manufacturing product information for
casting parts;
— Part 224, Application protocol: Mechanical product definition for process plans using machining
features;
— Part 225, Application protocol: Building elements using explicit shape representation;
— Part 226, Application protocol: Ship mechanical systems;
— Part 227, Application protocol: Plant spatial configuration;
— Part 229, Application protocol: Exchange of design and manufacturing product information for
forged parts;
— Part 230, Application protocol: Building structural frame: Steelwork;
— Part 231, Application protocol: Process engineering data: Process design and process specification
of major equipment;
— Part 232, Application protocol: Technical data packaging core information and exchange;
ix
— Part 301, Abstract test suite: Explicit draughting;
— Part 302, Abstract test suite: Associative draughting;
— Part 303, Abstract test suite: Configuration controlled design;
— Part 304, Abstract test suite: Mechanical design using boundary representation;
— Part 305, Abstract test suite: Mechanical design using surface representation;
— Part 307, Abstract test suite: Sheet metal die planning and design;
— Part 308, Abstract test suite: Life cycle management - Change process;
— Part 309, Abstract test suite: Composite and metallic structural analysis and related design;
— Part 310, Abstract test suite: Electronic assembly, interconnect, and packaging design;
— Part 312, Abstract test suite: Electrotechnical design and installation;
— Part 313, Abstract test suite: Numerical control process plans for machined parts;
— Part 314, Abstract test suite: Core data for automotive mechanical design;
— Part 315, Abstract test suite: Ship arrangement;
— Part 316, Abstract test suite: Ship moulded forms;
— Part 317, Abstract test suite: Ship piping;
— Part 318, Abstract test suite: Ship structures;
— Part 321, Abstract test suite: Functional data and their schematic representation for process plant;
— Part 322, Abstract test suite: Exchange of product data for composite structures;
— Part 323, Abstract test suite: Exchange of design and manufacturing product information for
casting parts;
— Part 324, Abstract test suite: Mechanical product definition for process plans using machining
features;
— Part 325, Abstract test suite: Building elements using explicit shape representation;
x
— Part 326, Abstract test suite: Ship mechanical systems;
— Part 327, Abstract test suite: Plant spatial configuration;
— Part 329, Abstract test suite: Exchange of design and manufacturing product information for
forged parts;
— Part 330, Abstract test suite: Building structural frame: Steelwork;
— Part 331, Abstract test suite: Process engineering data: Process design and process specification
of major equipment;
— Part 332, Abstract test suite: Technical data packaging core information and exchange;
— Part 501, Application interpreted construct: Edge-based wireframe;
— Part 502, Application interpreted construct: Shell-based wireframe;
— Part 503, Application interpreted construct: Geometrically bounded 2D wireframe;
— Part 504, Application interpreted construct: Draughting annotation;
— Part 505, Application interpreted construct: Drawing structure and administration;
— Part 506, Application interpreted construct: Draughting elements;
— Part 507, Application interpreted construct: Geometrically bounded surface;
— Part 508, Application interpreted construct: Non-manifold surface;
— Part 509, Application interpreted construct: Manifold surface;
— Part 510, Application interpreted construct: Geometrically bounded wireframe;
— Part 511, Application interpreted construct: Topologically bounded surface;
— Part 512, Application interpreted construct: Faceted boundary representation;
— Part 513, Application interpreted construct: Elementary boundary representation;
— Part 514, Application interpreted construct: Advanced boundary representation;
— Part 515, Application interpreted construct: Constructive solid geometry;
xi
— Part 517, Application interpreted construct: Mechanical design geometric presentation;
— Part 518, Application interpreted construct: Mechanical design shaded representation;
— Part 519, Application interpreted construct: Geometric tolerances;
— Part 520, Application interpreted construct: Associative draughting.
The structure of this International Standard is described in ISO 10303-1. The numbering of the parts of
the International Standard reflects its structure:
— Parts 11 to 12 specify the description methods,
— Parts 21 to 26 specify the implementation methods,
— Parts 31 to 35 specify the conformance testing methodology and framework,
— Parts 41 to 49 specify the integrated generic resources,
— Parts 101 to 107 specify the integrated application resources,
— Parts 201 to 232 specify the application protocols,
— Parts 301 to 332 specify the abstract test suites, and
— Parts 501 to 520 specify the application interpreted constructs.
Should further parts be published, they will follow the same numbering pattern.
Annex A forms a normative part of this part of ISO 10303. Annex B is for information only.
xii
Introduction
ISO 10303 is an International Standard for the computer-interpretable representation and exchange of
product data. The objective is to provide a neutral mechanism capable of describing product data
throughout the life cycle of a product, independent from any particular system. The nature of this
description makes it suitable not only for neutral file exchange, but also as a basis for implementing and
sharing product databases and archiving.
This International Standard is organized as a series of parts, each published separately. The parts of ISO
10303 fall into one of the following series: description methods, integrated resources, application
integrated constructs, application protocols, abstract test suites, implementation methods, and
conformance testing. The series is described in ISO 10303-1. This part of ISO 10303 is a member of the
implementation methods series.
This part of ISO 10303 specifies a C++ language binding to the standard data access interface (SDAI).
SDAI is the access interface specification to data which has been defined using ISO 10303-11. SDAI is
specified in ISO 10303-22.
Computer application systems are implemented using computing or definition languages. The
specification of the functionality defined in ISO 10303-22 in a particular computing or definition
language is referred to as an SDAI language binding. Since there are many computing and definition
languages, many SDAI language bindings are possible.
Readers of this part of ISO 10303 are advised that this part of ISO 10303 presupposes a working
knowledge of the functionality of the SDAI which is described in ISO 10303-22. Moreover, this part of
ISO 10303 presupposes a working knowledge of the C++ programming language. The source for the
C++ programming language is specified in the normative references of this part of ISO 10303.
Major subdivisions of this part of ISO 10303 are:
— language binding characteristics, constants and data types found in clauses 4 and 5;
— language bindings to SDAI operations and error handling found in clauses 6 and 7.
xiii
INTERNATIONAL STANDARD ISO 10303-23:2000(E)
Industrial automation systems and integration — Product data
representation and exchange —
Part 23:
Implementation methods: C++ language binding to the standard
data access interface
1 Scope
This part of ISO 10303 specifies the implementation of the functional interface specified in the standard
data access interface (SDAI), ISO 10303-22, in the C++ programming language.
The following are within the scope of this part of ISO 10303:
— access to and manipulation of data types and entities which are specified in ISO 10303-22;
— convenience functions suitable to this language binding;
— binding of functions to operations and attributes specified in ISO 10303-22 with the linking of
application schema definition at either compile-time or run-time;
— implementation mechanisms for the handling of errors as specified in ISO 10303-22;
— implementation mechanisms for the validation of constraints as specified in ISO 10303-22.
The following is outside the scope of this part of ISO 10303:
— all items listed as out of scope in ISO 10303-22.
2 Normative references
The following normative documents contain provisions which, through reference in this text,
constitute provisions of this part of ISO 10303. For dated references, subsequent amendments to, or
revisions of, any of these publications do not apply. However, parties to agreements based on this part
of ISO 10303 are encouraged to investigate the possibility of applying the most recent editions of the
normative documents indicated below. For undated references, the latest edition of the normative
document referred to applies. Members of ISO and IEC maintain registers of currently valid
International Standards.
Ellis, Margaret A. and Bjarne Stroustrup, The Annotated C++ Reference Manual, Addison-Wesley
Publishing Company, New York, 1990.
IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std 754-1985.
ISO/IEC 8824-1:1998, Information technology - Abstract Syntax Notation One (ASN.1):
Specification of basic notation.
ISO 10303-1:1994, Industrial automation systems and integration - Product data representation and
exchange - Part 1: Overview and fundamental principles.
ISO 10303-11:1994, Industrial automation systems and integration - Product data representation and
exchange - Part 11: Description methods: The EXPRESS language reference manual.
ISO 10303-21:1994, Industrial automation systems and integration - Product data representation and
exchange - Part 21: Implementation methods: Clear text encoding of the exchange structure.
ISO 10303-22:1998, Industrial automation systems and integration - Product data representation and
exchange - Part 22: Implementation methods: Standard data access interface.
ISO 10303-31:1994, Industrial automation systems and integration - Product data representation and
exchange - Part 31: Conformance testing methodology and framework: General concepts.
3 Definitions and abbreviations
For the purposes of this part of ISO 10303, the following definitions and naming conventions apply.
3.1 Definitions
3.1.1 Terms defined in ISO 10303-1
This part of ISO 10303 makes use of the following terms defined in ISO 10303-1:
— application;
— application protocol;
— data;
— implementation method;
— information;
— information model;
— product information model;
— structure.
3.1.2 Terms defined in ISO 10303-11
This part of ISO 10303 makes use of the following terms defined in ISO 10303-11:
— complex entity data type;
— data type;
— entity;
— entity data type;
— entity instance;
— instance;
— population;
— value.
3.1.3 Terms defined in ISO 10303-22
This part of ISO 10303 makes use of the following terms defined in ISO 10303-22:
— application schema;
— concurrent access;
— constraint;
— current schema;
— external schema;
— foreign schema;
— identifier;
— implementation class;
— iterator;
— native schema;
— repository;
— schema instance;
— SDAI-model;
— session;
— validation.
3.1.4 Terms defined in The Annotated C++ Reference Manual
This part of ISO 10303 makes use of the following terms defined in The Annotated C++ Reference
Manual:
— base class;
— C++ programming language;
— class;
— derived class;
— lvalue;
— member function;
— placement;
— virtual base class;
— user-defined conversion operator.
3.1.5 Term defined in IEEE standard
This part of ISO 10303 makes use of the following term defined in the IEEE standard for binary floating-
point arithmetic:
— NaN.
3.1.6 Other definitions
For the purpose of this part of ISO 10303, the following definitions apply.
3.1.6.1 accessor member function: a member function of a C++ class that is used to set, retrieve, unset
or test an attribute of that class.
3.1.6.2 convenience function: a function provided by a language binding in order to provide a more
convenient implementation.
3.1.6.3 copy constructor: a C++ constructor which makes a copy of an instance of the same class.
3.1.6.4 deep copy: a copy of an instance of a class in which member objects pointed to are recursively
copied.
3.1.6.5 default constructor: any C++ constructor which takes no arguments.
3.1.6.6 handle: an abstract data type which consists of a reference to a C++ class. A handle to class type
may hold a null reference (i.e. a reference to no instance) or a reference to an instance of class
or a reference to an instance of a subclass of type .
3.1.6.7 narrow: to assign an object reference of a given class to an object reference of a derived class
of the given class.
3.1.6.8 primitive: a term used to describe the following EXPRESS data types, INTEGER, REAL,
LOGICAL, BOOLEAN, STRING, BINARY, and their corresponding C++ data types.
3.1.6.9 receiver: an instance upon which a specified member function is invoked.
3.1.6.10 release: to indicate to the SDAI implementation that an object will not be used again.
3.1.6.11 SDAI operation: an operation defined in clause 10 of ISO 10303-22.
3.1.6.12 shallow copy: a copy of an instance of a class in which member objects pointed to are not
copied.
3.1.6.13 widen: to assign an object reference of a given class to an object reference of a base class of
the given class.
3.2 Abbreviations
For the purposes of this part of ISO 10303, the following abbreviations apply.
CPP C++
IDL Interface Definition Language
Repo Repository
RO Read-Only
RW Read-Write
SDAI Standard Data Access Interface
3.3 Typographical conventions
For the purposes of this part of ISO 10303, C++ language statements shall be presented as 10 point
Courier font. The C++ language statements are presented as a syntactically complete mapping of SDAI
elements. However, this part of ISO 10303 is not designed to be a compilable document. C++ language
statements specified in this part of ISO 10303 designate required functionality and should not be
interpreted as restricting implementation techniques. C++ language statements are generally separated
from text; however this is only for the purpose of clarity. The notation “” shall be used to represent
an arbitrary data type “T”.
EXAMPLE - 1 This example illustrates a C++ language statement in 10 point Courier font.
class foo { };
4 Overall requirements
4.1 Characteristics of the binding functions
If a parameter to a function has an invalid value, the behaviour is not defined in this part of ISO 10303.
EXAMPLE - 2 This example describes possible invalid values.
An invalid value may correspond to values such as a value outside the domain of the function, a pointer
outside the address space of the program, a null pointer, or an index out of range for an aggregate.
The SDAI implementation need not implement the type declarations given in this part of ISO 10303
identically. However, the SDAI implementation shall present types which shall be equivalent, from the
point of view of the user of the type, with the types prescribed in this part of ISO 10303.
For each function specification in this part of ISO 10303 which maps to an SDAI operation, the
correspondence between the operation’s SDAI input/output, as specified in ISO 10303-22, and its C++
language equivalent are provided.
Table 1 - Arguments and return values
SDAI/EXPRESS/IDL In argument Out argument Return value
INTEGER Integer Integer& Integer
REAL Real Real& Real
BOOLEAN sdaiBoolean sdaiBoolean& sdaiBoolean
LOGICAL sdaiLogical sdaiLogical& sdaiLogical
ENUMERATION   where is &
the name of an enumeration
STRING const char* char*& char*
Aggregate , const S_var& S_var& S_var
BINARY
SELECT const S_var& S_var& S_var
ANY const Any_var& Any_var& Any_var
ENTITY const E_ptr& E_ptr& E_ptr
Arguments to functions are classified as ‘in’ arguments and ‘out’ arguments. ‘In’ arguments are read-
only with respect to the function; ‘out’ arguments may be read-write with respect to the function. Except
where otherwise noted, the data types which are used for arguments and return values are given in
table 1.
EXPRESS TYPE types are treated according to the method prescribed for the underlying type.
4.2 Language specific features
4.2.1 Names of types and operations
Except where otherwise noted, the bindings of the names of operations and types to names in the C++
SDAI implementation shall be accomplished as follows. EXPRESS names for data types including
SELECT data types, ENUMERATION data types, ENTITY data types, aggregate data types, and defined
types shall be mapped to C++ names as follows: the C++ name shall be exactly the same as the
EXPRESS name except that the first character of the C++ name shall be uppercase and all other
characters shall be lowercase. This mapping shall also apply to EXPRESS schema names. The mapping
of EXPRESS attribute names shall be exactly the same as the EXPRESS name except that all characters
shall be lowercase and the name shall be followed by an underscore (“_”). In the case where the
EXPRESS ENTITY data type ends with the suffix “_ptr” or “_var”, the first letter of the suffix shall
be uppercase in the corresponding C++ class name.
EXAMPLE 3 - This example illustrates a mapping from an EXPRESS type name to a C++ type name:
in EXPRESS:
tHis_IS_a_sAMPLE_Name
in C++:
This_is_a_sample_name
in EXPRESS:
special_case_var
in C++:
Special_case_Var
4.2.2 Memory management
This part of ISO 10303 does not specify the implementation of memory management in an SDAI
implementation. The term ‘release’ is defined with respect to an object’s handle or containing aggregate.
When an object is released, either explicitly or implicitly, through its handle or containing aggregate, the
SDAI implementation may behave as if the object will no longer be addressed through that handle or
aggregate. Beyond any specified errors, the behaviour of operations on released objects is not specified
in this part of ISO 10303.
4.3 Binding styles
This document describes three binding styles for a C++ language binding to the SDAI: a) early binding
only, b) late binding only, and c) mixed binding.
Early binding functionality is to be provided by translating application schemas into the C++ classes
specified in this binding and linking the resulting code into the SDAI implementation. This instantiation
shall also include schema-dependent classes for Schema_instance, Model_contents, and
Application_instance. The portions of the binding designated by the following late binding
compiler directive:
#define SDAI_CPP_LATE_BINDING
need not be included in the early bound SDAI implementation. The classes based on the
SDAI_dictionary_schema in ISO 10303-22 need not be instantiated.
Late binding functionality shall be provided by implementing the functions designated in this binding
by the late-binding compiler directive. Dictionary classes shall be instantiated. Application schemas need
not be translated into classes and linked into the SDAI implementation. Schema-dependent classes for
Schema_instance, Model_contents, and Application_instance need not be provided.
Mixed binding functionality shall be provided by translating application schemas to the C++ classes
specified in this binding and linking the resulting code into the SDAI implementation. Schema-dependent
class for Schema_instance, Model_contents, and Application_instance shall be
provided. The functionality designated by the late-binding compiler directive shall be included in the
SDAI implementation. Dictionary classes shall be instantiated.
5 Constants and data type definitions and global functions
5.1 SDAI namespace
For implementations where namespace is available, all declarations of C++ classes and types described
in this part of ISO 10303 shall be enclosed in an outermost C++ language namespace named SDAI.
For implementations where namespace is not available, the name scoping provided by:
namespace SDAI {
class T { };
};
may be provided by
class SDAI_T { }
Each application schema shall be mapped to a C++ namespace whose name shall be the name of the
EXPRESS SCHEMA mapped according to 4.2.1. All declarations of C++ classes and types derived from
the EXPRESS application SCHEMA shall be contained in this namespace. The application schema
namespace shall not be nested in the SDAI namespace.
If the implementation supports only a single application protocol, and therefore, does not require
namespace, it need not be used.
5.2 EXPRESS built-in constants
The EXPRESS built-in constants for attribute values shall be represented by the C++ language constants
which are given in table 2.
Table 2 - EXPRESS built-in constants
EXPRESS Constant name C++ data type
FALSE SDAI::sdaiFALSE SDAI::sdaiBOOL
TRUE SDAI::sdaiTRUE SDAI::sdaiBOOL
UNKNOWN SDAI::sdaiUNKNOWN SDAI::sdaiLOGICAL
PI SDAI::PI SDAI::Real
CONST_E SDAI::E SDAI::Real
5.3 EXPRESS attribute data types
The data types of EXPRESS shall be represented by C++ data types as described below.
5.3.1 Primitive data types
The SDAI namespace shall contain the following C++ types for the primitive data types.
5.3.1.1 Integer
The following C++ types shall represent the integer values:
Type Name Range
Integer -2 ** 31 to 2 ** 31 -1
ULong 0 to 2 ** 32 -1
Short -2 ** 15 to 2 ** 15 -1
UShort 0 to 2 ** 16 -1
There shall also be a type Octet, that represents an 8-bit quantity.
The EXPRESS INTEGER data type shall be represented by the C++ type called Integer. The value
of 2 ** 31 - 1 shall designate an unset EXPRESS INTEGER. This representation does not prohibit the
type Integer as a C++ class.
5.3.1.2 Real
The EXPRESS REAL data type shall be represented by a C++ type called Real. The C++ type Real
shall be equivalent in functionality to the IEEE double precision floating point number. The value of
NaN shall designate an unset EXPRESS REAL. This representation does not prohibit the definition of
the type Real as a C++ class.
NOTE - To determine whether a Real number is equal to NaN, a method which looks like the following
may be implemented:
int isNaN(double d) { return (d != d); }
5.3.1.3 Logical
The EXPRESS LOGICAL data type shall be represented by the following C++ enumeration:
enum sdaiLogical { LFalse, LTrue, LUnset, LUnknown };
The enumerators of the enum sdaiLogical shall correspond to the states EXPRESS FALSE, EXPRESS
TRUE, unset, and EXPRESS UNKNOWN respectively.
The C++ class sdaiLOGICAL shall implement the behaviour of the EXPRESS LOGICAL type,
including support for the relational operators. The following class definition specifies the behaviour of
the LOGICAL type:
class sdaiBOOL;
class sdaiLOGICAL {
public:
sdaiLOGICAL();
The default constructor shall create an instance whose va
...