Instance Header API Calls

...

This call is an aggregate of several SetSPFFHeaderItem calls. In several cases the header can be set easily with this call. In case an argument is zero, this argument will not be updated, i.e. it will not be filled with 0.

This call can be used to write a specific header item, the source code example is larger to show and explain how this call can be used.

This call can be used to read a specific header item, the source code example is larger to show and explain how this call can be used.

Returns an current date and time according to ISO 8601 without time zone, i.e. formatted as '2099-12-31T23:59:59'.

Returns an current date and time according to ISO 8601 without time zone, i.e. formatted as '2099-12-31T23:59:59'.

Returns an identifier for the current instance of this library including date stamp and revision number.

Returns an identifier for the current instance of this library including date stamp and revision number.

Returns the value as defined by SCHEMA in the loaded EXPRESS schema.

Returns the value as defined by SCHEMA in the loaded EXPRESS schema.

...

...

File IO API Calls

The following calls can be used to open, save and close Geometry Kernel models or part of them.

This function creates and empty model (we expect with a schema file given).
Attributes repository and fileName will be ignored, they are their because of backward compatibility.
A handle to the model will be returned, or 0 in case something went wrong.

This function creates and empty model (we expect with a schema file given).
Attributes repository and fileName will be ignored, they are their because of backward compatibility.
A handle to the model will be returned, or 0 in case something went wrong.

This function opens the model on location fileName.
Attribute repository will be ignored, they are their because of backward compatibility.
A handle to the model will be returned, or 0 in case something went wrong.

This function opens the model on location fileName.
Attribute repository will be ignored, they are their because of backward compatibility.
A handle to the model will be returned, or 0 in case something went wrong.

This function opens the model via a stream. Attribute repository will be ignored, they are their because of backward compatibility. A handle to the model will be returned, or 0 in case something went wrong.

This function opens the model via an array.
Attribute repository will be ignored, they are their because of backward compatibility.
A handle to the model will be returned, or 0 in case something went wrong.

This function saves the model (char file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model (wchar, i.e. Unicode file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as a stream. If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - callback function not recognized

This function saves the model as an array. If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - content or size could not be set

This function saves the model as XML according to IFC2x3's way of XML serialization (char file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as XML according to IFC2x3's way of XML serialization (wchar, i.e. Unicode file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as XML according to IFC4's way of XML serialization (char file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as XML according to IFC4's way of XML serialization (wchar, i.e. Unicode file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as JSON according to IFC4's way of JSON serialization (char file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the model as JSON according to IFC4's way of JSON serialization (wchar, i.e. Unicode file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the schema. If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function saves the schema (wchar, i.e. Unicode file name). If save operation finished succesfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle 2 - file at path location cannot be created/overwritten

This function closes the model. After this call no instance handles will be available including all handles referencing the geometry of this specific file, in default compilation the model itself will be known in the kernel, however known to be disabled. Calls containing the model reference will be protected from crashing when called. If the model is closed successfully the return value will be 0, in case of non-zero value: 1 - model is NULL or not recognized as a model handle

...

Schema Reading API Calls

The collection of calls that allow reading, writing and modification of the design tree dedicated to Classes.

This call returns next iterator of EXPRESS schema declarations for entities and types. If the input iterator is NULL it returns first iterator. If the input iterator is last it returns NULL. The declaration can be ENTITY, TYPE ENUM, TYPE SELECT, or defined TYPE. Use engiGetDeclarationFromIterator to access the further information.

This call returns handle to the EXPRESS schema declaration from iterator. The declaration can be ENTITY, TYPE ENUM, TYPE SELECT, or defined TYPE. Use engiGetDeclarationType to access the further information. Use engiGetNextTypeDeclarationIterator to iterate declarations.

This call iterates EXPRESS schema declarations of FUNCTION, PROCEDURE or RULE. If prev is NULL it returns first declaration of above kinds. If prev is the last declaration it returns NULL. Use engiGetDeclarationType to access the further information.

This call returns a type of the EXPRESS schema declarations from its handle. The following functions can be used to get further information ENTITY: this SchemaDecl can be casted to SdaiEntity and used in engiGetEntityName and any other entity inquiry function TYPE ENUM: engiGetEnumerationElement TYPE SELECT: engiGetSelectElement DEFINED_TYPE: engiGetDefinedType FUNCTION, PROCEDURE, RULE, WHERE_RULE: engiGetScriptText Use engiGetTypeDeclarationFromIterator or engiGetSchemaScriptDeclarationByIterator to obtain declaration handle.

This call returns a name of the enumeration element with the given index (zero based). It returns NULL if the index out of range.

This call returns a declaration handle of the select element with the given index (zero based). It returns 0 if the index out of range.

This call returns a simple type for defined type handle and can inquire referenced type, if any.

This call returns name and body text for entity local (where) rule, schema rule, function or procedure.

This function can evaluate EXPRESS expression for entity where rule or derived attribute, valueType, value and return type work similary to sdaiGetAttr.

This call retrieves a handle to an entity based on a given entity name.

This call retrieves a handle to an entity composed of the supplied simple entity types.

This call retrieves a handle to an entity composed of the supplied simple entity types.

This call retrieves a model based on a given entity handle.

Get a position in a step file record where the value of the attribute is stored for simple instance or for component of complex instance. In case of complex entities 'entity' is a component of the complex entity. The position is 0-based. Returns -1 if the attribute has no slot to store value (inverse, pure derived or irrelevant attribute) or when 'entity' is a complex entity.

Returns the total number of entities within the loaded schema.

This call returns a specific entity based on an index, the index needs to be 0 or higher but lower then the number of entities in the loaded schema.

This call retrieves an aggregation that contains all instances of the entity given.

This call retrieves an aggregation that contains all instances of the entity given. Technically sdaiGetEntityExtentBN will transform into the following call

    sdaiGetEntityExtent(
            model,
            sdaiGetEntity(
                    model,
                    entityName
                )
        );

This call can be used to get the name of the given entity.

This call can be used to get the name of the given entity.

This call returns the number of arguments, this includes the arguments of its (nested) parents and inverse arguments.

This call returns the number of attributes, inclusion of parents and inverse depends on includeParent and includeInverse values.

Returns the first parent entity, for example the parent of IfcObject is IfcObjectDefinition, of IfcObjectDefinition is IfcRoot and of IfcRoot is 0.

Returns number of parent entities.

Returns the N-th parent of entity or NULL if index exceeds number of parents.

Checks if the entity is a supertype of another entity. An entity is supertype of itself.

This function checks if the attribute is derived and returns a script to be used to calculate the value of the attribute. If entity is NULL it checks declaration in defining entity (the most common supertype where the attribute is first declared), otherwise it also checks the actual redeclaration for specified entity.

This call can be used to check if an attribute is defined schema wise in the context of a certain entity. Technically engiGetAttrDerivedBN will transform into the following call

    engiGetAttrDerived(
            entity,
            sdaiGetAttrDefinition(
                    entity,
                    attributeName
                )
        );

This call can be used to check if an attribute is an inverse relation

This call can be used to check if an attribute is an inverse relation. Technically engiIsAttrInverseBN will transform into the following call

    engiIsAttrInverse(
            sdaiGetAttrDefinition(
                    entity,
                    attributeName
                )
        );

This call can be used to check if an attribute is optional.

This call can be used to check if an attribute is optional. Technically engiIsAttrOptionalBN will transform into the following call

    engiIsAttrOptional(
            sdaiGetAttrDefinition(
                    entity,
                    attributeName
                )
        );

Iterates actual attribute redeclarations for given entity. sdaiGetAttrDefinition and other functions returns the first definition in the most common supertype. This function allow to explore redeclarations by subtypes.

This call can be used to get the domain of an attribute.

This call can be used to get the domain of an attribute. Technically engiGetAttrDomainNameBN will transform into the following call

    engiGetAttrDomainName(
            sdaiGetAttrDefinition(
                    entity,
                    attributeName
                ),
            domainName
        );

This call can be used to check if an entity is abstract.

This call can be used to check if an entity is abstract. Technically engiIsEntityAbstractBN will transform into the following call

    engiIsEntityAbstract(
            sdaiGetEntity(
                    model,
                    entityName
                )
        );

Allows to retrieve enumeration values of an attribute by index.

Iterates attribute definition of the entity. Includes explicit, inverse and derived attributes defined by this or parent entities. If a explicit attribute is also known as derived it's reported ones as explicit. Returns first attribute if prev is NULL. Returns NULL when prev is the last attribute.

...

Iterates unique rules of the entity. Includes this but not parent entities. Returns first rule if prev is NULL. Returns NULL when prev is the last rule.

Iterates attributes of unique rule. Returns first attribute name if prev is NULL. Returns NULL when prev is the name of the last attribute.

Iterates where rules of the entity or defined type. Declaration can be ENTITY or DEFINED_TYPE. Includes this but not parent entities or types. Returns first rule if prev is NULL. Returns NULL when prev is the last rule. Use engiGetScriptText to get further information.

Instance Reading API Calls

...

This call can be used to get the used type within this ADB type.

This call can be used to get the path of an ADB type.

valueType argument to specify what type of data caller wants to get and value argument where the caller should provide a buffer, and the function will write the result to. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiGetADBValue, and it works similarly for all get-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. The Table 2 shows what valueType can be fulfilled depending on actual model data. On success get-function will return non-zero. More precisely, according to ISO 10303-24-2001 on success they return content of value argument (*value) for sdaiADB, sdaiAGGR, or sdaiINSTANCE or value argument itself for other types (it has no useful meaning for C#). All get-functions return NULL and set value to 0 if model data are incompatible with requested valueType. Furthermore: - for unset ($) data all get-functions return NULL and set value to 0, except when valueType = sdaiEXPRESSSTRING - for derived (*), depending on engiEnableDerivedAttributes, and except valueType = sdaiEXPRESSSTRING: -- either calculate and follow these rues for calculated value -- or handles it as unset ($) - if valueType = sdaiEXPRESSSTRING and data is unset ($) or derived (*), get-function will return NULL but set value to "$" or "*" respectively for any engiEnableDerivedAttributes state 

Table 1 – Required value buffer depending on valueType (on the example of sdaiGetADBValue but valid for all get-functions)

valueType               C/C++                                               C#

sdaiINTEGER             int_t val;                                          int_t val;
                        sdaiGetADBValue (ADB, sdaiINTEGER, &val);           IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiINTEGER, out val);

sdaiREAL or sdaiNUMBER  double val;                                         double val;
                        sdaiGetADBValue (ADB, sdaiREAL, &val);              IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiREAL, out val);

sdaiBOOLEAN             SdaiBoolean val;                                    bool val;
                        sdaiGetADBValue (ADB, sdaiBOOLEAN, &val);           IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiBOOLEAN, out val);

sdaiLOGICAL             const TCHAR* val;                                   string val;
                        sdaiGetADBValue (ADB, sdaiLOGICAL, &val);           IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiLOGICAL, out val);

sdaiENUM                const TCHAR* val;                                   string val;
                        sdaiGetADBValue (ADB, sdaiENUM, &val);              IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiENUM, out val);

sdaiBINARY              const TCHAR* val;                                   string val;
                        sdaiGetADBValue (ADB, sdaiBINARY, &val);            IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiBINARY, out val);

