/* We are going to use the BuiltinPublicationListener_on_data_available
* to detect the topics that are being published on the domain
*
* Once we have detected a new topic, we will print out the Topic Name,
* Participant ID, DataWriter id, and Data Type.
*/
void BuiltinPublicationListener_on_data_available(
void* listener_data,
DDS_DataReader* reader)
{
DDS_PublicationBuiltinTopicDataDataReader *builtin_reader = NULL;
struct DDS_PublicationBuiltinTopicDataSeq data_seq = DDS_SEQUENCE_INITIALIZER;
struct DDS_PublicationBuiltinTopicData *data = NULL;
struct DDS_SampleInfoSeq info_seq = DDS_SEQUENCE_INITIALIZER;
DDS_ReturnCode_t retcode;
DDS_ExceptionCode_t exception_code;
int i, len;
builtin_reader = DDS_PublicationBuiltinTopicDataDataReader_narrow(reader);
retcode = DDS_PublicationBuiltinTopicDataDataReader_take(
builtin_reader,
&data_seq, &info_seq, DDS_LENGTH_UNLIMITED,
DDS_ANY_SAMPLE_STATE, DDS_NEW_VIEW_STATE,
DDS_ANY_INSTANCE_STATE);
if (retcode == DDS_RETCODE_NO_DATA)
return;
if (retcode != DDS_RETCODE_OK) {
printf("***Error: failed to access data from the built-in reader\n");
return;
}
len = DDS_PublicationBuiltinTopicDataSeq_get_length(&data_seq);
for (i = 0; i < len; ++i) {
if (DDS_SampleInfoSeq_get_reference(&info_seq, i)->valid_data) {
data = DDS_PublicationBuiltinTopicDataSeq_get_reference(&data_seq, i);
printf("-----\nFound topic \"%s\"\nparticipant: %08x%08x%08x\ndatawriter: %08x%08x%08x\ntype:\n",
data->topic_name,
data->participant_key.value[0],
data->participant_key.value[1],
data->participant_key.value[2],
data->key.value[0],
data->key.value[1],
data->key.value[2]);
if (data->type_code == NULL) {
printf("No type code received, perhaps increase type_code_max_serialized_length?\n");
continue;
}
/* Using the type_code propagated we print the data type
* with print_IDL(). */
DDS_TypeCode_print_IDL(data->type_code, 2, &exception_code);
if (exception_code != DDS_NO_EXCEPTION_CODE) {
printf("Error***: print_IDL returns exception code %d",
exception_code);
}
}
}
DDS_PublicationBuiltinTopicDataDataReader_return_loan(
builtin_reader, &data_seq, &info_seq);
}
int main() {
struct DDS_TypeCode *inner_tc = NULL;
struct DDS_TypeCode *outer_tc = NULL;
struct DDS_TypeCodeFactory *factory = NULL;
DDS_ExceptionCode_t err;
DDS_ReturnCode_t retcode;
int ret = -1;
DDS_DynamicData *outer_data = NULL;
DDS_DynamicData *inner_data = NULL;
DDS_DynamicData *bounded_data = NULL;
/* Getting a reference to the type code factory */
factory = DDS_TypeCodeFactory_get_instance();
if (factory == NULL) {
fprintf(stderr, "! Unable to get type code factory singleton\n");
goto fail;
}
/* Creating the typeCode of the inner_struct */
inner_tc = inner_struct_get_typecode(factory);
if (inner_tc == NULL) {
fprintf(stderr, "! Unable to create typeCode\n");
goto fail;
}
/* Creating the typeCode of the outer_struct that contains an inner_struct */
outer_tc = outer_struct_get_typecode(factory);
if (inner_tc == NULL) {
fprintf(stderr, "! Unable to create typeCode\n");
goto fail;
}
printf(" Connext Dynamic Data Nested Struct Example \n"
"--------------------------------------------\n");
printf(" Data Types\n"
"------------------\n");
DDS_TypeCode_print_IDL(inner_tc, 0, &err);
DDS_TypeCode_print_IDL(outer_tc, 0, &err);
/* Now, we create a dynamicData instance for each type */
outer_data = DDS_DynamicData_new(outer_tc,
&DDS_DYNAMIC_DATA_PROPERTY_DEFAULT);
if (outer_data == NULL) {
fprintf(stderr, "! Unable to create outer dynamicData\n");
goto fail;
}
inner_data = DDS_DynamicData_new(inner_tc,
&DDS_DYNAMIC_DATA_PROPERTY_DEFAULT);
if (outer_data == NULL) {
fprintf(stderr, "! Unable to create inner dynamicData\n");
goto fail;
}
/* Setting the inner data */
retcode = DDS_DynamicData_set_double(inner_data, "x",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 3.14159);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value 'x' in the inner struct \n");
goto fail;
}
retcode = DDS_DynamicData_set_double(inner_data, "y",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 2.71828);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value 'y' in the inner struct\n");
goto fail;
}
printf("\n\n get/set_complex_member API\n"
"----------------------------\n");
/* Using set_complex_member, we copy inner_data values in inner_struct of
* outer_data */
printf("Setting initial values of outer_data with "
"set_complex_member()\n");
retcode = DDS_DynamicData_set_complex_member(outer_data, "inner",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, inner_data);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set complex struct value "
"(member inner in the outer struct)\n");
goto fail;
}
DDS_DynamicData_print(outer_data, stdout, 1);
retcode = DDS_DynamicData_clear_all_members(inner_data);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to clear all member in the inner data\n");
goto fail;
}
printf("\n + get_complex_member() called\n");
retcode = DDS_DynamicData_get_complex_member(outer_data, inner_data,
"inner", DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to get complex struct value "
"(member inner in the outer struct)\n");
goto fail;
}
printf("\n + inner_data value\n");
DDS_DynamicData_print(inner_data, stdout, 1);
/* get_complex_member made a copy of the inner_struct. If we modify
* inner_data values, outer_data inner_struct WILL NOT be modified. */
printf("\n + setting new values to inner_data\n");
retcode = DDS_DynamicData_set_double(inner_data, "x",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 1.00000);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value 'x' in the inner struct \n");
goto fail;
}
retcode = DDS_DynamicData_set_double(inner_data, "y",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 0.00001);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value 'y' in the inner struct \n");
goto fail;
}
DDS_DynamicData_print(inner_data, stdout, 1);
/* Current value of outer_data
* outer_data:
* inner:
* x: 3.141590
* y: 2.718280
*
* inner_data:
* x: 1.000000
* y: 0.000010
*/
printf("\n + current outer_data value \n");
DDS_DynamicData_print(outer_data, stdout, 1);
/* Bind/Unbind member API */
printf("\n\n bind/unbind API\n"
"------------------\n");
printf("Creating a new dynamic data called bounded_data\n");
bounded_data = DDS_DynamicData_new(NULL,
&DDS_DYNAMIC_DATA_PROPERTY_DEFAULT);
if (bounded_data == NULL) {
fprintf(stderr, "! Unable to create new dynamic data\n");
goto fail;
}
printf("\n + binding bounded_data to outer_data's inner_struct\n");
/* Using bind_complex_member, we do not copy inner_struct, but bind it.
* So, if we modify bounded_data, the inner member inside outer_data WILL
* also be modified */
retcode = DDS_DynamicData_bind_complex_member(outer_data, bounded_data,
"inner", DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to bind the structs\n");
goto fail;
}
DDS_DynamicData_print(bounded_data, stdout, 1);
printf("\n + setting new values to bounded_data\n");
retcode = DDS_DynamicData_set_double(bounded_data, "x",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 1.00000);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value to 'x' with the bounded data\n");
goto fail;
}
retcode = DDS_DynamicData_set_double(bounded_data, "y",
DDS_DYNAMIC_DATA_MEMBER_ID_UNSPECIFIED, 0.00001);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to set value to 'x' with the bounded data\n");
goto fail;
}
/* Current value of outer data
* outer:
* inner:
* x: 1.000000
* y: 0.000010
*/
DDS_DynamicData_print(bounded_data, stdout, 1);
retcode = DDS_DynamicData_unbind_complex_member(outer_data, bounded_data);
if (retcode != DDS_RETCODE_OK) {
fprintf(stderr, "! Unable to unbind the data\n");
goto fail;
}
printf("\n + current outer_data value \n");
DDS_DynamicData_print(outer_data, stdout, 1);
ret = 1;
fail:
if (inner_tc != NULL) {
DDS_TypeCodeFactory_delete_tc(factory, inner_tc, NULL);
}
if (outer_tc != NULL) {
DDS_TypeCodeFactory_delete_tc(factory, outer_tc, NULL);
}
if (inner_data != NULL) {
DDS_DynamicData_delete(inner_data);
}
if (outer_data != NULL) {
DDS_DynamicData_delete(outer_data);
}
if (bounded_data != NULL) {
DDS_DynamicData_delete(bounded_data);
}
return ret;
}