Fix rticommunity#551 Adds C++98 example

examples/connext_dds/CMakeLists.txt

@@ -59,6 +59,7 @@ if(NOT DEFINED CONNEXTDDS_CONNEXT_DDS_EXAMPLES)
         "asynchronous_publication"
         "asyncwaitset"
         "batching"
+        "build_systems/cmake"
         "builtin_qos_profiles"
         "builtin_topics"
         "coherent_presentation"

examples/connext_dds/build_systems/cmake/c++98/CMakeLists.txt

@@ -0,0 +1,111 @@
+# (c) 2019 Copyright, Real-Time Innovations, Inc. All rights reserved.
+# No duplications, whole or partial, manual or electronic, may be made
+# without express written permission.  Any such copies, or revisions thereof,
+# must display this notice unaltered.
+# This code contains trade secrets of Real-Time Innovations, Inc.
+
+cmake_minimum_required(VERSION 3.11)
+project(rtiexamples-hello-world)
+
+# Add the folder where the FindRTIConnextDDS.cmake file is placed to the
+# CMAKE_MODULE_PATH variable
+list(APPEND CMAKE_MODULE_PATH
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../resources/cmake/Modules"
+)
+include(ConnextDdsConfigureCmakeUtils)
+connextdds_configure_cmake_utils()
+
+# Find the ConnextDDS libraries. This will look fo the core and API libraries
+# only
+find_package(RTIConnextDDS
+    "7.0.0"
+    REQUIRED
+    COMPONENTS
+        core
+)
+
+# Run Codegen to generate the source code files for the types
+include(ConnextDdsCodegen)
+connextdds_rtiddsgen_run(
+    IDL_FILE
+        "${CMAKE_CURRENT_SOURCE_DIR}/HelloWorld.idl"
+    OUTPUT_DIRECTORY
+        "${CMAKE_CURRENT_BINARY_DIR}/src"
+    LANG C++98
+)
+
+add_custom_target(codegen_sources
+    DEPENDS
+        ${HelloWorld_CXX98_SOURCES}
+)
+
+# Create the target for the publisher executable
+add_executable(HelloWorld_publisher
+    "${CMAKE_CURRENT_SOURCE_DIR}/HelloWorld_publisher.cxx"
+    ${HelloWorld_CXX98_SOURCES}
+)
+
+# Link against the ConnextDDS libraries
+target_link_libraries(
+    HelloWorld_publisher
+    PRIVATE
+        RTIConnextDDS::cpp_api
+)
+
+# Include the folder with the type header files
+target_include_directories(HelloWorld_publisher
+    PRIVATE
+    "${CMAKE_CURRENT_BINARY_DIR}/src"
+)
+
+# Create the target for the subscriber executable
+add_executable(HelloWorld_subscriber
+    "${CMAKE_CURRENT_SOURCE_DIR}/HelloWorld_subscriber.cxx"
+    ${HelloWorld_CXX98_SOURCES}
+)
+
+# Link against the ConnextDDS libraries
+target_link_libraries(
+    HelloWorld_subscriber
+    PRIVATE
+        RTIConnextDDS::cpp_api
+)
+# Include the folder with the type header files
+target_include_directories(HelloWorld_subscriber
+    PRIVATE
+    "${CMAKE_CURRENT_BINARY_DIR}/src"
+)
+
+
+# Copy the USER_QOS_PROFILES.xml
+add_custom_target(copy_qos
+    DEPENDS
+        "${CMAKE_CURRENT_BINARY_DIR}/USER_QOS_PROFILES.xml"
+)
+
+add_custom_command(
+    OUTPUT
+        "${CMAKE_CURRENT_BINARY_DIR}/USER_QOS_PROFILES.xml"
+    COMMAND
+        ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_CURRENT_SOURCE_DIR}/USER_QOS_PROFILES.xml"
+            "${CMAKE_CURRENT_BINARY_DIR}"
+    COMMENT "Copying USER_QOS_PROFILES.xml"
+    DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/USER_QOS_PROFILES.xml"
+    VERBATIM
+)
+
+# Copy the USER_QOS_PROFILES.XML when the publisher is built and ensure
+# Codegen is called
+add_dependencies(HelloWorld_publisher
+    copy_qos
+    codegen_sources
+)
+
+# Copy the USER_QOS_PROFILES.XML when the subscriber is built and ensure
+# Codegen is called
+add_dependencies(HelloWorld_subscriber
+    copy_qos
+    codegen_sources
+)

examples/connext_dds/build_systems/cmake/c++98/HelloWorld.idl

@@ -0,0 +1,15 @@
+/*
+ * (c) 2019 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.
+ */
+
+struct HelloWorld {
+    char a;
+};