sdaiSTRING              const char* val;                                    string val;
                        sdaiGetADBValue (ADB, sdaiSTRING, &val);            IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiSTRING, out val);

sdaiUNICODE             const wchar_t* val;                                 string val;
                        sdaiGetADBValue (ADB, sdaiUNICODE, &val);           IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiUNICODE, out val);

sdaiEXPRESSSTRING       const char* val;                                    string val;
                        sdaiGetADBValue (ADB, sdaiEXPRESSSTRING, &val);     IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiEXPRESSSTRING, out val);

sdaiINSTANCE            SdaiInstance val;                                   int_t val;
                        sdaiGetADBValue (ADB, sdaiINSTANCE, &val);          IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiINSTANCE, out val);

sdaiAGGR                SdaiAggr aggr;                                      int_t aggr;
                        sdaiGetADBValue (ADB, sdaiAGGR, &aggr);             IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiAGGR, out aggr);

sdaiADB                 SdaiADB adb = sdaiCreateEmptyADB();                 int_t adb = IFCEngine.sdaiCreateEmptyADB();
                        sdaiGetADBValue (ADB, sdaiADB, adb);                IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiADB, adb);
                        ...                                                 ...
                        sdaiDeleteADB (adb);    //  optional                IFCEngine.sdaiDeleteADB (adb);  //  optional

                        SdaiADB adb = nullptr;                              int_t adb = 0;  //  it is important to initialize
                        sdaiGetADBValue (ADB, sdaiADB, &adb);               IFCEngine.sdaiGetADBValue (ADB, IFCEngine.sdaiADB, out adb);
                        ...                                                 ...
                        sdaiDeleteADB (adb);    //  optional                IFCEngine.sdaiDeleteADB (adb);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiCreateEmptyADB and sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list
sdaiINTEGER         Yes         Yes *        .           .           .           .           .           .           .
sdaiREAL            Yes         Yes          .           .           .           .           .           .           .
sdaiNUMBER          Yes         Yes          .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .
sdaiSTRING          Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiUNICODE         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiEXPRESSSTRING   Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes

(Non-standard extensions) sdaiGetADBValue: sdaiADB is allowed and will success when sdaiGetADBTypePath is not NULL, returning ABD value has type path element removed.

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPutADBValue, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPutADBValue but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiPutADBValue (ADB, sdaiINTEGER, &val);                   IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiPutADBValue (ADB, sdaiREAL, &val);                      IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiPutADBValue (ADB, sdaiBOOLEAN, &val);                   IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiPutADBValue (ADB, sdaiLOGICAL, val);                    IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiPutADBValue (ADB, sdaiENUM, val);                       IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiPutADBValue (ADB, sdaiBINARY, val);                     IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiPutADBValue (ADB, sdaiSTRING, val);                     IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiPutADBValue (ADB, sdaiUNICODE, val);                    IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPutADBValue (ADB, sdaiEXPRESSSTRING, val);              IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPutADBValue (ADB, sdaiINSTANCE, val);                   IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPutADBValue (ADB, sdaiAGGR, val);                       IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPutADBValue (ADB, sdaiADB, val);                        IFCEngine.sdaiPutADBValue (ADB, IFCEngine.sdaiADB, val);    
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

Creates an empty ADB (Attribute Data Block).

Deletes an ADB (Attribute Data Block).

valueType argument to specify what type of data caller wants to get and value argument where the caller should provide a buffer, and the function will write the result to. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiGetAggrByIndex, and it works similarly for all get-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. The Table 2 shows what valueType can be fulfilled depending on actual model data. On success get-function will return non-zero. More precisely, according to ISO 10303-24-2001 on success they return content of value argument (*value) for sdaiADB, sdaiAGGR, or sdaiINSTANCE or value argument itself for other types (it has no useful meaning for C#). All get-functions return NULL and set value to 0 if model data are incompatible with requested valueType. Furthermore: - for unset ($) data all get-functions return NULL and set value to 0, except when valueType = sdaiEXPRESSSTRING - for derived (*), depending on engiEnableDerivedAttributes, and except valueType = sdaiEXPRESSSTRING: -- either calculate and follow these rues for calculated value -- or handles it as unset ($) - if valueType = sdaiEXPRESSSTRING and data is unset ($) or derived (*), get-function will return NULL but set value to "$" or "*" respectively for any engiEnableDerivedAttributes state 

Table 1 – Required value buffer depending on valueType (on the example of sdaiGetAggrByIndex but valid for all get-functions)

valueType               C/C++                                                               C#

sdaiINTEGER             int_t val;                                                          int_t val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiINTEGER, &val);           IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiINTEGER, out val);

sdaiREAL or sdaiNUMBER  double val;                                                         double val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiREAL, &val);              IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiREAL, out val);

sdaiBOOLEAN             SdaiBoolean val;                                                    bool val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiBOOLEAN, &val);           IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiBOOLEAN, out val);

sdaiLOGICAL             const TCHAR* val;                                                   string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiLOGICAL, &val);           IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiLOGICAL, out val);

sdaiENUM                const TCHAR* val;                                                   string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiENUM, &val);              IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiENUM, out val);

sdaiBINARY              const TCHAR* val;                                                   string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiBINARY, &val);            IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiBINARY, out val);

sdaiSTRING              const char* val;                                                    string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiSTRING, &val);            IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiSTRING, out val);

sdaiUNICODE             const wchar_t* val;                                                 string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiUNICODE, &val);           IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiUNICODE, out val);

sdaiEXPRESSSTRING       const char* val;                                                    string val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiEXPRESSSTRING, &val);     IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiEXPRESSSTRING, out val);

sdaiINSTANCE            SdaiInstance val;                                                   int_t val;
                        sdaiGetAggrByIndex (aggregate, index, sdaiINSTANCE, &val);          IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiINSTANCE, out val);

sdaiAGGR                SdaiAggr aggr;                                                      int_t aggr;
                        sdaiGetAggrByIndex (aggregate, index, sdaiAGGR, &aggr);             IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiAGGR, out aggr);

sdaiADB                 SdaiADB adb = sdaiCreateEmptyADB();                                 int_t adb = IFCEngine.sdaiCreateEmptyADB();
                        sdaiGetAggrByIndex (aggregate, index, sdaiADB, adb);                IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiADB, adb);
                        ...                                                                 ...
                        sdaiDeleteADB (adb);    //  optional                                IFCEngine.sdaiDeleteADB (adb);  //  optional

                        SdaiADB adb = nullptr;                                              int_t adb = 0;  //  it is important to initialize
                        sdaiGetAggrByIndex (aggregate, index, sdaiADB, &adb);               IFCEngine.sdaiGetAggrByIndex (aggregate, index, IFCEngine.sdaiADB, out adb);
                        ...                                                                 ...
                        sdaiDeleteADB (adb);    //  optional                                IFCEngine.sdaiDeleteADB (adb);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiCreateEmptyADB and sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list
sdaiINTEGER         Yes         Yes *        .           .           .           .           .           .           .
sdaiREAL            Yes         Yes          .           .           .           .           .           .           .
sdaiNUMBER          Yes         Yes          .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .
sdaiSTRING          Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiUNICODE         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiEXPRESSSTRING   Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes

(Non-standard extensions) sdaiGetADBValue: sdaiADB is allowed and will success when sdaiGetADBTypePath is not NULL, returning ABD value has type path element removed.

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPutAggrByIndex, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPutAggrByIndex but valid for all put-functions)

valueType               C/C++                                                           C#

sdaiINTEGER             int_t val = 123;                                                int_t val = 123;
                        sdaiPutAggrByIndex (aggregate, index, sdaiINTEGER, &val);       IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                           double val = 123.456;
                        sdaiPutAggrByIndex (aggregate, index, sdaiREAL, &val);          IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                     bool val = true;
                        sdaiPutAggrByIndex (aggregate, index, sdaiBOOLEAN, &val);       IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                         string val = "U";
                        sdaiPutAggrByIndex (aggregate, index, sdaiLOGICAL, val);        IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                                string val = "NOTDEFINED";
                        sdaiPutAggrByIndex (aggregate, index, sdaiENUM, val);           IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                                string val = "0123456ABC";
                        sdaiPutAggrByIndex (aggregate, index, sdaiBINARY, val);         IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                           string val = "My Simple String";
                        sdaiPutAggrByIndex (aggregate, index, sdaiSTRING, val);         IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                     string val = "Any Unicode String";
                        sdaiPutAggrByIndex (aggregate, index, sdaiUNICODE, val);        IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";      string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPutAggrByIndex (aggregate, index, sdaiEXPRESSSTRING, val);  IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE");     int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPutAggrByIndex (aggregate, index, sdaiINSTANCE, val);       IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                        int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                          IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPutAggrByIndex (aggregate, index, sdaiAGGR, val);           IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                       int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);       int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                      IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPutAggrByIndex (aggregate, index, sdaiADB, val);            IFCEngine.sdaiPutAggrByIndex (aggregate, index, IFCEngine.sdaiADB, val);    
                        ...                                                             ...
                        sdaiDeleteADB (val);    //  optional                            IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

This call returns the type used within an aggregation according to the instance (independent of the schema definition)

This call returns the type used within an aggregation according to the instance (independent of the schema definition)

