/******************************************************************************* (c) 2005-2014 Copyright, Real-Time Innovations, Inc. All rights reserved. RTI grants Licensee a license to use, modify, compile, and create derivative works of the Software. Licensee has the right to distribute object form only for use with RTI products. The Software is provided "as is", with no warranty of any type, including any warranty for fitness for any purpose. RTI is under no obligation to maintain or support the Software. RTI shall not be liable for any incidental or consequential damages arising out of the use or inability to use the software. ******************************************************************************/ #include #include #include #include #include "msg.h" #include "application.h" /* We use the typecode from built-in listeners, so we don't need to include * this code*/ /* #include "msgSupport.h" #include "ndds/ndds_cpp.h" */ /* 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. */ using namespace application; static int shutdown_participant( DDSDomainParticipant *participant, const char *shutdown_message, int status); class BuiltinPublicationListener : public DDSDataReaderListener { public: virtual void on_data_available(DDSDataReader *reader); }; void BuiltinPublicationListener::on_data_available(DDSDataReader *reader) { DDSPublicationBuiltinTopicDataDataReader *builtin_reader = (DDSPublicationBuiltinTopicDataDataReader *) reader; DDS_PublicationBuiltinTopicDataSeq data_seq; DDS_SampleInfoSeq info_seq; DDS_ReturnCode_t retcode; DDS_ExceptionCode_t exception_code; DDSSubscriber *subscriber = NULL; DDSDomainParticipant *participant = NULL; retcode = builtin_reader->take( data_seq, info_seq, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); if (retcode != DDS_RETCODE_OK) { printf("***Error: failed to access data from the built-in reader\n"); return; } std::cout << std::hex << std::setw(8) << std::setfill('0'); for (int i = 0; i < data_seq.length(); ++i) { if (info_seq[i].valid_data) { std::cout << "-----\nFound topic \"" << data_seq[i].topic_name << "\"\nparticipant: " << data_seq[i].participant_key.value[0] << data_seq[i].participant_key.value[1] << data_seq[i].participant_key.value[2] << "\ndatawriter: " << data_seq[i].key.value[0] << data_seq[i].key.value[1] << data_seq[i].key.value[2] << "\ntype:\n"; if (data_seq[i].type_code == NULL) { std::cerr << "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(). */ data_seq[i].type_code->print_IDL(2, exception_code); if (exception_code != DDS_NO_EXCEPTION_CODE) { std::cerr << "print_IDL returns exception code " << exception_code << std::endl; } } } builtin_reader->return_loan(data_seq, info_seq); } int run_subscriber_application( unsigned int domain_id, unsigned int sample_count) { struct DDS_Duration_t receive_period = { 1, 0 }; // Start communicating in a domain, usually one participant per application DDSDomainParticipant *participant = DDSTheParticipantFactory->create_participant( domain_id, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (participant == NULL) { return shutdown_participant( participant, "create_participant error", EXIT_FAILURE); } /* If you want to change the type_code_max_serialized_length * programmatically (e.g., to 3070) rather than using the XML file, you * will need to add the following lines to your code and comment out the * create_participant call above. */ /* DDS_DomainParticipantQos participant_qos; retcode = DDSTheParticipantFactory->get_default_participant_qos(participant_qos); if (retcode != DDS_RETCODE_OK) { std::cerr << "get_default_participant_qos error\n"; return EXIT_FAILURE; } participant_qos.resource_limits.type_code_max_serialized_length = 3070; DDSDomainParticipant *participant = DDSTheParticipantFactory->create_participant( domain_id, participant_qos, NULL, DDS_STATUS_MASK_NONE); if (participant == NULL) { return shutdown_participant( participant, "create_participant error", EXIT_FAILURE); } */ /* We don't actually care about receiving the samples, just the topic information. To do this, we only need the builtin datareader for publications. */ // First get the built-in subscriber DDSSubscriber *builtin_subscriber = participant->get_builtin_subscriber(); if (builtin_subscriber == NULL) { return shutdown_participant( participant, "Failed to create builtin subscriber", EXIT_FAILURE); } // Then get the data reader for the built-in subscriber DDSPublicationBuiltinTopicDataDataReader *builtin_publication_datareader = (DDSPublicationBuiltinTopicDataDataReader *) builtin_subscriber ->lookup_datareader(DDS_PUBLICATION_TOPIC_NAME); if (builtin_publication_datareader == NULL) { return shutdown_participant( participant, "Failed to create builtin publication data reader", EXIT_FAILURE); } // Finally install the listener BuiltinPublicationListener *builtin_publication_listener = new BuiltinPublicationListener(); builtin_publication_datareader->set_listener( builtin_publication_listener, DDS_DATA_AVAILABLE_STATUS); // Main loop. Wait for data to arrive, and process when it arrives // Main loop, write data for (unsigned int count = 0; !shutdown_requested && count < sample_count; ++count) { NDDSUtility::sleep(receive_period); } // Cleanup return shutdown_participant(participant, "Shutting down", 0); } // Delete all entities static int shutdown_participant( DDSDomainParticipant *participant, const char *shutdown_message, int status) { DDS_ReturnCode_t retcode; std::cout << shutdown_message << std::endl; if (participant != NULL) { // Cleanup everything created by this Participant retcode = participant->delete_contained_entities(); if (retcode != DDS_RETCODE_OK) { std::cerr << "delete_contained_entities error" << retcode << std::endl; status = EXIT_FAILURE; } retcode = DDSTheParticipantFactory->delete_participant(participant); if (retcode != DDS_RETCODE_OK) { std::cerr << "delete_participant error" << retcode << std::endl; status = EXIT_FAILURE; } } return status; } int main(int argc, char *argv[]) { // Parse arguments and handle control-C ApplicationArguments arguments; parse_arguments(arguments, argc, argv, subscriber); if (arguments.parse_result == PARSE_RETURN_EXIT) { return EXIT_SUCCESS; } else if (arguments.parse_result == PARSE_RETURN_FAILURE) { return EXIT_FAILURE; } setup_signal_handlers(); // Sets Connext verbosity to help debugging NDDSConfigLogger::get_instance()->set_verbosity(arguments.verbosity); int status = run_subscriber_application( arguments.domain_id, arguments.sample_count); // Releases the memory used by the participant factory. Optional at // application exit DDS_ReturnCode_t retcode = DDSDomainParticipantFactory::finalize_instance(); if (retcode != DDS_RETCODE_OK) { std::cerr << "finalize_instance error" << retcode << std::endl; status = EXIT_FAILURE; } return status; }