StartLineProcessConnector::~StartLineProcessConnector() {
DDSDomainParticipant *participant = RTIConnector::getParticipant();
DDS_ReturnCode_t retcode;
if (NULL != m_reader_cache) {
if (DDS_RETCODE_OK != RTIConnector::getSubscriber()->delete_datareader(m_reader_cache)) {
g_cSystemLogger.LogMessage("(%s:%s(:%d))::Unable to delete m_reader_cache \n", LOG_LOCATION);
}
m_reader_cache = NULL;
}
if (NULL != m_read_topic) {
if (DDS_RETCODE_OK != participant->delete_topic(m_read_topic)) {
g_cSystemLogger.LogMessage("(%s:%s(:%d))::Unable to delete m_read_topic \n", LOG_LOCATION);
}
m_read_topic = NULL;
}
// Un-register the type...
if ((NULL != participant) && (NULL != m_type_name_cache)) {
retcode = MONITORING::leaseProcessStartTypeSupport::unregister_type(participant, m_type_name_cache);
if (retcode != DDS_RETCODE_OK) {
g_cSystemLogger.LogMessage("(%s:%s(:%d))::Error ---> RTCConnector() unregister_type RTC error \n", LOG_LOCATION);
}
m_type_name_cache = NULL;
}
pt_rtc = 0;
return;
}
int dispose(){
DDS_ReturnCode_t retCode;
int status = 0;
if (participant != NULL) {
retCode = participant->delete_contained_entities();
if (retCode != DDS_RETCODE_OK) {
printf("delete_contained_entities error %d\n", retCode);
status = -1;
}
retCode = DDSTheParticipantFactory->delete_participant(participant);
if (retCode != DDS_RETCODE_OK) {
printf("delete_participant error %d\n", retCode);
status = -1;
}
}
/* Release memory associated with participant factory */
retCode = DDSDomainParticipantFactory::finalize_instance();
if (retCode != DDS_RETCODE_OK) {
printf("finalize_instance error %d\n", retCode);
status = -1;
}
std::cout<<"\n All entities deleted successfully !";
return status;
}
void
Component_exec_i::check_domain_id (DDSPublisher * pub)
{
#if (CIAO_DDS4CCM_NDDS == 1)
DDSDomainParticipant * part = pub->get_participant ();
if (part->get_domain_id () != DOMAIN_ID_IN_DP)
{
ACE_ERROR ((LM_ERROR, "Component_exec_i::check_domain_id - "
"ERROR: Domain ID not set properly: "
"expected <%u> - retrieved <%u>\n",
DOMAIN_ID_IN_DP,
part->get_domain_id ()));
}
else
{
ACE_DEBUG ((LM_DEBUG, "Component_exec_i::check_domain_id - "
"Domain ID set properly.\n"));
}
#else
ACE_UNUSED_ARG (pub);
#endif
}
StartLineProcessConnector::StartLineProcessConnector(const char* rd_topic) {
DDS_ReturnCode_t retcode_cache;
DDSDomainParticipant *participant = RTIConnector::getParticipant();
m_read_topic = NULL;
pt_rtc = NULL;
m_reader_cache = NULL;
if (rd_topic == NULL) {
g_cSystemLogger.LogMessage("(%s:%s:%d):: Error --->rd_topic is NULL \n", LOG_LOCATION);
return;
}
if (participant == NULL) {
g_cSystemLogger.LogMessage("(%s:%s:%d):: Error --->Participant is NULL \n", LOG_LOCATION);
return;
}
/* Register the type before creating the topic for RTC */
m_type_name_cache = MONITORING::leaseProcessStartTypeSupport::get_type_name();
retcode_cache = MONITORING::leaseProcessStartTypeSupport::register_type(participant, m_type_name_cache);
if (retcode_cache != DDS_RETCODE_OK) {
g_cSystemLogger.LogMessage("(%s:%s:%d):: Error --->Register Type RTC ERROR \n", LOG_LOCATION);
m_type_name_cache = NULL;
return;
}
if (NULL == m_read_topic) {
/* To customize the topic QoS, use the configuration file USER_QOS_PROFILES.xml */
m_read_topic = participant->create_topic(rd_topic, m_type_name_cache, DDS_TOPIC_QOS_DEFAULT, NULL /* listener */
, DDS_STATUS_MASK_NONE);
if (m_read_topic == NULL) {
g_cSystemLogger.LogMessage("(%s:%s:%d):: Error --->create topic success is NULL \n", LOG_LOCATION);
return;
}
}
g_cSystemLogger.LogMessage("(%s:%s:%d):: --->create topic success \n", LOG_LOCATION);
}
int initialise(){
/* To customize the participant QoS, use
the configuration file USER_QOS_PROFILES.xml */
participant = DDSTheParticipantFactory->
create_participant_from_config(
"MyParticipantLibrary::SubscriptionParticipant");
if (participant == NULL) {
printf("create_participant_from_config error\n");
return -1;
}
else
{
std::cout<<"\n Subscriber initialised successfully !"<<std::endl;
subscriber=participant->lookup_subscriber_by_name("MySubscriber");
if (subscriber == NULL) {
printf("lookup_subscriber_by_name error\n");
return -1;
}
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
DDS_ReturnCode_t retcode;
DDSTopic* topic = 0;
DDSDataWriter* data_writer = 0;
DDSPublisher* publisher = 0;
int main_result = 1; /* error by default */
// NDDS_Config_LogVerbosity n_verbosity =
// static_cast <NDDS_Config_LogVerbosity> (3);
// NDDSConfigLogger::get_instance()->set_verbosity (n_verbosity);
const ACE_TCHAR * env_domain_id = 0;
if (argc > 1)
{
env_domain_id = argv[1];
}
if (!env_domain_id)
{
printf ("Environment variable DEFAULT_DOMAIN_ID not set "
"=> setting it to 2\n");
env_domain_id = "2";
}
else
printf ("Domain ID set to %s\n", env_domain_id);
const int domain_id = ACE_OS::atoi (env_domain_id);
DDSDomainParticipant *participant = DDSDomainParticipantFactory::get_instance()->
create_participant_with_profile (domain_id, /* Domain ID */
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!participant) {
cerr << "SENDER: Error creating participant" << endl;
goto clean_exit;
}
retcode = QueryConditionTestTypeSupport::register_type(
participant, QueryConditionTestTypeSupport::get_type_name ());
if (retcode != DDS_RETCODE_OK) {
cerr << "SENDER: Error registering type" << endl;
goto clean_exit;
}
topic = participant->create_topic_with_profile (
"QC", /* Topic name*/
QueryConditionTestTypeSupport::get_type_name (), /* Type name */
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!topic) {
cerr << "SENDER: Error creating topic" << endl;
goto clean_exit;
}
publisher = participant->create_publisher_with_profile (LIBRARY_NAME,
PROFILE_NAME,
0,
0);
if (!publisher) {
cerr << "SENDER: Error creating publisher" << endl;
goto clean_exit;
}
data_writer = publisher->create_datawriter_with_profile (
topic,
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!data_writer) {
cerr << "SENDER: Error creating data writer" << endl;
goto clean_exit;
}
write (data_writer);
sleep_now (8);
write (data_writer);
sleep_now (8);
write (data_writer);
sleep_now (30);
main_result = 0;
clean_exit:
cout << "SENDER: Exiting ..." << endl;
if (participant) {
retcode = participant->delete_contained_entities();
if (retcode != DDS_RETCODE_OK) {
main_result = 1;
}
retcode = DDSDomainParticipantFactory::get_instance()->
delete_participant(participant);
if (retcode != DDS_RETCODE_OK) {
main_result = 1;
}
}
DDSDomainParticipantFactory::finalize_instance ();
return main_result;
}
rmw_node_t *
create_node(const char * implementation_identifier, const char * name, size_t domain_id)
{
DDSDomainParticipantFactory * dpf_ = DDSDomainParticipantFactory::get_instance();
if (!dpf_) {
RMW_SET_ERROR_MSG("failed to get participant factory");
return NULL;
}
// use loopback interface to enable cross vendor communication
DDS_DomainParticipantQos participant_qos;
DDS_ReturnCode_t status = dpf_->get_default_participant_qos(participant_qos);
if (status != DDS_RETCODE_OK) {
RMW_SET_ERROR_MSG("failed to get default participant qos");
return NULL;
}
// forces local traffic to be sent over loopback,
// even if a more efficient transport (such as shared memory) is installed
// (in which case traffic will be sent over both transports)
status = DDSPropertyQosPolicyHelper::add_property(
participant_qos.property,
"dds.transport.UDPv4.builtin.ignore_loopback_interface",
"0",
DDS_BOOLEAN_FALSE);
if (status != DDS_RETCODE_OK) {
RMW_SET_ERROR_MSG("failed to add qos property");
return NULL;
}
status = DDSPropertyQosPolicyHelper::add_property(
participant_qos.property,
"dds.transport.use_510_compatible_locator_kinds",
"1",
DDS_BOOLEAN_FALSE);
if (status != DDS_RETCODE_OK) {
RMW_SET_ERROR_MSG("failed to add qos property");
return NULL;
}
DDS_DomainId_t domain = static_cast<DDS_DomainId_t>(domain_id);
DDSDomainParticipant * participant = dpf_->create_participant(
domain, participant_qos, NULL,
DDS_STATUS_MASK_NONE);
if (!participant) {
RMW_SET_ERROR_MSG("failed to create participant");
return NULL;
}
rmw_node_t * node_handle = nullptr;
ConnextNodeInfo * node_info = nullptr;
rmw_guard_condition_t * graph_guard_condition = nullptr;
CustomPublisherListener * publisher_listener = nullptr;
CustomSubscriberListener * subscriber_listener = nullptr;
void * buf = nullptr;
DDSDataReader * data_reader = nullptr;
DDSPublicationBuiltinTopicDataDataReader * builtin_publication_datareader = nullptr;
DDSSubscriptionBuiltinTopicDataDataReader * builtin_subscription_datareader = nullptr;
DDSSubscriber * builtin_subscriber = participant->get_builtin_subscriber();
if (!builtin_subscriber) {
RMW_SET_ERROR_MSG("builtin subscriber handle is null");
goto fail;
}
// setup publisher listener
data_reader = builtin_subscriber->lookup_datareader(DDS_PUBLICATION_TOPIC_NAME);
builtin_publication_datareader =
static_cast<DDSPublicationBuiltinTopicDataDataReader *>(data_reader);
if (!builtin_publication_datareader) {
RMW_SET_ERROR_MSG("builtin publication datareader handle is null");
goto fail;
}
graph_guard_condition = create_guard_condition(implementation_identifier);
if (!graph_guard_condition) {
RMW_SET_ERROR_MSG("failed to create graph guard condition");
goto fail;
}
buf = rmw_allocate(sizeof(CustomPublisherListener));
if (!buf) {
RMW_SET_ERROR_MSG("failed to allocate memory");
goto fail;
}
RMW_TRY_PLACEMENT_NEW(
publisher_listener, buf, goto fail, CustomPublisherListener,
implementation_identifier, graph_guard_condition)
buf = nullptr;
builtin_publication_datareader->set_listener(publisher_listener, DDS_DATA_AVAILABLE_STATUS);
data_reader = builtin_subscriber->lookup_datareader(DDS_SUBSCRIPTION_TOPIC_NAME);
builtin_subscription_datareader =
static_cast<DDSSubscriptionBuiltinTopicDataDataReader *>(data_reader);
if (!builtin_subscription_datareader) {
RMW_SET_ERROR_MSG("builtin subscription datareader handle is null");
goto fail;
}
// setup subscriber listener
buf = rmw_allocate(sizeof(CustomSubscriberListener));
if (!buf) {
RMW_SET_ERROR_MSG("failed to allocate memory");
goto fail;
}
RMW_TRY_PLACEMENT_NEW(
subscriber_listener, buf, goto fail, CustomSubscriberListener,
implementation_identifier, graph_guard_condition)
buf = nullptr;
builtin_subscription_datareader->set_listener(subscriber_listener, DDS_DATA_AVAILABLE_STATUS);
node_handle = rmw_node_allocate();
if (!node_handle) {
RMW_SET_ERROR_MSG("failed to allocate memory for node handle");
goto fail;
}
node_handle->implementation_identifier = implementation_identifier;
node_handle->data = participant;
node_handle->name =
reinterpret_cast<const char *>(rmw_allocate(sizeof(char) * strlen(name) + 1));
if (!node_handle->name) {
RMW_SET_ERROR_MSG("failed to allocate memory for node name");
goto fail;
}
memcpy(const_cast<char *>(node_handle->name), name, strlen(name) + 1);
buf = rmw_allocate(sizeof(ConnextNodeInfo));
if (!buf) {
RMW_SET_ERROR_MSG("failed to allocate memory");
goto fail;
}
RMW_TRY_PLACEMENT_NEW(node_info, buf, goto fail, ConnextNodeInfo)
buf = nullptr;
node_info->participant = participant;
node_info->publisher_listener = publisher_listener;
node_info->subscriber_listener = subscriber_listener;
node_info->graph_guard_condition = graph_guard_condition;
node_handle->implementation_identifier = implementation_identifier;
node_handle->data = node_info;
return node_handle;
fail:
status = dpf_->delete_participant(participant);
if (status != DDS_RETCODE_OK) {
std::stringstream ss;
ss << "leaking participant while handling failure at " <<
__FILE__ << ":" << __LINE__;
(std::cerr << ss.str()).flush();
}
if (graph_guard_condition) {
rmw_ret_t ret = destroy_guard_condition(implementation_identifier, graph_guard_condition);
if (ret != RMW_RET_OK) {
std::stringstream ss;
ss << "failed to destroy guard condition while handling failure at " <<
__FILE__ << ":" << __LINE__;
(std::cerr << ss.str()).flush();
}
}
if (publisher_listener) {
RMW_TRY_DESTRUCTOR_FROM_WITHIN_FAILURE(
publisher_listener->~CustomPublisherListener(), CustomPublisherListener)
rmw_free(publisher_listener);
}
if (subscriber_listener) {
RMW_TRY_DESTRUCTOR_FROM_WITHIN_FAILURE(
subscriber_listener->~CustomSubscriberListener(), CustomSubscriberListener)
rmw_free(subscriber_listener);
}
if (node_handle) {
if (node_handle->name) {
rmw_free(const_cast<char *>(node_handle->name));
}
rmw_free(node_handle);
}
if (node_info) {
RMW_TRY_DESTRUCTOR_FROM_WITHIN_FAILURE(
node_info->~ConnextNodeInfo(), ConnextNodeInfo)
rmw_free(node_info);
}
if (buf) {
rmw_free(buf);
}
return NULL;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
DDSTopic* topic = 0;
DDSDataReader* data_reader = 0;
DDSSubscriber* sub = 0;
DDS_ReturnCode_t retcode = DDS_RETCODE_OK;
QueryConditionTestDataReader* typed_dr = 0;
DDSQueryCondition* qc = 0;
DDSReadCondition* rc = 0;
int run = 0;
// NDDS_Config_LogVerbosity n_verbosity =
// static_cast <NDDS_Config_LogVerbosity> (3);
// NDDSConfigLogger::get_instance()->set_verbosity (n_verbosity);
const ACE_TCHAR * env_domain_id = 0;
if (argc > 1)
{
env_domain_id = argv[1];
}
if (!env_domain_id)
{
printf ("Environment variable DEFAULT_DOMAIN_ID not set "
"=> setting it to 2\n");
env_domain_id = "2";
}
else
printf ("Domain ID set to %s\n", env_domain_id);
const int domain_id = ACE_OS::atoi (env_domain_id);
DDSDomainParticipant *participant = DDSDomainParticipantFactory::get_instance()->
create_participant_with_profile (domain_id, /* Domain ID */
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!participant) {
cerr << "RECEIVER: Error creating participant" << endl;
return 1;
}
retcode = QueryConditionTestTypeSupport::register_type(
participant, QueryConditionTestTypeSupport::get_type_name ());
if (retcode != DDS_RETCODE_OK) {
cerr << "RECEIVER: Error registering type" << endl;
return clean_up (participant);
}
topic = participant->create_topic_with_profile (
"QC", /* Topic name*/
QueryConditionTestTypeSupport::get_type_name (), /* Type name */
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!topic) {
cerr << "RECEIVER: Error creating topic" << endl;
return clean_up (participant);
}
sub = participant->create_subscriber_with_profile (LIBRARY_NAME,
PROFILE_NAME,
0,
0);
if (!sub) {
cerr << "RECEIVER: Error creating subscriber" << endl;
return clean_up (participant);
}
data_reader = sub->create_datareader_with_profile (
topic,
LIBRARY_NAME, /* QoS */
PROFILE_NAME,
0, /* Listener */
DDS_STATUS_MASK_NONE);
if (!data_reader) {
cerr << "RECEIVER: Error creating data reader" << endl;
return clean_up (participant);
}
typed_dr = QueryConditionTestDataReader::narrow (data_reader);
if (!typed_dr) {
cerr << "RECEIVER: Unable to cast to a type specific data reader" << endl;
return clean_up (participant);
}
const char* PARAMS_RUN_1[] = {"1", "3"};
DDS_StringSeq parameters_run_1;
parameters_run_1.from_array (PARAMS_RUN_1, 2);
qc = typed_dr->create_querycondition (
DDS_NOT_READ_SAMPLE_STATE,
DDS_NEW_VIEW_STATE | DDS_NOT_NEW_VIEW_STATE,
DDS_ALIVE_INSTANCE_STATE | DDS_NOT_ALIVE_INSTANCE_STATE,
"iteration > %0 AND iteration < %1",
parameters_run_1);
if (!qc) {
cerr << "RECEIVER: Error creating query condition" << endl;
return clean_up (participant);
}
else
cout << "RECEIVER: query condition created : iteration > 1 AND iteration < 3" << endl;
ws_->attach_condition (qc);
cout << "RECEIVER: Expecting two samples (key_1 and key_2) with iteration 2." <<endl;
read (data_reader, qc, rc, ++run);
//Second run: change the parameters
if (qc)
{
const char* PARAMS_RUN_2[] = {"4", "6"};
DDS_StringSeq parameters_run_2;
parameters_run_2.from_array (PARAMS_RUN_2, 2);
if (qc->set_query_parameters (parameters_run_2) != DDS_RETCODE_OK)
{
cerr << "RECEIVER: Unable the set the new query parameters!!!" << endl;
return clean_up (participant);
}
}
cout << "RECEIVER: query condition changed : iteration > 4 AND iteration < 6" << endl;
cout << "RECEIVER: Expecting two samples (key_1 and key_2) with iterations 5" <<endl;
read (data_reader, qc, rc, ++run);
// Third run: Detach querycondition and create read condition instead.
// Remove the qc from the waitset and create a readcondition and start receiving
// samples
if (ws_->detach_condition (qc) != DDS_RETCODE_OK)
{
cerr << "RECEIVER: Error detaching query condition" << endl;
return clean_up (participant);
}
// Delete the query condition from the data reader
typed_dr->delete_readcondition (qc);
cout << "RECEIVER: query condition deleted" << endl;
cout << "RECEIVER: create read condition : DDS_NOT_READ_SAMPLE_STATE,"
<< "DDS_NEW_VIEW_STATE | DDS_NOT_NEW_VIEW_STATE,"
<< "DDS_ALIVE_INSTANCE_STATE | DDS_NOT_ALIVE_INSTANCE_STATE" << endl;
sleep_now(10);
rc = typed_dr->create_readcondition (
DDS_NOT_READ_SAMPLE_STATE,
DDS_NEW_VIEW_STATE | DDS_NOT_NEW_VIEW_STATE,
DDS_ALIVE_INSTANCE_STATE | DDS_NOT_ALIVE_INSTANCE_STATE);
if (!rc) {
cerr << "RECEIVER: Error creating read condition" << endl;
return clean_up (participant);
}
if (ws_->attach_condition (rc) != DDS_RETCODE_OK)
{
cerr << "RECEIVER: Error attaching read condition" << endl;
return clean_up (participant);
}
cout << "RECEIVER: Expecting ALL UNREAD samples (key_1 and key_2) with iterations between 1 and 9, except 2 and 5" <<endl;
read (data_reader, qc, rc, ++run);
return clean_up (participant);
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
timer = RTIHighResolutionClock_new();
DDS_ReturnCode_t retcode;
::DDS::DataReader * data_reader = 0;
::DDS::DataReader * dum_data_reader = 0;
HelloListener listener;
DummyListener dum_listener;
const char * type_name = 0;
int main_result = 1; /* error by default */
::DDS::Topic * receive_topic = 0;
::DDS::Topic * send_topic = 0;
::DDS::DataWriter * data_writer = 0;
::DDS::DataWriter * dum_data_writer = 0;
DummyPublisherListener * pub_listener = 0;
::DDS::Publisher * pub = 0;
try
{
ACE_Env_Value<int> id (ACE_TEXT("DDS4CCM_DEFAULT_DOMAIN_ID"), domain_id_);
domain_id_ = id;
if (parse_args (argc, argv) != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Error arguments.\n")));
return 1;
}
/* Create the domain participant */
DDSDomainParticipant * participant =
DDSDomainParticipantFactory::get_instance()->
create_participant_with_profile(
domain_id_,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!participant)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Sender : Unable to create domain participant.\n")));
goto clean_exit;
}
/* Register type before creating topic */
type_name = LatencyTestTypeSupport::get_type_name();
retcode = LatencyTestTypeSupport::register_type (participant,
type_name);
if (retcode != DDS_RETCODE_OK)
{
goto clean_exit;
}
send_topic = participant->create_topic_with_profile (
"send",
type_name,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!send_topic)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create topic.\n")));
goto clean_exit;
}
receive_topic = participant->create_topic_with_profile (
"receive",
type_name,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!receive_topic)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create topic.\n")));
goto clean_exit;
}
pub_listener = new DummyPublisherListener ();
pub = participant->create_publisher_with_profile (
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!pub)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create publisher.\n")));
goto clean_exit;
}
/* Create the data writer using the publisher */
data_writer = pub->create_datawriter_with_profile(
send_topic,
lib_name_,
prof_name_,
pub_listener,
DDS_OFFERED_DEADLINE_MISSED_STATUS |
DDS_OFFERED_INCOMPATIBLE_QOS_STATUS |
DDS_RELIABLE_WRITER_CACHE_CHANGED_STATUS |
DDS_RELIABLE_READER_ACTIVITY_CHANGED_STATUS |
DDS_LIVELINESS_LOST_STATUS |
DDS_PUBLICATION_MATCHED_STATUS);
if (!data_writer)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data writer.\n")));
goto clean_exit;
}
/* Create a data reader, which will not be used, but is there for
* compatibility with DDS4CCM latency test, where there is always a
* reader and a writer per connector.
*/
if (both_read_write_)
{
dum_data_reader = participant->create_datareader_with_profile(
send_topic,
lib_name_,
prof_name_,
&dum_listener,
DDS_DATA_AVAILABLE_STATUS);
if (!dum_data_reader )
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create dummy data reader.\n")));
goto clean_exit;
}
}
data_reader = participant->create_datareader_with_profile(
receive_topic,
lib_name_,
prof_name_,
&listener,
DDS_DATA_AVAILABLE_STATUS);
if (!data_reader)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data reader.\n")));
goto clean_exit;
}
/* Create a data writer, which will not be used, but is there for
* compatibility with DDS4CCM latency test, where there is always a
* reader and a writer per connector
*/
if (both_read_write_)
{
dum_data_writer = participant->create_datawriter_with_profile(
receive_topic,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!dum_data_writer)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create dummy data writer.\n")));
goto clean_exit;
}
}
/* Create data sample for writing */
instance_ = LatencyTestTypeSupport::create_data ();
if (instance_ == 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data sample.\n")));
goto clean_exit;
}
init_values();
test_data_writer_ = LatencyTestDataWriter::narrow (data_writer);
if (!test_data_writer_)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("LatencyTestDataWriter_narrow failed.\n")));
goto clean_exit;
}
// Sleep a couple seconds to allow discovery to happen
ACE_OS::sleep (5);
// handle writing of messages
start();
/* --- Clean Up --- */
ACE_OS::sleep (5);
main_result = 0;
clean_exit:
const char * read_write_str = 0;
if (both_read_write_)
{
read_write_str = "Used a extra dummy reader and writer per topic.";
}
else
{
read_write_str = "Used a reader for one topic and a writer for other topic.";
}
if((nr_of_runs_ -1) != datalen_idx_)
{
ACE_DEBUG ((LM_DEBUG, "SUMMARY SENDER : %u of %u runs completed.\n"
" Number of messages sent of last run (%u): %u\n"
"%C\n\n",
datalen_idx_,
nr_of_runs_,
datalen_idx_ + 1,
number_of_msg_,
read_write_str));
}
else
{
ACE_DEBUG ((LM_DEBUG, "TEST successful, number of runs (%u) of "
"%u messages.\n"
"%C\n\n",
nr_of_runs_,
number_of_msg_,
read_write_str));
}
ACE_DEBUG ((LM_DEBUG, "\tNumber of unexpected events : %u\n",
unexpected_count_));
if (participant)
{
retcode = participant->delete_contained_entities ();
if (retcode != DDS_RETCODE_OK)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Deletion failed.\n")));
main_result = 1;
}
retcode = DDSDomainParticipantFactory::get_instance()->
delete_participant (participant);
if (retcode != DDS_RETCODE_OK)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Deletion failed.\n")));
main_result = 1;
}
}
}
catch (const ::CORBA::Exception &ex)
{
ex._tao_print_exception("ERROR : Unexpected CORBA exception caught :");
main_result = 1;
}
delete [] datalen_range_;
delete [] duration_times_;
delete pub_listener;
return main_result;
}
void MyPublisher::publish(unsigned short *image, const std::string& qosProfileName,
uint32_t domainId, const std::string& topic)
{
DDSDomainParticipant *participant = DDSDomainParticipantFactory::get_instance()->
create_participant_with_profile(
domainId,
"DataExchangeProfile",
qosProfileName.c_str(),
NULL,
DDS_STATUS_MASK_NONE);
if(participant == NULL) {
std::cout << "Error while creating participant" << std::endl;
}
DataExchangeTypeSupport::register_type(participant, DataExchangeTypeSupport::get_type_name());
DDSTopic *ddstopic = participant->create_topic(
topic.c_str(),
DataExchangeTypeSupport::get_type_name(),
DDS_TOPIC_QOS_DEFAULT,
NULL, /* listener */
DDS_STATUS_MASK_NONE);
if(ddstopic == NULL) {
std::cout << "Publisher: Error while creating topic: " << topic << std::endl;
std::cout << "With typename: " << DataExchangeTypeSupport::get_type_name() << std::endl;
}
DDSPublisher *publisher = participant->create_publisher(
DDS_PUBLISHER_QOS_DEFAULT,
NULL, /* listener */
DDS_STATUS_MASK_NONE);
if(publisher == NULL) {
std::cout << "Error while creating publisher" << std::endl;
}
DDSDataWriter *dataWriter = publisher->create_datawriter(
ddstopic,
DDS_DATAWRITER_QOS_DEFAULT,
NULL, /* listener */
DDS_STATUS_MASK_NONE);
if(dataWriter == NULL) {
std::cout << "Error while creating dataWriter" << std::endl;
}
DataExchangeDataWriter *dataExchangeWriter = NULL;
dataExchangeWriter = DataExchangeDataWriter::narrow(dataWriter);
DDS_Duration_t disc_period = {1,0};
NDDSUtility::sleep(disc_period);
DataExchange *instance = NULL;
instance = DataExchangeTypeSupport::create_data_ex(DDS_BOOLEAN_FALSE);
int rows = 1024;
int cols = 1024;
DDS_UnsignedShortSeq_ensure_length(&instance->pixels, rows*cols, MAX_PIXELS_SEQUENCE_LENGTH);
for (int i = 0; i < rows*cols; ++i) {
instance->pixels[i] = i;
}
std::cout << "Sending dataaa...";
instance->rows = rows;
instance->cols = cols;
dataExchangeWriter->write(*instance, DDS_HANDLE_NIL);
std::cout << " DONE!" << std::endl;
}