valueType argument to specify what type of data caller wants to get and value argument where the caller should provide a buffer, and the function will write the result to. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiGetAttr, and it works similarly for all get-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. The Table 2 shows what valueType can be fulfilled depending on actual model data. On success get-function will return non-zero. More precisely, according to ISO 10303-24-2001 on success they return content of value argument (*value) for sdaiADB, sdaiAGGR, or sdaiINSTANCE or value argument itself for other types (it has no useful meaning for C#). All get-functions return NULL and set value to 0 if model data are incompatible with requested valueType. Furthermore: - for unset ($) data all get-functions return NULL and set value to 0, except when valueType = sdaiEXPRESSSTRING - for derived (*), depending on engiEnableDerivedAttributes, and except valueType = sdaiEXPRESSSTRING: -- either calculate and follow these rues for calculated value -- or handles it as unset ($) - if valueType = sdaiEXPRESSSTRING and data is unset ($) or derived (*), get-function will return NULL but set value to "$" or "*" respectively for any engiEnableDerivedAttributes state 

Table 1 – Required value buffer depending on valueType (on the example of sdaiGetAttr but valid for all get-functions)

valueType               C/C++                                                           C#

sdaiINTEGER             int_t val;                                                      int_t val;
                        sdaiGetAttr (instance, attribute, sdaiINTEGER, &val);           IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiINTEGER, out val);

sdaiREAL or sdaiNUMBER  double val;                                                     double val;
                        sdaiGetAttr (instance, attribute, sdaiREAL, &val);              IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiREAL, out val);

sdaiBOOLEAN             SdaiBoolean val;                                                bool val;
                        sdaiGetAttr (instance, attribute, sdaiBOOLEAN, &val);           IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiBOOLEAN, out val);

sdaiLOGICAL             const TCHAR* val;                                               string val;
                        sdaiGetAttr (instance, attribute, sdaiLOGICAL, &val);           IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiLOGICAL, out val);

sdaiENUM                const TCHAR* val;                                               string val;
                        sdaiGetAttr (instance, attribute, sdaiENUM, &val);              IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiENUM, out val);

sdaiBINARY              const TCHAR* val;                                               string val;
                        sdaiGetAttr (instance, attribute, sdaiBINARY, &val);            IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiBINARY, out val);

sdaiSTRING              const char* val;                                                string val;
                        sdaiGetAttr (instance, attribute, sdaiSTRING, &val);            IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiSTRING, out val);

sdaiUNICODE             const wchar_t* val;                                             string val;
                        sdaiGetAttr (instance, attribute, sdaiUNICODE, &val);           IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiUNICODE, out val);

sdaiEXPRESSSTRING       const char* val;                                                string val;
                        sdaiGetAttr (instance, attribute, sdaiEXPRESSSTRING, &val);     IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiEXPRESSSTRING, out val);

sdaiINSTANCE            SdaiInstance val;                                               int_t val;
                        sdaiGetAttr (instance, attribute, sdaiINSTANCE, &val);          IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiINSTANCE, out val);

sdaiAGGR                SdaiAggr aggr;                                                  int_t aggr;
                        sdaiGetAttr (instance, attribute, sdaiAGGR, &aggr);             IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiAGGR, out aggr);

sdaiADB                 SdaiADB adb = sdaiCreateEmptyADB();                             int_t adb = IFCEngine.sdaiCreateEmptyADB();
                        sdaiGetAttr (instance, attribute, sdaiADB, adb);                IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiADB, adb);
                        ...                                                             ...
                        sdaiDeleteADB (adb);    //  optional                            IFCEngine.sdaiDeleteADB (adb);  //  optional

                        SdaiADB adb = nullptr;                                          int_t adb = 0;  //  it is important to initialize
                        sdaiGetAttr (instance, attribute, sdaiADB, &adb);               IFCEngine.sdaiGetAttr (instance, attribute, IFCEngine.sdaiADB, out adb);
                        ...                                                             ...
                        sdaiDeleteADB (adb);    //  optional                            IFCEngine.sdaiDeleteADB (adb);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiCreateEmptyADB and sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list
sdaiINTEGER         Yes         Yes *        .           .           .           .           .           .           .
sdaiREAL            Yes         Yes          .           .           .           .           .           .           .
sdaiNUMBER          Yes         Yes          .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .
sdaiSTRING          Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiUNICODE         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiEXPRESSSTRING   Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes

(Non-standard extensions) sdaiGetADBValue: sdaiADB is allowed and will success when sdaiGetADBTypePath is not NULL, returning ABD value has type path element removed.

valueType argument to specify what type of data caller wants to get and value argument where the caller should provide a buffer, and the function will write the result to. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiGetAttrBN, and it works similarly for all get-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. The Table 2 shows what valueType can be fulfilled depending on actual model data. On success get-function will return non-zero. More precisely, according to ISO 10303-24-2001 on success they return content of value argument (*value) for sdaiADB, sdaiAGGR, or sdaiINSTANCE or value argument itself for other types (it has no useful meaning for C#). All get-functions return NULL and set value to 0 if model data are incompatible with requested valueType. Furthermore: - for unset ($) data all get-functions return NULL and set value to 0, except when valueType = sdaiEXPRESSSTRING - for derived (*), depending on engiEnableDerivedAttributes, and except valueType = sdaiEXPRESSSTRING: -- either calculate and follow these rues for calculated value -- or handles it as unset ($) - if valueType = sdaiEXPRESSSTRING and data is unset ($) or derived (*), get-function will return NULL but set value to "$" or "*" respectively for any engiEnableDerivedAttributes state 

Table 1 – Required value buffer depending on valueType (on the example of sdaiGetAttrBN but valid for all get-functions)

valueType               C/C++                                                               C#

sdaiINTEGER             int_t val;                                                          int_t val;
                        sdaiGetAttrBN (instance, "attrName", sdaiINTEGER, &val);            IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiINTEGER, out val);

sdaiREAL or sdaiNUMBER  double val;                                                         double val;
                        sdaiGetAttrBN (instance, "attrName", sdaiREAL, &val);               IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiREAL, out val);

sdaiBOOLEAN             SdaiBoolean val;                                                    bool val;
                        sdaiGetAttrBN (instance, "attrName", sdaiBOOLEAN, &val);            IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiBOOLEAN, out val);

sdaiLOGICAL             const TCHAR* val;                                                   string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiLOGICAL, &val);            IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiLOGICAL, out val);

sdaiENUM                const TCHAR* val;                                                   string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiENUM, &val);               IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiENUM, out val);

sdaiBINARY              const TCHAR* val;                                                   string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiBINARY, &val);             IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiBINARY, out val);

sdaiSTRING              const char* val;                                                    string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiSTRING, &val);             IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiSTRING, out val);

sdaiUNICODE             const wchar_t* val;                                                 string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiUNICODE, &val);            IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiUNICODE, out val);

sdaiEXPRESSSTRING       const char* val;                                                    string val;
                        sdaiGetAttrBN (instance, "attrName", sdaiEXPRESSSTRING, &val);      IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiEXPRESSSTRING, out val);

sdaiINSTANCE            SdaiInstance val;                                                   int_t val;
                        sdaiGetAttrBN (instance, "attrName", sdaiINSTANCE, &val);           IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiINSTANCE, out val);

sdaiAGGR                SdaiAggr aggr;                                                      int_t aggr;
                        sdaiGetAttrBN (instance, "attrName", sdaiAGGR, &aggr);              IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiAGGR, out aggr);

sdaiADB                 SdaiADB adb = sdaiCreateEmptyADB();                                 int_t adb = IFCEngine.sdaiCreateEmptyADB();
                        sdaiGetAttrBN (instance, "attrName", sdaiADB, adb);                 IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiADB, adb);
                        ...                                                                 ...
                        sdaiDeleteADB (adb);    //  optional                                IFCEngine.sdaiDeleteADB (adb);  //  optional

                        SdaiADB adb = nullptr;                                              int_t adb = 0;  //  it is important to initialize
                        sdaiGetAttrBN (instance, "attrName", sdaiADB, &adb);                IFCEngine.sdaiGetAttrBN (instance, "attrName", IFCEngine.sdaiADB, out adb);
                        ...                                                                 ...
                        sdaiDeleteADB (adb);    //  optional                                IFCEngine.sdaiDeleteADB (adb);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiCreateEmptyADB and sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list
sdaiINTEGER         Yes         Yes *        .           .           .           .           .           .           .
sdaiREAL            Yes         Yes          .           .           .           .           .           .           .
sdaiNUMBER          Yes         Yes          .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .
sdaiSTRING          Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiUNICODE         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiEXPRESSSTRING   Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes

(Non-standard extensions) sdaiGetADBValue: sdaiADB is allowed and will success when sdaiGetADBTypePath is not NULL, returning ABD value has type path element removed. Technically sdaiGetAttrBN will transform into the following call
    sdaiGetAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            valueType,
            value
        );

...

This function is a specific version of sdaiGetAttrBN(..), where the valueType is sdaiSTRING. This call can be useful in case of specific programming languages that cannot map towards sdaiGetAttrBN(..) directly, this function is useless for languages as C, C++, C#, JAVA, VB.NET, Delphi and similar as they are able to map sdaiGetAttrBN(..) directly. Technically sdaiGetStringAttrBN will transform into the following call

    char    * rValue = 0;
    sdaiGetAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            sdaiSTRING,
            &rValue
        );
    return  rValue;

This function is a specific version of sdaiGetAttrBN(..), where the valueType is sdaiINSTANCE. This call can be useful in case of specific programming languages that cannot map towards sdaiGetAttrBN(..) directly, this function is useless for languages as C, C++, C#, JAVA, VB.NET, Delphi and similar as they are able to map sdaiGetAttrBN(..) directly. Technically sdaiGetInstanceAttrBN will transform into the following call

    SdaiInstance    inst = 0;
    sdaiGetAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            sdaiINSTANCE,
            &inst
        );
    return  inst;

This function is a specific version of sdaiGetAttrBN(..), where the valueType is sdaiAGGR. This call can be useful in case of specific programming languages that cannot map towards sdaiGetAttrBN(..) directly, this function is useless for languages as C, C++, C#, JAVA, VB.NET, Delphi and similar as they are able to map sdaiGetAttrBN(..) directly. Technically sdaiGetAggregationAttrBN will transform into the following call

    SdaiAggr    aggr = 0;
    sdaiGetAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            sdaiAGGR,
            &aggr
        );
    return  aggr;

...

The function returns information how the attribute is declared in the schema. 'attribute' may by a base declaration received by sdaiGetAttrDefinition, engiGetEntityAttributeByIterator, etc. or redeclaration by engiGetAttrRedeclarationByIterator. 'definingEntity' is the entity which declares or re-decelerates the attribute.

