A.1 Selection of personalities

A.1.1 Enumerating all personalities by application

The example below enumerates all personalities with application “IDevID”. This can be useful to select personalities usable for onboarding (cf. 5.2.2, Figure 9).

gta_instance_handle_t h_inst;
gta_context_handle_t h_ctx = GTA_HANDLE_INVALID;
gta_errinfo_t errinfo;

bool b_loop_pers = true;
gta_enum_handle_t h_enum_pers = GTA_HANDLE_ENUM_FIRST;

while (b_loop_pers) {
    char pers_name[STR_LEN_MAX];
    myio_obufstream_t ostream_pers_name = { 0 };

    myio_open_obufstream(&ostream_pers_name, pers_name,
                         sizeof(pers_name), &errinfo);

    if (gta_personality_enumerate_application(h_inst,
            "IDevID", h_enum_pers, GTA_PERSONALITY_ENUM_ALL,
            (gtaio_ostream_t *)&o_pers_name, &errinfo)) {
        
             /* 
              * do something with personality pers_name 
              */            

        }
        else {
            b_loop_pers = false;
        }
        myio_close_obufstream(&ostream_pers_name, &errinfo);
    }
}

A.1.2 Discover DeviceIdentity personality using attribute org.opcfoundation.product_instance_uri

The example below enumerates all personalities and checks for the attribute org.opcfoundation.product_instance_uri

bool b_loop = true;
char identifier_type_buffer[200];
char identifier_value_buffer[200];
myio_obufstream_t ostream_identifier_type = { 0 };
myio_obufstream_t ostream_identifier_value = { 0 };
gta_enum_handle_t h_enum = GTA_HANDLE_ENUM_FIRST;

gta_context_handle_t h_ctx = GTA_HANDLE_INVALID;
bool exit_loops = false;
char selected_personality[100];

/* enumerate all identifiers */
while (b_loop && !exit_loops) {
    myio_open_obufstream(&ostream_identifier_type,
                         identifier_type_buffer,
                         sizeof(identifier_type_buffer),
                         &errinfo);
    myio_open_obufstream(&ostream_identifier_value,
                         identifier_value_buffer,
                         sizeof(identifier_value_buffer),
                         &errinfo);
    b_ret = gta_identifier_enumerate(
                h_inst,
                &h_enum,
                (gtaio_ostream_t *)&ostream_identifier_type,
                (gtaio_ostream_t *)&ostream_identifier_value,
                &errinfo);
    myio_close_obufstream(&ostream_identifier_type, &errinfo);
    myio_close_obufstream(&ostream_identifier_value, &errinfo);

    if (true == b_ret) {
        bool b_inner_loop = true;
        char personality_name_buffer[200];
        myio_obufstream_t ostream_personality_name = { 0 };
        gta_enum_handle_t h_enum_inner_loop = GTA_HANDLE_ENUM_FIRST;

        /* enumerate all personalities belonging to identifier */
        while (b_inner_loop && !exit_loops) {
            myio_open_obufstream(&ostream_personality_name,
                                 personality_name_buffer, 
                                 sizeof(personality_name_buffer),
                                 &errinfo);
            b_ret = gta_personality_enumerate(
                        h_inst,
                        identifier_value_buffer,
                        &h_enum_inner_loop,
                        GTA_PERSONALITY_ENUM_ALL,
                        (gtaio_ostream_t *)&ostream_personality_name,
                        &errinfo);
            myio_close_obufstream(&ostream_personality_name, &errinfo);

            if (true == b_ret) {
                bool b_innermost_loop = true;
                char attribute_type_buffer[200];
                char attribute_value_buffer[200];
                myio_obufstream_t ostream_attribute_type = { 0 };
                myio_obufstream_t ostream_attribute_value = { 0 };
                gta_enum_handle_t h_enum_innermost_loop
                    = GTA_HANDLE_ENUM_FIRST;
 
 
 
                /* enumerate all attributes belonging to personality */
                while (b_innermost_loop && !exit_loops) {
                    myio_open_obufstream(
                        &ostream_attribute_type,
                        attribute_type_buffer,
                        sizeof(attribute_type_buffer),
                        &errinfo);
                    myio_open_obufstream(
                        &ostream_attribute_value,
                        attribute_value_buffer,
                        sizeof(attribute_value_buffer),
                        &errinfo);
                    b_ret = gta_personality_attributes_enumerate(
                         h_inst,
                         personality_name_buffer,
                         &h_enum_innermost_loop,
                         (gtaio_ostream_t *)&ostream_attribute_type,
                         (gtaio_ostream_t *)&ostream_attribute_value,
                         &errinfo);
                    myio_close_obufstream(&ostream_attribute_type,
                                          &errinfo);
                    myio_close_obufstream(&ostream_attribute_value,
                                          &errinfo);
                    if (true == b_ret) {
                        if (0 == strcmp(
                            "org.opcfoundation.product_instance_uri",
                            attribute_type_buffer)) {
                            exit_loops = true;
                            strcpy(selected_personality,
                                   personality_name_buffer);
                        }
                    }
                    else {
                        b_innermost_loop = false;
                    }
                } 
             }
             else {
                 errinfo = 0;
                 b_inner_loop = false;
             }
         }
    }
    else {
        errinfo = 0;
        b_loop = false;
    }
}

/*
 * do something with selected personality
 */