int OSPL_MAIN (int argc, const char *argv[]) { DDS_Publisher message_Publisher; DDS_DataWriter message_DataWriter; ListenerData_Msg* message_Sample; const DDS_char listener [] = "Hello World"; os_time delay_2s = { 2, 0 }; DDS_unsigned_long listenerLength = sizeof(listener) - 1; printf("\n Starting ListenerPublisher..."); // Create DDS DomainParticipant printf("\n create Participant..."); createParticipant("Listener example"); // Register the Topic's type in the DDS Domain. g_MessageTypeSupport = ListenerData_MsgTypeSupport__alloc(); checkHandle(g_MessageTypeSupport, "ListenerData_MsgTypeSupport__alloc"); registerMessageType(g_MessageTypeSupport); // Create the Topic's in the DDS Domain. g_MessageTypeName = ListenerData_MsgTypeSupport_get_type_name(g_MessageTypeSupport); g_MessageTopic = createTopic("ListenerData_Msg", g_MessageTypeName); DDS_free(g_MessageTypeName); DDS_free(g_MessageTypeSupport); // Create the Publisher's in the DDS Domain. message_Publisher = createPublisher(); // Request a Writer from the the Publisher. message_DataWriter = createDataWriter(message_Publisher, g_MessageTopic); message_Sample = ListenerData_Msg__alloc(); message_Sample->userID = 1; message_Sample->message = DDS_string_alloc(listenerLength); strncpy(message_Sample->message, listener, listenerLength); printf("\n=== [ListenerPublisher] writing a message containing :"); printf("\n userID : %d", message_Sample->userID); printf("\n Message : \"%s\"", message_Sample->message); g_status = ListenerData_MsgDataWriter_write(message_DataWriter, message_Sample, DDS_HANDLE_NIL); checkStatus(g_status, "ListenerData_MsgDataWriter_write"); os_nanoSleep(delay_2s); // Cleanup DDS deleteDataWriter(message_Publisher, message_DataWriter); deletePublisher(message_Publisher); deleteTopic(g_MessageTopic); deleteParticipant(); // Cleanup C allocations DDS_free(message_Sample); printf("\n=== [ListenerPublisher] Exiting.\n\n"); return 0; }
main(int argc, const char *argv[]) { os_time os_delay_500ms = { 0, 500000000 }; os_time os_delay_200ms = { 0, 200000000 }; os_time os_delay_2ms = { 0, 2000000 }; int x, i; DDS_boolean autodispose_unregistered_instances = FALSE; DDS_Publisher writerStatePublisher; DDS_DataWriter writerStateWriter; DDS_Publisher msgPublisher; DDS_DataWriter msgWriter; DDS_DataWriter msgWriter_stopper; int messageLength; LifecycleData_Msg *sample_Msg; // Force the output to be unbuffered. setbuf(stdout, (char *) 0); printf("\n\n Starting LifecyclePublisher..."); if( argc < 3 ) { usage(); } if ((strcmp(argv[1], "false") != 0) && (strcmp(argv[1], "true") != 0) && (strcmp(argv[2], "dispose") != 0) && (strcmp(argv[2], "unregister") != 0) && (strcmp(argv[2], "stoppub") != 0)) { usage(); } autodispose_unregistered_instances = (strcmp(argv[1], "true") == 0); // First initialize the Topics and their DDS Entities // Create DDS DomainParticipant createParticipant("Lifecycle example"); //------------------ Msg topic --------------------// // Register Msg Topic's type in the DDS Domain. g_msgTypeSupport = LifecycleData_MsgTypeSupport__alloc(); checkHandle(g_msgTypeSupport, "LifecycleData_MsgTypeSupport__alloc"); registerMsgType(g_msgTypeSupport); // Create Msg Topic in the DDS Domain. g_msgTypeName = (char*) LifecycleData_MsgTypeSupport_get_type_name(g_msgTypeSupport); g_msgTopic = createTopic("Lifecycle_Msg", g_msgTypeName); DDS_free(g_msgTypeName); DDS_free(g_msgTypeSupport); // Create the Publisher's in the DDS Domain. msgPublisher = createPublisher(); // Request a Writer from the the Publisher. msgWriter = createDataWriter(msgPublisher, g_msgTopic, autodispose_unregistered_instances); msgWriter_stopper = createDataWriter(msgPublisher, g_msgTopic, autodispose_unregistered_instances); //End initialization. os_nanoSleep(os_delay_200ms); // Start publishing... printf("\n=== [Publisher] Ready..."); if (strcmp(argv[2], "dispose") == 0) { // Publish a Msg Sample and dispose the instance LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc(); sample_Msg->userID = 1; messageLength = strlen("Lifecycle_1"); sample_Msg->message = DDS_string_alloc(messageLength); snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_1"); messageLength = strlen("SAMPLE_SENT -> INSTANCE_DISPOSED -> DATAWRITER_DELETED"); sample_Msg->writerStates = DDS_string_alloc(messageLength); snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> INSTANCE_DISPOSED -> DATAWRITER_DELETED"); printf("\n=== [Publisher] :"); printf("\n userID : %d", sample_Msg->userID); printf("\n Message : %s", sample_Msg->message); printf("\n writerStates : %s", sample_Msg->writerStates); g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0); checkStatus(g_status, "MsgDataWriter_write"); os_nanoSleep(os_delay_500ms); printf("\n=== [Publisher] : SAMPLE_SENT"); // Dispose instance g_status = LifecycleData_MsgDataWriter_dispose(msgWriter, sample_Msg, 0); checkStatus(g_status, "LifecycleData_MsgDataWriter_dispose"); printf("\n=== [Publisher] : INSTANCE_DISPOSED"); // OpenSplice will recursively free the content of the sample, // provided it has all been allocated through the DDS_xxxx_alloc API... DDS_free(sample_Msg); } else if (strcmp(argv[2], "unregister") == 0) { // Publish a Msg Sample and unregister the instance LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc(); sample_Msg->userID = 1; messageLength = strlen("Lifecycle_2"); sample_Msg->message = DDS_string_alloc(messageLength); snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_2"); messageLength = strlen("SAMPLE_SENT -> INSTANCE_UNREGISTERED -> DATAWRITER_DELETED"); sample_Msg->writerStates = DDS_string_alloc(messageLength); snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> INSTANCE_UNREGISTERED -> DATAWRITER_DELETED"); printf("\n=== [Publisher] :"); printf("\n userID : %d", sample_Msg->userID); printf("\n Message : %s", sample_Msg->message); printf("\n writerStates : %s", sample_Msg->writerStates); g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0); checkStatus(g_status, "MsgDataWriter_write"); os_nanoSleep(os_delay_500ms); printf("\n=== [Publisher] : SAMPLE_SENT"); // Unregister instance : the auto_dispose_unregistered_instances flag // is currently ignored and the instance is never disposed automatically g_status = LifecycleData_MsgDataWriter_unregister_instance(msgWriter, sample_Msg, 0); checkStatus(g_status, "LifecycleData_MsgDataWriter_unregister_instance"); printf("\n=== [Publisher] : INSTANCE_UNREGISTERED"); // OpenSplice will recursively free the content of the sample, // provided it has all been allocated through the DDS_xxxx_alloc API... DDS_free(sample_Msg); } else if (strcmp(argv[2], "stoppub") == 0) { // Publish a Msg Sample LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc(); sample_Msg->userID = 1; messageLength = strlen("Lifecycle_3"); sample_Msg->message = DDS_string_alloc(messageLength); snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_3"); messageLength = strlen("SAMPLE_SENT -> DATAWRITER_DELETED"); sample_Msg->writerStates = DDS_string_alloc(messageLength); snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> DATAWRITER_DELETED"); printf("\n=== [Publisher] :"); printf("\n userID : %d", sample_Msg->userID); printf("\n Message : %s", sample_Msg->message); printf("\n writerStates : %s", sample_Msg->writerStates); g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0); checkStatus(g_status, "MsgDataWriter_write"); os_nanoSleep(os_delay_500ms); printf("\n=== [Publisher] : SAMPLE_SENT"); // OpenSplice will recursively free the content of the sample, // provided it has all been allocated through the DDS_xxxx_alloc API... DDS_free(sample_Msg); } // let the subscriber treat the previous writer state !!!! printf("\n=== [Publisher] waiting 500ms to let the subscriber treat the previous write state ..."); os_nanoSleep(os_delay_500ms); /* Remove the DataWriters */ deleteDataWriter(msgPublisher, &msgWriter); printf("\n=== [Publisher] : DATAWRITER_DELETED"); os_nanoSleep(os_delay_500ms); printf("\n=== [Publisher] : Sending a message to stop the subscriber"); /* send a Msg sample to stop the subscriber */ sample_Msg = LifecycleData_Msg__alloc(); sample_Msg->userID = 1; messageLength = strlen("Lifecycle_4"); sample_Msg->message = DDS_string_alloc(messageLength); snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_4"); messageLength = strlen("STOPPING_SUBSCRIBER"); sample_Msg->writerStates = DDS_string_alloc(messageLength); snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "STOPPING_SUBSCRIBER"); printf("\n=== [Publisher] :"); printf("\n userID : %d", sample_Msg->userID); printf("\n Message : %s", sample_Msg->message); printf("\n writerStates : %s\n", sample_Msg->writerStates); g_status = LifecycleData_MsgDataWriter_write(msgWriter_stopper, sample_Msg, 0); checkStatus(g_status, "MsgDataWriter_write"); os_nanoSleep(os_delay_500ms); // OpenSplice will recursively free the content of the sample, // provided it has all been allocated through the DDS_xxxx_alloc API... DDS_free(sample_Msg); /* Remove the DataWriter */ deleteDataWriter(msgPublisher, &msgWriter_stopper); // Cleanup DDS from the created Entities. deletePublisher(&msgPublisher); deleteTopic(g_msgTopic); deleteParticipant(); return 0; }
int main(int argc, char *argv[]) { char* publisher_name; int i, sampleIndex, nb_iteration; c_bool isStoppingSubscriber; float price; char* geTicker = "GE"; int geTickerLength = strlen(geTicker); char* msftTicker = "MSFT"; int msftTickerLength = strlen(msftTicker); os_time os_delay100 = { 0, 100000000 }; os_time os_delay2000 = { 2, 0 }; DDS_Publisher QueryConditionDataPublisher; DDS_DataWriter QueryConditionDataDataWriter; QueryConditionData_Stock* geStockSample; QueryConditionData_Stock* msftStockSample; DDS_InstanceHandle_t geInstanceHandle; DDS_InstanceHandle_t msftInstancetHandle; createParticipant("QueryCondition example"); // Register Stock Topic's type in the DDS Domain. g_StockTypeSupport = (DDS_TypeSupport) QueryConditionData_StockTypeSupport__alloc(); checkHandle(g_StockTypeSupport, "QueryConditionData_StockTypeSupport__alloc"); registerStockType(g_StockTypeSupport); // Create Stock Topic in the DDS Domain. g_StockTypeName = (char*) QueryConditionData_StockTypeSupport_get_type_name(g_StockTypeSupport); g_StockTopic = createTopic("StockTrackerExclusive", g_StockTypeName); DDS_free(g_StockTypeName); DDS_free(g_StockTypeSupport); // Create the Publisher's in the DDS Domain. QueryConditionDataPublisher = createPublisher(); // Request a Writer from the the Publisher. QueryConditionDataDataWriter = createDataWriter(QueryConditionDataPublisher, g_StockTopic, FALSE); // Publish a Stock Sample reflecting the state of the Msg DataWriter. geStockSample = QueryConditionData_Stock__alloc(); msftStockSample = QueryConditionData_Stock__alloc(); msftStockSample->ticker = DDS_string_alloc(msftTickerLength); snprintf(msftStockSample->ticker, msftTickerLength + 1, "%s", msftTicker); msftStockSample->price = 12.00f; geStockSample->ticker = DDS_string_alloc(geTickerLength); snprintf(geStockSample->ticker, geTickerLength + 1, "%s", geTicker); geStockSample->price = 25.00f; geInstanceHandle = QueryConditionData_StockDataWriter_register_instance(QueryConditionDataDataWriter, geStockSample); msftInstancetHandle = QueryConditionData_StockDataWriter_register_instance(QueryConditionDataDataWriter, msftStockSample); nb_iteration = 20; // The subscriber should display the prices sent by the publisher with the highest ownership strength for( sampleIndex = 0; sampleIndex < nb_iteration ; ++sampleIndex ) { printf("GE : %.1f MSFT : %.1f\n", geStockSample->price, msftStockSample->price); writeStockSample(QueryConditionDataDataWriter, geInstanceHandle, geStockSample); writeStockSample(QueryConditionDataDataWriter, msftInstancetHandle, msftStockSample); geStockSample->price += 0.5; msftStockSample->price += 1.5; os_nanoSleep(os_delay100); } // This special price gives the end signal to the Subscriber: // signal to terminate geStockSample->price = -1.0f; msftStockSample->price = -1.0f; writeStockSample(QueryConditionDataDataWriter, geInstanceHandle, geStockSample); writeStockSample(QueryConditionDataDataWriter, msftInstancetHandle, msftStockSample); // This to make sure the Subscriber will get all the Samples. os_nanoSleep(os_delay2000); printf("Market Closed"); QueryConditionData_StockDataWriter_unregister_instance (QueryConditionDataDataWriter, geStockSample, geInstanceHandle); QueryConditionData_StockDataWriter_unregister_instance (QueryConditionDataDataWriter, msftStockSample, msftInstancetHandle); // Cleanup DDS from the created Entities. deleteDataWriter(QueryConditionDataPublisher, QueryConditionDataDataWriter); deletePublisher(QueryConditionDataPublisher); deleteTopic(g_StockTopic); deleteParticipant(); // Cleanup C allocations, // recursively freeing the allocated structures and sequences using the OpenSplice API. DDS_free(geStockSample); DDS_free(msftStockSample); // Print out an empty line, just to let behind a clean new line for the shell.. printf("\n\r"); return 0; }
main(int argc, const char *argv[]) { int x, i; DDS_InstanceHandle_t userHandle; DDS_Publisher message_Publisher; DDS_DataWriter message_DataWriter; ListenerData_Msg* message_Sample; DDS_char* listener = "Hello World"; int listenerLength; printf("\n Starting ListenerPublisher..."); // Create DDS DomainParticipant printf("\n create Participant..."); createParticipant("Listener example"); // Register the Topic's type in the DDS Domain. g_MessageTypeSupport = ListenerData_MsgTypeSupport__alloc(); checkHandle(g_MessageTypeSupport, "ListenerData_MsgTypeSupport__alloc"); registerMessageType(g_MessageTypeSupport); // Create the Topic's in the DDS Domain. g_MessageTypeName = (char*) ListenerData_MsgTypeSupport_get_type_name(g_MessageTypeSupport); g_MessageTopic = createTopic("ListenerData_Msg", g_MessageTypeName); DDS_free(g_MessageTypeName); DDS_free(g_MessageTypeSupport); // Create the Publisher's in the DDS Domain. message_Publisher = createPublisher(); // Request a Writer from the the Publisher. message_DataWriter = createDataWriter(message_Publisher, g_MessageTopic); message_Sample = ListenerData_Msg__alloc(); userHandle = ListenerData_MsgDataWriter_register_instance(message_DataWriter, message_Sample); message_Sample->userID = 1; listenerLength = strlen(listener); message_Sample->message = DDS_string_alloc(listenerLength); strcpy(message_Sample->message, listener); printf("\n=== [ListenerPublisher] writing a message containing :"); printf("\n userID : %d", message_Sample->userID); printf("\n Message : \"%s\"", message_Sample->message); g_status = ListenerData_MsgDataWriter_write(message_DataWriter, message_Sample, 0); checkStatus(g_status, "ListenerData_MsgDataWriter_write"); ListenerData_MsgDataWriter_unregister_instance (message_DataWriter, message_Sample, userHandle); // Cleanup DDS deleteDataWriter(message_Publisher, message_DataWriter); deletePublisher(message_Publisher); deleteTopic(g_MessageTopic); deleteParticipant(); // Cleanup C allocations // Recursively free the instances sequence using the OpenSplice API. DDS_free(message_Sample); printf("\n=== [ListenerPublisher] Exiting.\n\n"); return 0; }
main(int argc, const char *argv[]) { int x, i; DDS_InstanceHandle_t userHandles[10]; DDS_sequence_DurabilityData_Msg* instances = DDS_sequence_DurabilityData_Msg__alloc(); DDS_boolean isTransient; DDS_boolean isPersistent; DDS_boolean isAutodisposeTrue; DDS_boolean isAutodisposeFalse; DDS_boolean isAutomated; os_time delay_10s = { 10, 0 }; if( argc < 4 ) { usage(); } isTransient = (strcmp(argv[1], "transient") == 0) ? TRUE : FALSE; isPersistent = (strcmp(argv[1], "persistent") == 0) ? TRUE : FALSE; isAutodisposeTrue = (strcmp(argv[2], "true") == 0) ? TRUE : FALSE; isAutodisposeFalse = (strcmp(argv[2], "false") == 0) ? TRUE : FALSE; if( !((isTransient || isPersistent) && (isAutodisposeTrue || isAutodisposeFalse)) ) { usage(); } isAutomated = (strcmp(argv[3], "true") == 0) ? TRUE : FALSE; g_durability_kind = (char*) argv[1]; g_autodispose_unregistered_instances = isAutodisposeTrue ? (DDS_boolean) TRUE : (DDS_boolean) FALSE; // Create DDS DomainParticipant createParticipant("Durability example"); // Register the Topic's type in the DDS Domain. g_MsgTypeSupport = DurabilityData_MsgTypeSupport__alloc(); checkHandle(g_MsgTypeSupport, "DurabilityData_MsgTypeSupport__alloc"); registerType(g_MsgTypeSupport); // Create the Topic's in the DDS Domain. g_MsgTypeName = (char*) DurabilityData_MsgTypeSupport_get_type_name(g_MsgTypeSupport); createTopic("DurabilityData_Msg", g_MsgTypeName); DDS_free(g_MsgTypeName); DDS_free(g_MsgTypeSupport); // Create the Publisher's in the DDS Domain. createPublisher(); // Request a Writer from the the Publisher. createWriter(); instances->_buffer = DDS_sequence_DurabilityData_Msg_allocbuf(10); for( x = 0; x < 10 ; x++ ) { instances->_buffer[x].id = x; instances->_buffer[x].content = DDS_string_alloc(1); snprintf(instances->_buffer[x].content, 2, "%d", x); userHandles[x] = DurabilityData_MsgDataWriter_register_instance(g_DataWriter, &instances->_buffer[x]); printf("\n%s", instances->_buffer[x].content); g_status = DurabilityData_MsgDataWriter_write(g_DataWriter, &instances->_buffer[x], userHandles[x]); checkStatus(g_status, "DurabilityData_MsgDataWriter_write"); } if( isAutomated == FALSE ) { int c = 0; printf("\n Type 'E' + Enter to exit:\n"); do { c = getchar(); printf("\n You Typed %c", c); } while( c != (int) 'E' ); printf("\n Exiting.\n\n"); } else { printf( "\n === sleeping 10s..." );; os_nanoSleep(delay_10s); } // Cleanup DDS from the created Entities. deleteDataWriter(); deletePublisher(); deleteTopic(); deleteParticipant(); // Cleanup C allocations, recursively freeing the allocated structures and sequences using the OpenSplice API. DDS_free(instances); // Print out an empty line, just to let behind a clean new line for the shell.. printf("\n"); return 0; }
int OSPL_MAIN (int argc, char *argv[]) { char* publisher_name; int i, sampleIndex, ownership_strength, nb_iteration; c_bool isStoppingSubscriber; float price; os_time os_delay200 = { 0, 200000000 }; os_time os_delay2000 = { 2, 0 }; DDS_Publisher OwnershipDataPublisher; DDS_DataWriter OwnershipDataDataWriter; OwnershipData_Stock* OwnershipDataSample; DDS_InstanceHandle_t userHandle; const char ticker [] = "MSFT"; DDS_unsigned_long stringLength = sizeof(ticker) - 1; // usage : Publisher.exe <publisher_name> <ownership_strength> <nb_iterations> if( argc < 5 ) { usage(); } printf("\n\n Starting OwnershipDataPublisher..."); printf("\n\n Parameters are:"); for( i = 1; i < argc ; ++i ) { printf("\n %d: %s", i, argv[i]); } publisher_name = argv[1]; ownership_strength = atoi(argv[2]); nb_iteration = atoi(argv[3]); isStoppingSubscriber = argv[4][0] == '1' ? TRUE : FALSE; createParticipant("Ownership example"); // Register Stock Topic's type in the DDS Domain. g_StockTypeSupport = (DDS_TypeSupport) OwnershipData_StockTypeSupport__alloc(); checkHandle(g_StockTypeSupport, "OwnershipData_StockTypeSupport__alloc"); registerStockType(g_StockTypeSupport); // Create Stock Topic in the DDS Domain. g_StockTypeName = OwnershipData_StockTypeSupport_get_type_name(g_StockTypeSupport); g_StockTopic = createTopic("StockTrackerExclusive", g_StockTypeName); DDS_free(g_StockTypeName); DDS_free(g_StockTypeSupport); // Create the Publisher's in the DDS Domain. OwnershipDataPublisher = createPublisher(); // Request a Writer from the the Publisher. OwnershipDataDataWriter = createDataWriter(OwnershipDataPublisher, g_StockTopic, FALSE, ownership_strength); // Publish a Stock Sample reflecting the state of the Msg DataWriter. OwnershipDataSample = OwnershipData_Stock__alloc(); OwnershipDataSample->ticker = DDS_string_alloc(stringLength); snprintf(OwnershipDataSample->ticker, stringLength + 1, "%s", ticker); OwnershipDataSample->price = 0.0; OwnershipDataSample->publisher = DDS_string_dup(publisher_name); OwnershipDataSample->strength = ownership_strength; userHandle = OwnershipData_StockDataWriter_register_instance(OwnershipDataDataWriter, OwnershipDataSample); //Publisher publishes the prices in dollars printf("\n=== [Publisher] Publisher %d with strength : ", ownership_strength); printf("\n / sending %d prices...", nb_iteration); // The subscriber should display the prices sent by the publisher with the highest ownership strength price = 10.0f; for( sampleIndex = 0; sampleIndex < nb_iteration ; ++sampleIndex ) { OwnershipDataSample->price = price; writeStockSample(OwnershipDataDataWriter, userHandle, OwnershipDataSample); os_nanoSleep(os_delay200); price = price + 0.5f; } if( isStoppingSubscriber == TRUE ) { // This special price gives the end signal to the Subscriber: OwnershipDataSample->price = (DDS_float) -1.0f; writeStockSample(OwnershipDataDataWriter, userHandle, OwnershipDataSample); } // This to make sure the Subscriber will get all the Samples. os_nanoSleep(os_delay2000); OwnershipData_StockDataWriter_unregister_instance (OwnershipDataDataWriter, OwnershipDataSample, userHandle); // Cleanup DDS from the created Entities. deleteDataWriter(OwnershipDataPublisher, OwnershipDataDataWriter); deletePublisher(OwnershipDataPublisher); deleteTopic(g_StockTopic); deleteParticipant(); // Cleanup C allocations, // recursively freeing the allocated structures and sequences using the OpenSplice API. DDS_free(OwnershipDataSample); // Print out an empty line, just to let behind a clean new line for the shell.. printf("\n\r"); return 0; }
int OSPL_MAIN (int argc, const char *argv[]) { DDS_Publisher message_Publisher; DDS_DataWriter message_DataWriter; WaitSetData_Msg* message_Sample; const DDS_char firstHello[] = "First Hello"; DDS_unsigned_long firstHelloLength = sizeof(firstHello) - 1; const DDS_char helloAgain[] = "Hello again"; DDS_unsigned_long helloAgainLength = sizeof(helloAgain) - 1; os_time os_delay300ms = { 0, 300000000 }; printf("\n Starting WaitSetDataPublisher..."); // Create DDS DomainParticipant printf("\n create Participant..."); createParticipant("WaitSet example"); // Register the Topic's type in the DDS Domain. g_MessageTypeSupport = WaitSetData_MsgTypeSupport__alloc(); checkHandle(g_MessageTypeSupport, "WaitSetData_MsgTypeSupport__alloc"); registerMessageType(g_MessageTypeSupport); // Create the Topic's in the DDS Domain. g_MessageTypeName = WaitSetData_MsgTypeSupport_get_type_name(g_MessageTypeSupport); g_MessageTopic = createTopic("WaitSetData_Msg", g_MessageTypeName); DDS_free(g_MessageTypeName); DDS_free(g_MessageTypeSupport); // Create the Publisher's in the DDS Domain. message_Publisher = createPublisher(); // Request a Writer from the the Publisher. message_DataWriter = createDataWriter(message_Publisher, g_MessageTopic); message_Sample = WaitSetData_Msg__alloc(); message_Sample->userID = 1; message_Sample->message = DDS_string_alloc(firstHelloLength); strncpy(message_Sample->message, firstHello, firstHelloLength); printf("\n=== [WaitSetDataPublisher] writing a message containing :"); printf("\n userID : %d", message_Sample->userID); printf("\n Message : \"%s\"", message_Sample->message); g_status = WaitSetData_MsgDataWriter_write(message_DataWriter, message_Sample, DDS_HANDLE_NIL); checkStatus(g_status, "WaitSetData_MsgDataWriter_write"); DDS_free(message_Sample->message); // Let the time for the new StatusCondition to be handled by the Subscriber. os_nanoSleep(os_delay300ms); message_Sample->message = DDS_string_alloc(helloAgainLength); strncpy(message_Sample->message, helloAgain, helloAgainLength); printf("\n=== [WaitSetDataPublisher] writing a message containing :"); printf("\n userID : %d", message_Sample->userID); printf("\n Message : \"%s\"", message_Sample->message); g_status = WaitSetData_MsgDataWriter_write(message_DataWriter, message_Sample, DDS_HANDLE_NIL); checkStatus(g_status, "WaitSetData_MsgDataWriter_write"); // This time, no need to free message_Sample->message as it will be freed by DDS_free(message_Sample); // Let the time for the new StatusCondition to be handled by the Subscriber. os_nanoSleep(os_delay300ms); printf("\n=== [WaitSetDataPublisher] Exiting.\n\n"); // Cleanup DDS deleteDataWriter(message_Publisher, message_DataWriter); // Let the time for the new StatusCondition to be handled by the Subscriber. os_nanoSleep(os_delay300ms); deletePublisher(message_Publisher); deleteTopic(g_MessageTopic); deleteParticipant(); // Cleanup C allocations DDS_free(message_Sample); return 0; }