This call can be used to get the name of the given attribute.

...

...

...

Returns the model based on an instance.

Returns the entity based on an instance.

Returns the number of elements within an aggregation.

This call checks if an instance is a type of a certain given entity.

This call checks if an instance is a type of a certain given entity. Technically sdaiIsKindOfBN will transform into the following call

    sdaiIsKindOf(
            instance,
            sdaiGetEntity(
                    engiGetEntityModel(
                            sdaiGetInstanceType(
                                    instance
                                )
                        ),
                    entityName
        );

Returns primitive SDAI data type for the attribute according to schema, e.g. sdaiINTEGER In case of aggregation if will return base primitive type combined with engiTypeFlagAggr, e.g. sdaiINTEGER|engiTypeFlagAggr For SELECT it will return sdaiINSTANCE if all options are instances or aggregation of instances, either sdaiADB In case of SELECT and sdaiINSTANCE, return value will be combined with engiTypeFlagAggrOption if some options are aggregation or engiTypeFlagAggr if all options are aggregations of instances Comparing with engiGetExpressAttrType this function drills down into defined type to find base primitive type. It works for explicit and inverse attributes

Combines sdaiGetAttrDefinition and engiGetAttrType. Technically engiGetAttrTypeBN will transform into the following call

    engiGetAttrType(
            sdaiGetAttrDefinition(
                    entity,
                    attributeName
                )
        );

...

...

Returns SDAI type for actual data stored in the instance for the attribute, compare with engiGetAttrType that returns type according to schema. It may be primitive type, sdaiAGGR or sdaiADB. Returns 0 for $ and *.

Combines sdaiGetAttrDefinition and engiGetInstanceAttrType. Technically engiGetInstanceAttrTypeBN will transform into the following call

    engiGetInstanceAttrType(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                )
        );

This call checks if an instance is an exact instance of a given entity.

This call checks if an instance is an exact instance of a given entity. Technically sdaiIsInstanceOfBN will transform into the following call

    sdaiIsInstanceOf(
            instance,
            sdaiGetEntity(
                    engiGetEntityModel(
                            sdaiGetInstanceType(
                                    instance
                                )
                        ),
                    entityName
                )
        );

...

...

Technically it will transform into the following call

    sdaiValidateAttribute(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                )
        );

...

...

...

The function returns the identifiers of all the entity instances in the defined domain that reference the specified entity instance.

The function returns the identifiers of all the entity instances in the defined domain that reference the specified entity instance by the specified attribute (role).

The function returns the identifiers of all the entity instances in the defined domain that reference the specified entity instance by the specified attribute (with roleName). Technically sdaiFindInstanceUsedInBN will transform into the following call sdaiFindInstanceUsedIn( instance, sdaiGetAttrDefinition( sdaiGetInstanceType( instance ), roleName ), domain, resultList );

Instance Writing API Calls

...

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPrepend, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPrepend but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiPrepend (aggregate, sdaiINTEGER, &val);                 IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiPrepend (aggregate, sdaiREAL, &val);                    IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiPrepend (aggregate, sdaiBOOLEAN, &val);                 IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiPrepend (aggregate, sdaiLOGICAL, val);                  IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiPrepend (aggregate, sdaiENUM, val);                     IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiPrepend (aggregate, sdaiBINARY, val);                   IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiPrepend (aggregate, sdaiSTRING, val);                   IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiPrepend (aggregate, sdaiUNICODE, val);                  IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPrepend (aggregate, sdaiEXPRESSSTRING, val);            IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPrepend (aggregate, sdaiINSTANCE, val);                 IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPrepend (aggregate, sdaiAGGR, val);                     IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPrepend (aggregate, sdaiADB, val);                      IFCEngine.sdaiPrepend (aggregate, IFCEngine.sdaiADB, val);  
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiAppend, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiAppend but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiAppend (aggregate, sdaiINTEGER, &val);                  IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiAppend (aggregate, sdaiREAL, &val);                     IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiAppend (aggregate, sdaiBOOLEAN, &val);                  IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiAppend (aggregate, sdaiLOGICAL, val);                   IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiAppend (aggregate, sdaiENUM, val);                      IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiAppend (aggregate, sdaiBINARY, val);                    IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiAppend (aggregate, sdaiSTRING, val);                    IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiAppend (aggregate, sdaiUNICODE, val);                   IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiAppend (aggregate, sdaiEXPRESSSTRING, val);             IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiAppend (aggregate, sdaiINSTANCE, val);                  IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiAppend (aggregate, sdaiAGGR, val);                      IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiAppend (aggregate, sdaiADB, val);                       IFCEngine.sdaiAppend (aggregate, IFCEngine.sdaiADB, val);   
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiAdd, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiAdd but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiAdd (aggregate, sdaiINTEGER, &val);                     IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiAdd (aggregate, sdaiREAL, &val);                        IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiAdd (aggregate, sdaiBOOLEAN, &val);                     IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiAdd (aggregate, sdaiLOGICAL, val);                      IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiAdd (aggregate, sdaiENUM, val);                         IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiAdd (aggregate, sdaiBINARY, val);                       IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiAdd (aggregate, sdaiSTRING, val);                       IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiAdd (aggregate, sdaiUNICODE, val);                      IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiAdd (aggregate, sdaiEXPRESSSTRING, val);                IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiAdd (aggregate, sdaiINSTANCE, val);                     IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiAdd (aggregate, sdaiAGGR, val);                         IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiAdd (aggregate, sdaiADB, val);                          IFCEngine.sdaiAdd (aggregate, IFCEngine.sdaiADB, val);  
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiInsertByIndex, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiInsertByIndex but valid for all put-functions)

valueType               C/C++                                                           C#

sdaiINTEGER             int_t val = 123;                                                int_t val = 123;
                        sdaiInsertByIndex (aggregate, index, sdaiINTEGER, &val);        IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                           double val = 123.456;
                        sdaiInsertByIndex (aggregate, index, sdaiREAL, &val);           IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                     bool val = true;
                        sdaiInsertByIndex (aggregate, index, sdaiBOOLEAN, &val);        IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                         string val = "U";
                        sdaiInsertByIndex (aggregate, index, sdaiLOGICAL, val);         IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                                string val = "NOTDEFINED";
                        sdaiInsertByIndex (aggregate, index, sdaiENUM, val);            IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                                string val = "0123456ABC";
                        sdaiInsertByIndex (aggregate, index, sdaiBINARY, val);          IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                           string val = "My Simple String";
                        sdaiInsertByIndex (aggregate, index, sdaiSTRING, val);          IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                     string val = "Any Unicode String";
                        sdaiInsertByIndex (aggregate, index, sdaiUNICODE, val);         IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";      string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiInsertByIndex (aggregate, index, sdaiEXPRESSSTRING, val);   IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE");     int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiInsertByIndex (aggregate, index, sdaiINSTANCE, val);        IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                        int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                          IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiInsertByIndex (aggregate, index, sdaiAGGR, val);            IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                       int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);       int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                      IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiInsertByIndex (aggregate, index, sdaiADB, val);             IFCEngine.sdaiInsertByIndex (aggregate, index, IFCEngine.sdaiADB, val); 
                        ...                                                             ...
                        sdaiDeleteADB (val);    //  optional                            IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiInsertBefore, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiInsertBefore but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiInsertBefore (iterator, sdaiINTEGER, &val);             IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiInsertBefore (iterator, sdaiREAL, &val);                IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiInsertBefore (iterator, sdaiBOOLEAN, &val);             IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiInsertBefore (iterator, sdaiLOGICAL, val);              IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiInsertBefore (iterator, sdaiENUM, val);                 IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiInsertBefore (iterator, sdaiBINARY, val);               IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiInsertBefore (iterator, sdaiSTRING, val);               IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiInsertBefore (iterator, sdaiUNICODE, val);              IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiInsertBefore (iterator, sdaiEXPRESSSTRING, val);        IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiInsertBefore (iterator, sdaiINSTANCE, val);             IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiInsertBefore (iterator, sdaiAGGR, val);                 IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiInsertBefore (iterator, sdaiADB, val);                  IFCEngine.sdaiInsertBefore (iterator, IFCEngine.sdaiADB, val);  
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiInsertAfter, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiInsertAfter but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiInsertAfter (iterator, sdaiINTEGER, &val);              IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiInsertAfter (iterator, sdaiREAL, &val);                 IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiInsertAfter (iterator, sdaiBOOLEAN, &val);              IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiInsertAfter (iterator, sdaiLOGICAL, val);               IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiInsertAfter (iterator, sdaiENUM, val);                  IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiInsertAfter (iterator, sdaiBINARY, val);                IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiInsertAfter (iterator, sdaiSTRING, val);                IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiInsertAfter (iterator, sdaiUNICODE, val);               IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiInsertAfter (iterator, sdaiEXPRESSSTRING, val);         IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiInsertAfter (iterator, sdaiINSTANCE, val);              IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiInsertAfter (iterator, sdaiAGGR, val);                  IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiInsertAfter (iterator, sdaiADB, val);                   IFCEngine.sdaiInsertAfter (iterator, IFCEngine.sdaiADB, val);   
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiCreateADB, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiCreateADB but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        SdaiADB adb = sdaiCreateADB (sdaiINTEGER, &val);            int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        SdaiADB adb = sdaiCreateADB (sdaiREAL, &val);               int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        SdaiADB adb = sdaiCreateADB (sdaiBOOLEAN, &val);            int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        SdaiADB adb = sdaiCreateADB (sdaiLOGICAL, val);             int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        SdaiADB adb = sdaiCreateADB (sdaiENUM, val);                int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        SdaiADB adb = sdaiCreateADB (sdaiBINARY, val);              int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        SdaiADB adb = sdaiCreateADB (sdaiSTRING, val);              int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        SdaiADB adb = sdaiCreateADB (sdaiUNICODE, val);             int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        SdaiADB adb = sdaiCreateADB (sdaiEXPRESSSTRING, val);       int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        SdaiADB adb = sdaiCreateADB (sdaiINSTANCE, val);            int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        SdaiADB adb = sdaiCreateADB (sdaiAGGR, val);                int_t adb = IFCEngine.sdaiCreateADB (IFCEngine.sdaiAGGR, val);

sdaiADB                 not applicable
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

