void recreate_data_writer_and_topic(DataWriter_var& dw, const DataReader_var& dr)
{
DataWriterQos dw_qos;
dw->get_qos(dw_qos);
Topic_var topic = dw->get_topic();
TopicQos topic_qos;
topic->get_qos(topic_qos);
CORBA::String_var topic_name = topic->get_name(),
type_name = topic->get_type_name();
Publisher_var pub = dw->get_publisher();
DomainParticipant_var dp = pub->get_participant();
pub->delete_datawriter(dw);
dw = 0;
dp->delete_topic(topic);
topic = 0;
// Wait until the data reader is not associated with the writer.
wait_match (dr, 0);
topic = dp->create_topic(topic_name, type_name, topic_qos, 0, 0);
if (!topic) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create topic\n"));
return;
}
dw = pub->create_datawriter(topic, dw_qos, 0, 0);
if (!dw) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create data writer\n"));
}
}
int
OSPL_MAIN (
int argc,
char *argv[])
{
/* Generic DDS entities */
DomainParticipantFactory_var dpf;
DomainParticipant_var participant;
Topic_var chatMessageTopic;
Subscriber_var chatSubscriber;
DataReader_ptr parentReader;
/* Type-specific DDS entities */
ChatMessageTypeSupport_var chatMessageTS;
ChatMessageDataReader_var chatAdmin;
ChatMessageSeq_var msgSeq = new ChatMessageSeq();
SampleInfoSeq_var infoSeq = new SampleInfoSeq();
/* QosPolicy holders */
TopicQos reliable_topic_qos;
SubscriberQos sub_qos;
DDS::StringSeq parameterList;
/* DDS Identifiers */
DomainId_t domain = 0;
ReturnCode_t status;
/* Others */
bool terminated = false;
const char * partitionName = "ChatRoom1";
char * chatMessageTypeName = NULL;
/* Options: MessageBoard [ownID] */
/* Messages having owner ownID will be ignored */
parameterList.length(1);
if (argc > 1) {
parameterList[0] = string_dup(argv[1]);
}
else
{
parameterList[0] = "0";
}
/* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings. */
dpf = DomainParticipantFactory::get_instance();
checkHandle(dpf.in(), "DDS::DomainParticipantFactory::get_instance");
participant = dpf->create_participant (
domain,
PARTICIPANT_QOS_DEFAULT,
NULL,
STATUS_MASK_NONE);
checkHandle(participant, "DDS::DomainParticipantFactory::create_participant");
/* Register the required datatype for ChatMessage. */
chatMessageTS = new ChatMessageTypeSupport();
checkHandle(chatMessageTS.in(), "new ChatMessageTypeSupport");
chatMessageTypeName = chatMessageTS->get_type_name();
status = chatMessageTS->register_type(
participant.in(),
chatMessageTypeName);
checkStatus(status, "NetworkPartitionsData::ChatMessageTypeSupport::register_type");
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant->get_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos");
reliable_topic_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
/* Make the tailored QoS the new default. */
status = participant->set_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::set_default_topic_qos");
/* Use the changed policy when defining the ChatMessage topic */
chatMessageTopic = participant->create_topic(
"Chat_ChatMessage",
chatMessageTypeName,
reliable_topic_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::create_topic (ChatMessage)");
/* Adapt the default SubscriberQos to read from the "ChatRoom1" Partition. */
status = participant->get_default_subscriber_qos (sub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_subscriber_qos");
sub_qos.partition.name.length(1);
sub_qos.partition.name[0] = partitionName;
/* Create a Subscriber for the MessageBoard application. */
chatSubscriber = participant->create_subscriber(sub_qos, NULL, STATUS_MASK_NONE);
checkHandle(chatSubscriber.in(), "DDS::DomainParticipant::create_subscriber");
/* Create a DataReader for the NamedMessage Topic (using the appropriate QoS). */
parentReader = chatSubscriber->create_datareader(
chatMessageTopic.in(),
DATAREADER_QOS_USE_TOPIC_QOS,
NULL,
STATUS_MASK_NONE);
checkHandle(parentReader, "DDS::Subscriber::create_datareader");
/* Narrow the abstract parent into its typed representative. */
chatAdmin = ChatMessageDataReader::_narrow(parentReader);
checkHandle(chatAdmin.in(), "NetworkPartitionsData::ChatMessageDataReader::_narrow");
/* Print a message that the MessageBoard has opened. */
cout << "MessageBoard has opened: send a ChatMessage with userID = -1 to close it...." << endl << endl;
while (!terminated) {
/* Note: using read does not remove the samples from
unregistered instances from the DataReader. This means
that the DataRase would use more and more resources.
That's why we use take here instead. */
status = chatAdmin->take(
msgSeq,
infoSeq,
LENGTH_UNLIMITED,
ANY_SAMPLE_STATE,
ANY_VIEW_STATE,
ALIVE_INSTANCE_STATE );
checkStatus(status, "NetworkPartitionsData::ChatMessageDataReader::take");
for (ULong i = 0; i < msgSeq->length(); i++) {
ChatMessage *msg = &(msgSeq[i]);
if (msg->userID == TERMINATION_MESSAGE) {
cout << "Termination message received: exiting..." << endl;
terminated = true;
} else {
cout << msg->userID << ": " << msg->content << endl;
}
}
status = chatAdmin->return_loan(msgSeq, infoSeq);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataReader::return_loan");
/* Sleep for some amount of time, so as not to consume too many CPU cycles. */
sleep(1);
}
/* Remove the DataReader */
status = chatSubscriber->delete_datareader(chatAdmin.in());
checkStatus(status, "DDS::Subscriber::delete_datareader");
/* Remove the Subscriber. */
status = participant->delete_subscriber(chatSubscriber.in());
checkStatus(status, "DDS::DomainParticipant::delete_subscriber");
/* Remove the Topic. */
status = participant->delete_topic(chatMessageTopic.in());
checkStatus(status, "DDS::DomainParticipant::delete_topic (chatMessageTopic)");
/* De-allocate the type-names. */
string_free(chatMessageTypeName);
/* Remove the DomainParticipant. */
status = dpf->delete_participant(participant.in());
checkStatus(status, "DDS::DomainParticipantFactory::delete_participant");
return 0;
}
int
OSPL_MAIN (
int argc,
char *argv[])
{
/* Generic DDS entities */
DomainParticipantFactory_var dpf;
DomainParticipant_var participant;
Topic_var chatMessageTopic;
Publisher_var chatPublisher;
DataWriter_ptr parentWriter;
/* QosPolicy holders */
TopicQos reliable_topic_qos;
PublisherQos pub_qos;
DataWriterQos dw_qos;
/* DDS Identifiers */
DomainId_t domain = 0;
InstanceHandle_t userHandle;
ReturnCode_t status;
/* Type-specific DDS entities */
ChatMessageTypeSupport_var chatMessageTS;
ChatMessageDataWriter_var talker;
/* Sample definitions */
ChatMessage *msg; /* Example on Heap */
/* Others */
int ownID = 1;
int i;
const char *partitionName = "ChatRoom1";
char *chatMessageTypeName = NULL;
char buf[MAX_MSG_LEN];
#ifdef INTEGRITY
#ifdef CHATTER_QUIT
ownID = -1;
#else
ownID = 1;
#endif
#else
/* Options: Chatter [ownID] */
if (argc > 1) {
ownID = atoi(argv[1]);
}
#endif
/* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings. */
dpf = DomainParticipantFactory::get_instance ();
checkHandle(dpf.in(), "DDS::DomainParticipantFactory::get_instance");
participant = dpf->create_participant(domain, PARTICIPANT_QOS_DEFAULT, NULL, STATUS_MASK_NONE);
checkHandle(participant.in(), "DDS::DomainParticipantFactory::create_participant");
/* Register the required datatype for ChatMessage. */
chatMessageTS = new ChatMessageTypeSupport();
checkHandle(chatMessageTS.in(), "new ChatMessageTypeSupport");
chatMessageTypeName = chatMessageTS->get_type_name();
status = chatMessageTS->register_type(
participant.in(),
chatMessageTypeName);
checkStatus(status, "NetworkPartitionsData::ChatMessageTypeSupport::register_type");
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant->get_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos");
reliable_topic_qos.reliability.kind = RELIABLE_RELIABILITY_QOS;
/* Make the tailored QoS the new default. */
status = participant->set_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::set_default_topic_qos");
/* Use the changed policy when defining the ChatMessage topic */
chatMessageTopic = participant->create_topic(
"Chat_ChatMessage",
chatMessageTypeName,
reliable_topic_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::create_topic (ChatMessage)");
/* Adapt the default PublisherQos to write into the "ChatRoom1" Partition. */
status = participant->get_default_publisher_qos (pub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_publisher_qos");
pub_qos.partition.name.length(1);
pub_qos.partition.name[0] = partitionName;
/* Create a Publisher for the chatter application. */
chatPublisher = participant->create_publisher(pub_qos, NULL, STATUS_MASK_NONE);
checkHandle(chatPublisher.in(), "DDS::DomainParticipant::create_publisher");
/* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */
parentWriter = chatPublisher->create_datawriter(
chatMessageTopic.in(),
DATAWRITER_QOS_USE_TOPIC_QOS,
NULL,
STATUS_MASK_NONE);
checkHandle(parentWriter, "DDS::Publisher::create_datawriter (chatMessage)");
/* Narrow the abstract parent into its typed representative. */
talker = ChatMessageDataWriter::_narrow(parentWriter);
checkHandle(talker.in(), "NetworkPartitionsData::ChatMessageDataWriter::_narrow");
/* Initialize the chat messages on Heap. */
msg = new ChatMessage();
checkHandle(msg, "new ChatMessage");
msg->userID = ownID;
msg->index = 0;
if (ownID == TERMINATION_MESSAGE) {
snprintf(buf, MAX_MSG_LEN, "Termination message.");
} else {
snprintf(buf, MAX_MSG_LEN, "Hi there, I will send you %d more messages.", NUM_MSG);
}
msg->content = string_dup(buf);
cout << "Writing message: \"" << msg->content << "\"" << endl;
/* Register a chat message for this user (pre-allocating resources for it!!) */
userHandle = talker->register_instance(*msg);
/* Write a message using the pre-generated instance handle. */
status = talker->write(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::write");
sleep (1); /* do not run so fast! */
/* Write any number of messages, re-using the existing string-buffer: no leak!!. */
for (i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++) {
msg->index = i;
snprintf(buf, MAX_MSG_LEN, "Message no. %d", i);
msg->content = string_dup(buf);
cout << "Writing message: \"" << msg->content << "\"" << endl;
status = talker->write(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::write");
sleep (1); /* do not run so fast! */
}
/* Leave the room by disposing and unregistering the message instance. */
status = talker->dispose(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::dispose");
status = talker->unregister_instance(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::unregister_instance");
/* Release the data-samples. */
delete msg; // msg allocated on heap: explicit de-allocation required!!
/* Remove the DataWriters */
status = chatPublisher->delete_datawriter( talker.in() );
checkStatus(status, "DDS::Publisher::delete_datawriter (talker)");
/* Remove the Publisher. */
status = participant->delete_publisher( chatPublisher.in() );
checkStatus(status, "DDS::DomainParticipant::delete_publisher");
status = participant->delete_topic( chatMessageTopic.in() );
checkStatus(status, "DDS::DomainParticipant::delete_topic (chatMessageTopic)");
/* Remove the type-names. */
string_free(chatMessageTypeName);
/* Remove the DomainParticipant. */
status = dpf->delete_participant( participant.in() );
checkStatus(status, "DDS::DomainParticipantFactory::delete_participant");
cout << "Completed Chatter example" << endl;
return 0;
}