examples/connext_dds/build_systems/cmake/c++98/HelloWorld_publisher.cxx

@@ -0,0 +1,183 @@
+/*
+* (c) Copyright, Real-Time Innovations, 2020.  All rights reserved.
+* RTI grants Licensee a license to use, modify, compile, and create derivative
+* works of the software solely for use with RTI Connext DDS. Licensee may
+* redistribute copies of the software provided that all such copies are subject
+* to this license. 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 <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "HelloWorld.h"
+#include "HelloWorldSupport.h"
+#include "ndds/ndds_cpp.h"
+#include "application.h"
+
+using namespace application;
+
+static int shutdown_participant(
+    DDSDomainParticipant *participant,
+    const char *shutdown_message,
+    int status);
+
+int run_publisher_application(unsigned int domain_id, unsigned int sample_count)
+{
+    // Start communicating in a domain, usually one participant per application
+    DDSDomainParticipant *participant =
+    DDSTheParticipantFactory->create_participant(
+        domain_id,
+        DDS_PARTICIPANT_QOS_DEFAULT,
+        NULL /* listener */,
+        DDS_STATUS_MASK_NONE);
+    if (participant == NULL) {
+        return shutdown_participant(participant, "create_participant error", EXIT_FAILURE);
+    }
+
+    // A Publisher allows an application to create one or more DataWriters
+    DDSPublisher *publisher = participant->create_publisher(
+        DDS_PUBLISHER_QOS_DEFAULT,
+        NULL /* listener */,
+        DDS_STATUS_MASK_NONE);
+    if (publisher == NULL) {
+        return shutdown_participant(participant, "create_publisher error", EXIT_FAILURE);
+    }
+
+    // Register the datatype to use when creating the Topic
+    const char *type_name = HelloWorldTypeSupport::get_type_name();
+    DDS_ReturnCode_t retcode =
+    HelloWorldTypeSupport::register_type(participant, type_name);
+    if (retcode != DDS_RETCODE_OK) {
+        return shutdown_participant(participant, "register_type error", EXIT_FAILURE);
+    }
+
+    // Create a Topic with a name and a datatype
+    DDSTopic *topic = participant->create_topic(
+        "Example HelloWorld",
+        type_name,
+        DDS_TOPIC_QOS_DEFAULT,
+        NULL /* listener */,
+        DDS_STATUS_MASK_NONE);
+    if (topic == NULL) {
+        return shutdown_participant(participant, "create_topic error", EXIT_FAILURE);
+    }
+
+    // This DataWriter writes data on "Example HelloWorld" Topic
+    DDSDataWriter *untyped_writer = publisher->create_datawriter(
+        topic,
+        DDS_DATAWRITER_QOS_DEFAULT,
+        NULL /* listener */,
+        DDS_STATUS_MASK_NONE);
+    if (untyped_writer == NULL) {
+        return shutdown_participant(participant, "create_datawriter error", EXIT_FAILURE);
+    }
+
+    // Narrow casts from an untyped DataWriter to a writer of your type 
+    HelloWorldDataWriter *typed_writer =
+    HelloWorldDataWriter::narrow(untyped_writer);
+    if (typed_writer == NULL) {
+        return shutdown_participant(participant, "DataWriter narrow error", EXIT_FAILURE);
+    }
+
+    // Create data for writing, allocating all members
+    HelloWorld *data = HelloWorldTypeSupport::create_data();
+    if (data == NULL) {
+        return shutdown_participant(
+            participant,
+            "HelloWorldTypeSupport::create_data error",
+            EXIT_FAILURE);
+    }
+
+    // Main loop, write data
+    for (unsigned int samples_written = 0;
+    !shutdown_requested && samples_written < sample_count;
+    ++samples_written) {
+
+        // Modify the data to be written here
+
+        std::cout << "Writing HelloWorld, count " << samples_written 
+        << std::endl;
+        retcode = typed_writer->write(*data, DDS_HANDLE_NIL);
+        if (retcode != DDS_RETCODE_OK) {
+            std::cerr << "write error " << retcode << std::endl;
+        }
+
+        // Send once every second
+        DDS_Duration_t send_period = { 1, 0 };
+        NDDSUtility::sleep(send_period);
+    }
+
+    // Delete previously allocated HelloWorld, including all contained elements
+    retcode = HelloWorldTypeSupport::delete_data(data);
+    if (retcode != DDS_RETCODE_OK) {
+        std::cerr << "HelloWorldTypeSupport::delete_data error " << retcode
+        << std::endl;
+    }
+
+    // Delete all entities (DataWriter, Topic, Publisher, DomainParticipant)
+    return shutdown_participant(participant, "Shutting down", EXIT_SUCCESS);
+}
+
+// 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);
+    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_publisher_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;
+}
+