This call creates an aggregation. The instance has to be present, the attribute argument can be empty (0) in case the aggregation is an nested aggregation for this specific instance, preferred use would be use of sdaiCreateNestedAggr in such a case.

This call creates an aggregation. The instance has to be present, the attributeName argument can be NULL (0) in case the aggregation is an nested aggregation for this specific instance, preferred use would be use of sdaiCreateNestedAggr in such a case. Technically sdaiCreateAggrBN will transform into the following call

    (attributeName) ?
        sdaiCreateAggr(
                instance,
                sdaiGetAttrDefinition(
                        sdaiGetInstanceType(
                                instance
                            ),
                        attributeName
                    )
            ) :
        sdaiCreateAggr(
                instance,
                nullptr
            );

...

...

This call creates an aggregation within an aggregation.

The function creates an aggregate instance and replaces the existing member of the specified ordered aggregate instance referenced by the specified index.

The function creates an aggregate instance as a member of the specified ordered aggregate instance. The newly created aggregate is inserted into the aggregate at the position referenced by the specified index.

The function creates an aggregate instance replacing the current member of the aggregate instance referenced by the specified iterator.

The function creates an aggregate instance as a member of a list instance. The newly created aggregate is inserted into the list instance before the member referenced by the specified iterator.

The function creates an aggregate instance as a member of a list instance. The newly created aggregate is inserted into the list instance after the member referenced by the specified iterator.

The CreateNestedAggrABD function creates an aggregate instance as a member of (an unordered) aggregate instance in the case where the type of the aggregate to create is a SELECT TYPE and ambiguous. Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function creates an aggregate instance and replaces the existing member of the specified ordered aggregate instance referenced by the specified index. Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function creates an aggregate instance as member of the specified ordered aggregate instance. The newly created aggregate is inserted into the aggregate at the position referenced by the specified index. Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function creates an aggregate instance replacing the current member of the aggregate instance referenced by the specified iterator where the type of the aggregate to create is a SELECT TYPE and ambiguous, Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function creates an aggregate instance as a member of a list instance where the type of the aggregate to create is a SELECT TYPE and ambiguous. The newly created aggregate is inserted into the list instance before the member referenced by the specified iterator. Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function creates an aggregate instance as a member of a list instance where the type of the aggregate to create is a SELECT TYPE and ambiguous. The newly created aggregate is inserted into the list instance after the member referenced by the specified iterator. Input ADB is expected to have type path. The function sets the value of the ADB with the identifier of the newly created aggregate instance.

The function removes the member of the specified list referenced by the specified index.

The function removes the current member of an aggregate instance, that is not an array, referenced by the specified iterator. After executing the function, the iterator position set as if the sdaiNext function had been invoked before the member was removed.

The function removes one occurrence of the specified value from the specified unordered aggregate instance. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiRemove, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiRemove but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiRemove (aggregate, sdaiINTEGER, &val);                  IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiRemove (aggregate, sdaiREAL, &val);                     IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiRemove (aggregate, sdaiBOOLEAN, &val);                  IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiRemove (aggregate, sdaiLOGICAL, val);                   IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiRemove (aggregate, sdaiENUM, val);                      IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiRemove (aggregate, sdaiBINARY, val);                    IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiRemove (aggregate, sdaiSTRING, val);                    IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiRemove (aggregate, sdaiUNICODE, val);                   IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiRemove (aggregate, sdaiEXPRESSSTRING, val);             IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = ...                                      int_t val = ...
                        sdaiRemove (aggregate, sdaiINSTANCE, val);                  IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = ...                                          int_t val = ...
                        sdaiRemove (aggregate, sdaiAGGR, val);                      IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiAGGR, val);

sdaiADB                 SdaiADB val = ...                                           int_t val = ...
                        sdaiRemove (aggregate, sdaiADB, val);                       IFCEngine.sdaiRemove (aggregate, IFCEngine.sdaiADB, val);
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

The function tests whether the member of the specified array referenced by the specified index position has a value.

The function tests whether the member of the specified array referenced by the specified index position has a value.

This call creates an instance of the given entity.

This call creates an instance of the given entity. Technically it will transform into the following call

    sdaiCreateInstance(
            model,
            sdaiGetEntity(
                    model,
                    entityName
                )
        );

This call creates a new application instance of the specified type, as determined by a constructed entity type that is made up of the supplied simple entity types, in the specified SDAI model.

This call creates a new application instance of the specified type, as determined by a constructed entity type that is made up of the supplied simple entity types, in the specified SDAI model.

This call will delete an existing instance.

...

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPutAttr, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPutAttr but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiPutAttr (instance, attribute, sdaiINTEGER, &val);       IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiPutAttr (instance, attribute, sdaiREAL, &val);          IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiPutAttr (instance, attribute, sdaiBOOLEAN, &val);       IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiPutAttr (instance, attribute, sdaiLOGICAL, val);        IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiPutAttr (instance, attribute, sdaiENUM, val);           IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiPutAttr (instance, attribute, sdaiBINARY, val);         IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiPutAttr (instance, attribute, sdaiSTRING, val);         IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiPutAttr (instance, attribute, sdaiUNICODE, val);        IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPutAttr (instance, attribute, sdaiEXPRESSSTRING, val);  IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPutAttr (instance, attribute, sdaiINSTANCE, val);       IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPutAttr (instance, attribute, sdaiAGGR, val);           IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPutAttr (instance, attribute, sdaiADB, val);            IFCEngine.sdaiPutAttr (instance, attribute, IFCEngine.sdaiADB, val);    
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPutAttrBN, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPutAttrBN but valid for all put-functions)

valueType               C/C++                                                           C#

sdaiINTEGER             int_t val = 123;                                                int_t val = 123;
                        sdaiPutAttrBN (instance, "attrName", sdaiINTEGER, &val);        IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                           double val = 123.456;
                        sdaiPutAttrBN (instance, "attrName", sdaiREAL, &val);           IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                     bool val = true;
                        sdaiPutAttrBN (instance, "attrName", sdaiBOOLEAN, &val);        IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                         string val = "U";
                        sdaiPutAttrBN (instance, "attrName", sdaiLOGICAL, val);         IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                                string val = "NOTDEFINED";
                        sdaiPutAttrBN (instance, "attrName", sdaiENUM, val);            IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                                string val = "0123456ABC";
                        sdaiPutAttrBN (instance, "attrName", sdaiBINARY, val);          IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                           string val = "My Simple String";
                        sdaiPutAttrBN (instance, "attrName", sdaiSTRING, val);          IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                     string val = "Any Unicode String";
                        sdaiPutAttrBN (instance, "attrName", sdaiUNICODE, val);         IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";      string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPutAttrBN (instance, "attrName", sdaiEXPRESSSTRING, val);   IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE");     int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPutAttrBN (instance, "attrName", sdaiINSTANCE, val);        IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                        int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                          IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPutAttrBN (instance, "attrName", sdaiAGGR, val);            IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                       int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);       int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                      IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPutAttrBN (instance, "attrName", sdaiADB, val);             IFCEngine.sdaiPutAttrBN (instance, "attrName", IFCEngine.sdaiADB, val); 
                        ...                                                             ...
                        sdaiDeleteADB (val);    //  optional                            IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .
Technically sdaiPutAttrBN will transform into the following call
    sdaiPutAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            valueType,
            value
        );

This call removes all data from a specific attribute for the given instance.

This call removes all data from a specific attribute for the given instance. Technically it will transform into the following call

    sdaiUnsetAttr(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                )
        );

This call can be used to add a comment to an instance when exporting the content. The comment is available in the exported/saved IFC file.

...

...

Technically it will transform into the following call

    sdaiGetAttrDefinition(
            sdaiGetInstanceType(
                    instance
                ),
            attributeName
        );

This call creates an instance at a specific given express ID, the instance is only created if the express ID was not used yet.

This call creates an instance at a specific given express ID, the instance is only created if the express ID was not used yet.

This function creates an iterator associated with the specified aggregate instance. The iterator is positioned as if the sdaiBeginning function had been executed such that so that no member of the aggregate is referenced as the current member.

This function deletes the specified iterator.

The function positions the iterator at the beginning of its associated aggregate instance such that there is no current member.

This function positions the iterator to the succeeding member of the associated aggregate instance.

This function positions the specified iterator so that the preceding member of its subject ordered aggregate instance shall become the current member. If the iterator is at the end of the aggregate, the last member becomes the current member. If the iterator is at the beginning of the aggregate no repositioning occur. If the iterator references the first member of the aggregate, the iterator is set at the beginning so there is no current member.

This function positions the specified iterator at the end of the ordered aggregate instance members such that there is no current member.

