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;
}