The function determines whether the specified primitive or instance value is contained in the aggregate. In the case of aggregate members represented by ADBs, both the data value and data type are compared. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiIsMember, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiIsMember but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiIsMember (sdaiINTEGER, &val);                           IFCEngine.sdaiIsMember (IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiIsMember (sdaiREAL, &val);                              IFCEngine.sdaiIsMember (IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiIsMember (sdaiBOOLEAN, &val);                           IFCEngine.sdaiIsMember (IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiIsMember (sdaiLOGICAL, val);                            IFCEngine.sdaiIsMember (IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiIsMember (sdaiENUM, val);                               IFCEngine.sdaiIsMember (IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiIsMember (sdaiBINARY, val);                             IFCEngine.sdaiIsMember (IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiIsMember (sdaiSTRING, val);                             IFCEngine.sdaiIsMember (IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiIsMember (sdaiUNICODE, val);                            IFCEngine.sdaiIsMember (IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiIsMember (sdaiEXPRESSSTRING, val);                      IFCEngine.sdaiIsMember (IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = ...                                      int_t val = ...
                        sdaiIsMember (sdaiINSTANCE, val);                           IFCEngine.sdaiIsMember (IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = ...                                          int_t val = ...
                        sdaiIsMember (sdaiAGGR, val);                               IFCEngine.sdaiIsMember (IFCEngine.sdaiAGGR, val);

sdaiADB                 SdaiADB val = ...                                           int_t val = ...
                        sdaiIsMember (sdaiADB, val);                                IFCEngine.sdaiIsMember (IFCEngine.sdaiADB, val);
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

The function returns the current value of the real precision, the string width, or the binary width for the current member referenced by the specified iterator.

The function returns the current value of the real precision, the string width, or the binary width of the aggregate element at the specified index position in the specified ordered aggregate instance.

The function returns the current value of the lower bound, or index, of the specified aggregate instance.

The function returns the current value of the upper bound, or index, of the specified aggregate instance.

The function returns the value of the lower index of the specified array instance when it was created.

The function returns the value of the upper index of the specified array instance when it was created.

The function restores the unset (not assigned a value) status of the member of the specified array at the specified index position.

The function restores the unset (not assigned a value) status of a member at the position identified by the iterator in the array associated with the iterator.

The function resizes the specified array instance setting the lower, or upper index, or both, based upon the current population of the application schema.

The function shall resizes the specified array instance setting the lower and upper index with the specified values.

The function enables calculation of derived attributes for sdaiGetAttr(BN) and other get value functions and dynamic aggregation indexes. Returns success flag.

The function evaluates and replaces all * with values, optionally can handle $ values as derived attributes.

The function checks if instances of the specified entity are complex instances. You can use engiGetEntityParentEx to list components.

This call sets the segmentation for any curved part of an object in case it is defined by a circle, ellipse, nurbs etc. If segmentationParts is set to 0 it will fallback on the default setting (i.e. 36), it makes sense to change the segmentation depending on the entity type that is visualized. in case segmentationLength is non-zero, this is the maximum length (in file length unit definition) of a segment For example a slightly curved wall with large size will get much more precise segmentation as the segmentLength will force the segmentation for the wall to increase.

This returns the set values for segmentationParts and segmentationLength. Both attributes are optional. The values can be changed through the API call setSegmentation(). The default values are segmentationParts = 36 segmentationLength = 0.

...

...

Controling API Calls

...

Please use the setSegmentation call, note it is now a call that is model dependent. The circleSegments(circles, smallCircles) can be replaced with

    double  segmentationLength = 0.;
    getSegmentation(model, nullptr, &segmentationLength);
    setSegmentation(model, circles, segmentationLength);

Please use setSegmentation call The call setMaximumSegmentationLength(model, length) can be replaced with

    int_t segmentationParts = 0;
    getSegmentation(model, &segmentationParts, nullptr);
    setSegmentation(model, segmentationParts, length);

This function will return the conversion factor compared to the base SI unit. The possible unitType values are all enumeration values from enumeration type IfcUnitEnum. For example getProjectUnitConversionFactor(model, "LENGTHUNIT") returns 0.001 in case of MilliMeters. Optional arguments unitPrefix (for example "MILLI"), unitName (if defined) and SIUnitName (for example "METRE") can be requested.

This function will return the conversion factor compared to the base SI unit. The possible unitType values are all enumeration values from enumeration type IfcUnitEnum. For example getProjectUnitConversionFactorW(model, L"LENGTHUNIT") returns 0.001 in case of MilliMeters. Optional arguments unitPrefix (for example L"MILLI"), unitName (if defined) and SIUnitName (for example L"METRE") can be requested.

This function will return the conversion factor compared to the base SI unit. The unitType is derived from the instance. For example getUnitInstanceConversionFactor(myInstance) returns 0.001 in case of MilliMeters if the instance defines a length unit. Optional arguments unitType (for example "LENGTHUNIT"), unitPrefix (for example "MILLI"), unitName (if defined) and SIUnitName (for example "METRE") can be requested.

This function will return the conversion factor compared to the base SI unit. The unitType is derived from the instance. For example getUnitInstanceConversionFactorW(myInstance) returns 0.001 in case of MilliMeters if the instance defines a length unit. Optional arguments unitType (for example L"LENGTHUNIT"), unitPrefix (for example L"MILLI"), unitName (if defined) and SIUnitName (for example L"METRE") can be requested.

This call can be used to optimize Boundary Representation or Mesh geometries. In many cases geometry within an IFC file is not semantically rich similar to an extruded profile or polygon, bounded surfaces or results from boolean operations on top of basic parametric shapes. Depending on how such geometries are stored very often only vertices and triangles or polygons based on these vertices are available. Looking at the shape however, they meant to represent often parametric surfaces. In case normal and surface boundary information is missing in the IFC file this call allows automatic recalculation of such information. consistencyCheck bit0 (1) merge elements in the vertex array are duplicated (epsilon used as distance) bit1 (2) remove elements in the vertex array that are not referenced by elements in the index array (interpreted as SET if flags are defined) bit2 (4) merge polygons placed in the same plane and sharing at least one edge bit3 (8) merge polygons advanced (check of polygons have the opposite direction and are overlapping, but don't share points) bit4 (16) check if faces are wrongly turned opposite from each other bit5 (32) check if faces are inside-out bit6 (64) check if faces result in solid, if not generate both sided faces bit7 (128) invert direction of the face/normal information bit8 (256) export all faces as one conceptual face bit9 (512) remove irrelevant intermediate points on lines bit10 (1024) check and repair faces that are not defined in a perfect plane fraction To compare adjacent faces, they will be defined as being part of the same conceptual face if the fraction value is larger then the dot product of the normal vector's of the individual faces. epsilon This value is used to compare vertex elements, if vertex elements should be merged and the distance is smaller than this epsilon value then it will be defined as equal maxVerticesSize if 0 this setting is applied to all BoundaryRepresentation/Mesh based geometries if larger than 0 it is applied to BoundaryRepresentation/Mesh based geometries with vertices size smaller or equal to the given number

This call forces cleaning of memory allocated. The following mode values are effected: 0 non-cached geometry tree structures 1 cached and non-cached geometry tree structures + resetting buffers for internally used Geometry Kernel instance 3 cached and non-cached geometry tree structures 4 clean memory allocated within a session for ADB structures and string values (including enumerations requested as wide char).

Returns the line STEP/Express ID of an instance

Returns an instance based on the model and STEP/Express ID (even when the instance itself might be non-existant).

Returns an instance based on the model and STEP/Express ID

In case an XML file is loaded the XML ID values are kept in memory and can be retrieved through this API call.

Set mode of interpretation for arguments of type char* 0 - char* (default) 1 - wchar_t* 2 - char16_t* 4 - char32_t*

...

Sets encoding for sdaiSTRING data type in put and get functions if model is NULL it will set codepage for models, created after the call or for contexts when model is not known returns 1 when successful of 0 when fails.

...

...

...

...

Uncategorized API Calls

...

Model input parameter is irrelevant, but is required for backwards compatibility.

Technically xxxxGetEntityAndSubTypesExtentBN will transform into the following call

    xxxxGetEntityAndSubTypesExtent(
            model,
            sdaiGetEntity(
                    model,
                    entityName
                )
        );

This call returns an aggregation containing all instances.

This call returns an aggregation containing all instances referencing the given instance. note: this is independent from if there are inverse relations defining such an aggregation or parts of it.

...

...

This function iterates over all available instances loaded in memory, it is the fastest way to find all instances. Argument entity and entityName are both optional and if non-zero are filled with respectively the entity handle and entity name as char array.

valueType argument to specify what type of data caller wants to get and value argument where the caller should provide a buffer, and the function will write the result to. Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiGetAggrByIterator, and it works similarly for all get-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. The Table 2 shows what valueType can be fulfilled depending on actual model data. On success get-function will return non-zero. More precisely, according to ISO 10303-24-2001 on success they return content of value argument (*value) for sdaiADB, sdaiAGGR, or sdaiINSTANCE or value argument itself for other types (it has no useful meaning for C#). All get-functions return NULL and set value to 0 if model data are incompatible with requested valueType. Furthermore: - for unset ($) data all get-functions return NULL and set value to 0, except when valueType = sdaiEXPRESSSTRING - for derived (*), depending on engiEnableDerivedAttributes, and except valueType = sdaiEXPRESSSTRING: -- either calculate and follow these rues for calculated value -- or handles it as unset ($) - if valueType = sdaiEXPRESSSTRING and data is unset ($) or derived (*), get-function will return NULL but set value to "$" or "*" respectively for any engiEnableDerivedAttributes state 

Table 1 – Required value buffer depending on valueType (on the example of sdaiGetAggrByIterator but valid for all get-functions)

valueType               C/C++                                                           C#

sdaiINTEGER             int_t val;                                                      int_t val;
                        sdaiGetAggrByIterator (iterator, sdaiINTEGER, &val);            IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiINTEGER, out val);

sdaiREAL or sdaiNUMBER  double val;                                                     double val;
                        sdaiGetAggrByIterator (iterator, sdaiREAL, &val);               IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiREAL, out val);

sdaiBOOLEAN             SdaiBoolean val;                                                bool val;
                        sdaiGetAggrByIterator (iterator, sdaiBOOLEAN, &val);            IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiBOOLEAN, out val);

sdaiLOGICAL             const TCHAR* val;                                               string val;
                        sdaiGetAggrByIterator (iterator, sdaiLOGICAL, &val);            IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiLOGICAL, out val);

sdaiENUM                const TCHAR* val;                                               string val;
                        sdaiGetAggrByIterator (iterator, sdaiENUM, &val);               IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiENUM, out val);

sdaiBINARY              const TCHAR* val;                                               string val;
                        sdaiGetAggrByIterator (iterator, sdaiBINARY, &val);             IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiBINARY, out val);

sdaiSTRING              const char* val;                                                string val;
                        sdaiGetAggrByIterator (iterator, sdaiSTRING, &val);             IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiSTRING, out val);

sdaiUNICODE             const wchar_t* val;                                             string val;
                        sdaiGetAggrByIterator (iterator, sdaiUNICODE, &val);            IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiUNICODE, out val);

sdaiEXPRESSSTRING       const char* val;                                                string val;
                        sdaiGetAggrByIterator (iterator, sdaiEXPRESSSTRING, &val);      IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiEXPRESSSTRING, out val);

sdaiINSTANCE            SdaiInstance val;                                               int_t val;
                        sdaiGetAggrByIterator (iterator, sdaiINSTANCE, &val);           IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiINSTANCE, out val);

sdaiAGGR                SdaiAggr aggr;                                                  int_t aggr;
                        sdaiGetAggrByIterator (iterator, sdaiAGGR, &aggr);              IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiAGGR, out aggr);

sdaiADB                 SdaiADB adb = sdaiCreateEmptyADB();                             int_t adb = IFCEngine.sdaiCreateEmptyADB();
                        sdaiGetAggrByIterator (iterator, sdaiADB, adb);                 IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiADB, adb);
                        ...                                                             ...
                        sdaiDeleteADB (adb);    //  optional                            IFCEngine.sdaiDeleteADB (adb);  //  optional

                        SdaiADB adb = nullptr;                                          int_t adb = 0;  //  it is important to initialize
                        sdaiGetAggrByIterator (iterator, sdaiADB, &adb);                IFCEngine.sdaiGetAggrByIterator (iterator, IFCEngine.sdaiADB, out adb);
                        ...                                                             ...
                        sdaiDeleteADB (adb);    //  optional                            IFCEngine.sdaiDeleteADB (adb);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiCreateEmptyADB and sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list
sdaiINTEGER         Yes         Yes *        .           .           .           .           .           .           .
sdaiREAL            Yes         Yes          .           .           .           .           .           .           .
sdaiNUMBER          Yes         Yes          .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .
sdaiSTRING          Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiUNICODE         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiEXPRESSSTRING   Yes         Yes         Yes         Yes         Yes         Yes         Yes          .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes

(Non-standard extensions) sdaiGetADBValue: sdaiADB is allowed and will success when sdaiGetADBTypePath is not NULL, returning ABD value has type path element removed.

valueType argument to specify what type of data caller wants to put Table 1 shows type of buffer the caller should provide depending on the valueType for sdaiPutAggrByIterator, and it works similarly for all put-functions. Note: with SDAI API it is impossible to check buffer type at compilation or execution time and this is responsibility of a caller to ensure that requested valueType is matching with the value argument, a mismatch will lead to unpredictable results. 

Table 1 – Required value buffer depending on valueType (on the example of sdaiPutAggrByIterator but valid for all put-functions)

valueType               C/C++                                                       C#

sdaiINTEGER             int_t val = 123;                                            int_t val = 123;
                        sdaiPutAggrByIterator (iterator, sdaiINTEGER, &val);        IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiINTEGER, ref val);

sdaiREAL or sdaiNUMBER  double val = 123.456;                                       double val = 123.456;
                        sdaiPutAggrByIterator (iterator, sdaiREAL, &val);           IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiREAL, ref val);

sdaiBOOLEAN             SdaiBoolean val = sdaiTRUE;                                 bool val = true;
                        sdaiPutAggrByIterator (iterator, sdaiBOOLEAN, &val);        IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiBOOLEAN, ref val);

sdaiLOGICAL             const TCHAR* val = "U";                                     string val = "U";
                        sdaiPutAggrByIterator (iterator, sdaiLOGICAL, val);         IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiLOGICAL, val);

sdaiENUM                const TCHAR* val = "NOTDEFINED";                            string val = "NOTDEFINED";
                        sdaiPutAggrByIterator (iterator, sdaiENUM, val);            IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiENUM, val);

sdaiBINARY              const TCHAR* val = "0123456ABC";                            string val = "0123456ABC";
                        sdaiPutAggrByIterator (iterator, sdaiBINARY, val);          IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiBINARY, val);

sdaiSTRING              const char* val = "My Simple String";                       string val = "My Simple String";
                        sdaiPutAggrByIterator (iterator, sdaiSTRING, val);          IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiSTRING, val);

sdaiUNICODE             const wchar_t* val = L"Any Unicode String";                 string val = "Any Unicode String";
                        sdaiPutAggrByIterator (iterator, sdaiUNICODE, val);         IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiUNICODE, val);

sdaiEXPRESSSTRING       const char* val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";  string val = "EXPRESS format, i.e. \\X2\\00FC\\X0\\";
                        sdaiPutAggrByIterator (iterator, sdaiEXPRESSSTRING, val);   IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiEXPRESSSTRING, val);

sdaiINSTANCE            SdaiInstance val = sdaiCreateInstanceBN (model, "IFCSITE"); int_t val = IFCEngine.sdaiCreateInstanceBN (model, "IFCSITE");
                        sdaiPutAggrByIterator (iterator, sdaiINSTANCE, val);        IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiINSTANCE, val);

sdaiAGGR                SdaiAggr val = sdaiCreateAggr (inst, 0);                    int_t val = sdaiCreateAggr (inst, 0);
                        sdaiPutAttr (val, sdaiINSTANCE, inst);                      IFCEngine.sdaiPutAttr (val, IFCEngine.sdaiINSTANCE, inst);
                        sdaiPutAggrByIterator (iterator, sdaiAGGR, val);            IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiAGGR, val);

sdaiADB                 int_t integerValue = 123;                                   int_t integerValue = 123;   
                        SdaiADB val = sdaiCreateADB (sdaiINTEGER, &integerValue);   int_t val = IFCEngine.sdaiCreateADB (IFCEngine.sdaiINTEGER, ref integerValue);
                        sdaiPutADBTypePath (val, 1, "IFCINTEGER");                  IFCEngine.sdaiPutADBTypePath (val, 1, "IFCINTEGER");
                        sdaiPutAggrByIterator (iterator, sdaiADB, val);             IFCEngine.sdaiPutAggrByIterator (iterator, IFCEngine.sdaiADB, val); 
                        ...                                                         ...
                        sdaiDeleteADB (val);    //  optional                        IFCEngine.sdaiDeleteADB (val);  //  optional
TCHAR is “char” or “wchar_t” depending on setStringUnicode. (Non-standard behavior) sdaiLOGICAL behaves differently from ISO 10303-24-2001: it expects char* while standard declares int_t. (Non-standard extension) sdiADB has an option to work without sdaiDeleteADB as shown in the table (all open ADB's will be deleted on model close). 
Table 2 - valueType can be requested depending on actual model data.

valueType       Works for following values in the model
                  integer      real     .T. or .F.     .U.      other enum    binary      string     instance      list      $ (empty)
sdaiINTEGER         Yes          .           .           .           .           .           .           .           .           .
sdaiREAL             .          Yes          .           .           .           .           .           .           .           .
sdaiNUMBER           .          Yes          .           .           .           .           .           .           .           .
sdaiBOOLEAN          .           .          Yes          .           .           .           .           .           .           .
sdaiLOGICAL          .           .          Yes         Yes          .           .           .           .           .           .
sdaiENUM             .           .          Yes         Yes         Yes          .           .           .           .           .
sdaiBINARY           .           .           .           .           .          Yes          .           .           .           .
sdaiSTRING           .           .           .           .           .           .          Yes          .           .           .
sdaiUNICODE          .           .           .           .           .           .          Yes          .           .           .
sdaiEXPRESSSTRING    .           .           .           .           .           .          Yes          .           .           .
sdaiINSTANCE         .           .           .           .           .           .           .          Yes          .           .
sdaiAGGR             .           .           .           .           .           .           .           .          Yes          .
sdaiADB             Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes         Yes          .

...

...

...

...

...

Geometry Kernel related API Calls

...

...

...

Returns a handle to the model within the Geometry Kernel. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP model handle also, however most correct would be to get and use the Geometry Kernel handle.

By default a model for the Geometry Modelling Kernel will be created once required on-the-fly. This call allows a user to use an existing model that will be connected. This connected model will not be destroyed at closing of the STEP model, i.e. within sdaiCloseModel().

Returns a handle to the instance representing the head of design tree within the Geometry Kernel. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP instance handle also, however most correct would be to get and use the Geometry Kernel handle.

deprecated, if you use this call, please contact us

Returns a handle to the instance representing the head of design tree within the Geometry Kernel. If no design tree is created yet it will be created on-the-fly. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP instance handle also, however most correct would be to get and use the Geometry Kernel handle.

Returns a handle to the instance representing the head of design tree within the Geometry Kernel. If no design tree is created yet it will be created on-the-fly. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP instance handle also, however most correct would be to get and use the Geometry Kernel handle.

Returns a handle to the instance representing the head of design tree within the Geometry Kernel. If no design tree is created yet it will be created on-the-fly. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP instance handle also, however most correct would be to get and use the Geometry Kernel handle.

Returns a handle to the instance representing the head of design tree within the Geometry Kernel. If no design tree is created yet it will be created on-the-fly. Note: the STEP Engine uses one or more models within the Geometry Kernel to generate design trees within the Geometry Kernel. All Geometry Kernel calls can be called with the STEP instance handle also, however most correct would be to get and use the Geometry Kernel handle.

...

deprecated, if you use this call, please contact us

...

...

...

...

...

...

...

...

The call getGlobalPlacement is meant to be used together with setGlobalPlacement(..) and allows you to get and adjust the placement of a model. This is all done semantically, i.e. it can be seen as a derived call representing a small SDAI function adjust (in case of set) the origin of a model.

The call setGlobalPlacement allows you to adjust the placement of a model. This is all done semantically, i.e. it can be seen as a derived call representing a small SDAI function adjust the origin of a model.

...

...

...

This call allows certain constructs to complete implicitly already available data. Specifically for IFC4.3 and higher calls using the instances of the following entities are supported: IfcAlignment => in case business logic is defined and not geometrically representation is available yet the geometrical representation will be constructed on the fly, i.e. an IfcCompositeCurve with IfcCurveSegment instances for the horizontal alignment an IfcGradientCurve with IfcCurveSegment instances for the vertical alignment an IfcSegmentedReferenceCurve with IfcCurveSegment instances for the cant alignment IfcLinearPlacement => in case CartesianPosition is empty the internally calculated matrix will be represented as an IfcAxis2Placement

...

Deprecated API Calls (GENERIC)

The following calls will still be working but it is advised to change towards the new alternatives.

This call is deprecated, please use engiGetAggrType, the index is irrelevant.

Return attribute definition from attribute index. This call is deprecated, use SdaiAttr or attribute name as primary data and engiGetEntityAttributePosition.

This function iterated over all available attributes of a specific given entity. This call is typically used in combination with iterateOverInstances(..). This call is deprecated, use engiGetEntityAttributeByIterator.

This call is deprecated, use engiGetEntityAttributePosition.

This call is deprecated, use engiGetEntityAttributePosition.

This call is deprecated, use engiGetEntityAttributeByIterator, engiGetAttrName.

This call is deprecated, use engiGetEntityAttributeByIterator, engiGetAttrType.

This call is deprecated, please use call engiIsAttrOptional(..) instead.

This call is deprecated, please use call engiIsAttrOptionalBN(..) instead. Technically engiGetAttrOptionalBN will transform into the following call engiGetAttrOptional( sdaiGetAttrDefinition( entity, attributeName ) );

This call is deprecated, please use call engiIsAttrInverse(..) instead.

This call is deprecated, please use call engiIsAttrInverseBN(..) instead. Technically engiGetAttrInverseBN will transform into the following call engiGetAttrInverse( sdaiGetAttrDefinition( entity, attributeName ) );

This call is deprecated, please use call engiIsAttrInverse(..) instead.

This call is deprecated, please use call engiGetAttrDomainName(..) instead.

This call is deprecated, please use call engiGetAttrDomainNameBN(..) instead. Technically engiGetAttrDomainBN will transform into the following call engiGetAttrDomain( sdaiGetAttrDefinition( entity, attributeName ), domainName );

This call is deprecated, please use call engiIsEntityAbstract(..) instead.

This call is deprecated, please use call engiIsEntityAbstractBN(..) instead. Technically engiGetEntityIsAbstractBN will transform into the following call engiGetEntityIsAbstract( sdaiGetEntity( model, entityName ) );

This call is deprecated, please use call engiGetAttrTraits(..) instead.

This call is deprecated, please use call engiGetEntityNoAttributes(..) instead.

This call is deprecated, please use call engiGetAttrType(..) instead.

This call is deprecated, please use call engiGetAttrType(..) instead.

This call is deprecated, use engiGetEntityAttributePosition instead.

This call is deprecated, please use call sdaiGetAggrByIndex(..) instead.

This call is deprecated, please use call sdaiGetAttrDefinition(..) instead.

This call is deprecated, please use call sdaiGetADBTypePath(..) instead.

This call is deprecated, please use call engiOpenModelByStream(..) instead.

This call is deprecated, please use call engiGetAttrType(..) instead.

This call is deprecated, please use call engiGetAttrType(..) instead.

This call is deprecated, please use calls engiGetAttrTypeBN(..) instead. Technically it will transform into the following call

    xxxxGetAttrType(
            instance,
            sdaiGetAttrDefinition(
                    sdaiGetInstanceType(
                            instance
                        ),
                    attributeName
                ),
            attributeType
        );

This call is deprecated, please use call GetSPFFHeaderItem instead

This call works for non-complex entities and entities without multiple inheritance, it is advised not to use this call for other schemas. This call is deprecated, use call engiGetEntityAttributePosition instead.

This call works for non-complex entities and entities without multiple inheritance, it is advised not to use this call for other schemas. Technically engiGetAttrIndexBN will transform into the following call engiGetAttrIndex( sdaiGetAttrDefinition( entity, attributeName ) ); This call is deprecated, use call engiGetEntityAttributePosition instead.

This call works for non-complex entities and entities without multiple inheritance, it is advised not to use this call for other schemas. This call is deprecated, use call engiGetEntityAttributePosition instead.

This call works for non-complex entities and entities without multiple inheritance, it is advised not to use this call for other schemas. Technically engiGetAttrIndexExBN will transform into the following call engiGetAttrIndexEx( sdaiGetAttrDefinition( entity, attributeName ), countedWithParents, countedWithInverse ); This call is deprecated, use call engiGetEntityAttributePosition instead.

This call can be used to retrieve the name of the n-th argument of the given entity. Arguments of parent entities are included in the index. Both explicit and inverse attributes are included. This call is deprecated, use SdaiAttr or attribute name as primary data and engiGetEntityAttributePosition.

This call can be used to retrieve the type of the n-th argument of the given entity. In case of a select argument no relevant information is given by this call as it depends on the instance. Arguments of parent entities are included in the index. Both explicit and inverse attributes are included. This call is deprecated, use engiGetEntityAttributePosition, engiGetEntityAttributeByIterator, engiGetAttrType.

This call is deprecated, use SdaiAttr or attribute name as primary data and engiGetEntityAttributePosition, engiGetEntityAttributeByIterator, engiGetAttrName.

Validation

...

Allows to set a time limit in seconds, setting to 0 means no time limit. Allows to set a count limit, setting to 0 means no count limit. Allows to hide redundant issues. 

    bit 0:  (__KNOWN_ENTITY)                    entity is defined in the schema
    bit 1:  (__NO_OF_ARGUMENTS)                 number of arguments
    bit 2:  (__ARGUMENT_EXPRESS_TYPE)           argument value is correct entity, defined type or enumeration value
    bit 3:  (__ARGUMENT_PRIM_TYPE)              argument value has correct primitive type
    bit 4:  (__REQUIRED_ARGUMENTS)              non-optional arguments values are provided
    bit 5:  (__ARRGEGATION_EXPECTED)            aggregation is provided when expected
    bit 6:  (__AGGREGATION_NOT_EXPECTED)        aggregation is not used when not expected
    bit 7:  (__AGGREGATION_SIZE)                aggregation size
    bit 8:  (__AGGREGATION_UNIQUE)              elements in aggregations are unique when required
    bit 9:  (__COMPLEX_INSTANCE)                complex instances contains full parent chains
    bit 10: (__REFERENCE_EXISTS)                referenced instance exists
    bit 11: (__ABSTRACT_ENTITY)                 abstract entity should not instantiate
    bit 12: (__WHERE_RULE)                      where-rule check
    bit 13: (__UNIQUE_RULE)                     unique-rule check
    bit 14: (__STAR_USAGE)                      * is used only for derived arguments
    bit 15: (__CALL_ARGUMENT)                   validateModel/validateInstance function argument should be model/instance
    bit 63: (__INTERNAL_ERROR)                  unspecified error

Allows to get the time limit in seconds, value 0 means no time limit, input can be left to NULL if not relevant. Allows to get the count limit, value 0 means no count limit, input can be left to NULL if not relevant. Allows to get hide redundant issues, input can be left to NULL if not relevant. Return value is the issueTypes enabled according to the mask given. 

    bit 0:  (__KNOWN_ENTITY)                    entity is defined in the schema
    bit 1:  (__NO_OF_ARGUMENTS)                 number of arguments
    bit 2:  (__ARGUMENT_EXPRESS_TYPE)           argument value is correct entity, defined type or enumeration value
    bit 3:  (__ARGUMENT_PRIM_TYPE)              argument value has correct primitive type
    bit 4:  (__REQUIRED_ARGUMENTS)              non-optional arguments values are provided
    bit 5:  (__ARRGEGATION_EXPECTED)            aggregation is provided when expected
    bit 6:  (__AGGREGATION_NOT_EXPECTED)        aggregation is not used when not expected
    bit 7:  (__AGGREGATION_SIZE)                aggregation size
    bit 8:  (__AGGREGATION_UNIQUE)              elements in aggregations are unique when required
    bit 9:  (__COMPLEX_INSTANCE)                complex instances contains full parent chains
    bit 10: (__REFERENCE_EXISTS)                referenced instance exists
    bit 11: (__ABSTRACT_ENTITY)                 abstract entity should not instantiate
    bit 12: (__WHERE_RULE)                      where-rule check
    bit 13: (__UNIQUE_RULE)                     unique-rule check
    bit 14: (__STAR_USAGE)                      * is used only for derived arguments
    bit 15: (__CALL_ARGUMENT)                   validateModel/validateInstance function argument should be model/instance
    bit 63: (__INTERNAL_ERROR)                  unspecified error

Apply validation of a model

Apply validation of an instance

Clean validation results

Get first issue from validation results. If no issues inside validation results or validation results is NULL it will return NULL.

Get next issue based on a given issue. If no issues left or validation issue is NULL it will return NULL.

Return value is the issueStatus (enum_validation_status): 

    value 0:    (__NONE)                        no status set
    value 1:    (__COMPLETE_ALL)                all issues proceed
    value 2:    (__COMPLETE_NOT_ALL)            completed but some issues were excluded by option settings
    value 3:    (__TIME_EXCEED)                 validation was finished because of reach time limit
    value 4:    (__COUNT_EXCEED)                validation was finished because of reach of issue's numbers limit

Return value is the issueType (enum_validation_type): 

    bit 0:  (__KNOWN_ENTITY)                    entity is defined in the schema
    bit 1:  (__NO_OF_ARGUMENTS)                 number of arguments
    bit 2:  (__ARGUMENT_EXPRESS_TYPE)           argument value is correct entity, defined type or enumeration value
    bit 3:  (__ARGUMENT_PRIM_TYPE)              argument value has correct primitive type
    bit 4:  (__REQUIRED_ARGUMENTS)              non-optional arguments values are provided
    bit 5:  (__ARRGEGATION_EXPECTED)            aggregation is provided when expected
    bit 6:  (__AGGREGATION_NOT_EXPECTED)        aggregation is not used when not expected
    bit 7:  (__AGGREGATION_SIZE)                aggregation size
    bit 8:  (__AGGREGATION_UNIQUE)              elements in aggregations are unique when required
    bit 9:  (__COMPLEX_INSTANCE)                complex instances contains full parent chains
    bit 10: (__REFERENCE_EXISTS)                referenced instance exists
    bit 11: (__ABSTRACT_ENTITY)                 abstract entity should not instantiate
    bit 12: (__WHERE_RULE)                      where-rule check
    bit 13: (__UNIQUE_RULE)                     unique-rule check
    bit 14: (__STAR_USAGE)                      * is used only for derived arguments
    bit 15: (__CALL_ARGUMENT)                   validateModel/validateInstance function argument should be model/instance
    bit 63: (__INTERNAL_ERROR)                  unspecified error

Returns the (first) instance related to the given issue.

Returns the second instance related to the given issue (if relevant).

Returns the entity handle related to the given issue (if relevant).

Returns the attribute handle related to the given issue (if relevant).

Specifies nesting level of aggregation or 0.

Array of indices for each aggregation size is aggrLevel.

Returns the issue level (i.e. severity of the issue) of the issue given as input.

Returns the description text of the issue given as input.

Deprecated API Calls (GEOMETRY)

...

This call is deprecated, please use call CalculateInstance().

This call is deprecated, please use call UpdateInstanceVertexBuffer() and UpdateInstanceIndexBuffer().

This call is deprecated, there is no direct/easy replacement although the functionality is present. If you still use this call please contact RDF to find a solution together.

This call is deprecated, please use call SetVertexBufferOffset().

This call is deprecated, please use call SetFormat().

This call is deprecated, please use call GetConceptualFaceCnt().

This call is deprecated, please use call GetConceptualFaceEx().

This call is deprecated, please use call owlBuildInstance.

This call is deprecated, please use call owlBuildInstance.

This call is deprecated, please use call CalculateInstance().

This call is deprecated, please contact us if you use this call.