HelloWorld_publisher.cpp

RTI Connext Publication Example

The publication example generated by rtiddsgen. The example has been modified slightly to update the sample value.

HelloWorld_publisher.cpp

/*
* (c) Copyright, Real-Time Innovations, 2012.  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.
*/

/* HelloWorld_publisher.cpp

A publication of data of type HelloWorld

This file is derived from code automatically generated by the rtiddsgen 
command:

rtiddsgen -language C++/CLI -example <arch> HelloWorld.idl

Example publication of type HelloWorld automatically generated by 
'rtiddsgen'. To test it, follow these steps:

(1) Compile this file and the example subscription.

(2) Start the subscription

(3) Start the publication

(4) [Optional] Specify the list of discovery initial peers and 
multicast receive addresses via an environment variable or a file 
(in the current working directory) called NDDS_DISCOVERY_PEERS. 

You can run any number of publisher and subscriber programs, and can 
add and remove them dynamically from the domain.
*/

#ifndef IMPORT_HelloWorld
/* If this example code is packaged into an assembly other than that
* containing the generated types themselves, no header inclusion is
* necessary. In that case, simply define IMPORT_HelloWorld.
*/
#include "HelloWorldSupport.h"
#endif

using namespace System;

public ref class HelloWorldPublisher {
  public:
    static void publish(int domain_id, int sample_count);

  private:
    static void shutdown(
        DDS::DomainParticipant^ participant);
};

int main(array<System::String^>^ argv) {
    int domain_id = 0;
    if (argv->Length >= 1) {
        domain_id = Int32::Parse(argv[0]);
    }

    int sample_count = 0; /* infinite loop */
    if (argv->Length >= 2) {
        sample_count = Int32::Parse(argv[1]);
    }

    /* Uncomment this to turn on additional logging
    NDDS::ConfigLogger::get_instance()->set_verbosity_by_category(
        NDDS::LogCategory::NDDS_CONFIG_LOG_CATEGORY_API, 
        NDDS::LogVerbosity::NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL);
    */
    try {
        HelloWorldPublisher::publish(
            domain_id, sample_count);
    }
    catch(DDS::Exception^) {
        return -1;
    }
    return 0;
}

void HelloWorldPublisher::publish(int domain_id, int sample_count) {

    /* To customize participant QoS, use 
    the configuration file USER_QOS_PROFILES.xml */
    DDS::DomainParticipant^ participant =
    DDS::DomainParticipantFactory::get_instance()->create_participant(
        domain_id,
        DDS::DomainParticipantFactory::PARTICIPANT_QOS_DEFAULT, 
        nullptr /* listener */,
        DDS::StatusMask::STATUS_MASK_NONE);
    if (participant == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_participant error");
    }

    /* To customize publisher QoS, use 
    the configuration file USER_QOS_PROFILES.xml */
    DDS::Publisher^ publisher = participant->create_publisher(
        DDS::DomainParticipant::PUBLISHER_QOS_DEFAULT,
        nullptr /* listener */,
        DDS::StatusMask::STATUS_MASK_NONE);
    if (publisher == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_publisher error");
    }

    /* Register type before creating topic */
    System::String^ type_name = HelloWorldTypeSupport::get_type_name();
    try {
        HelloWorldTypeSupport::register_type(
            participant, type_name);
    } catch (DDS::Exception^ e) {
        shutdown(participant);
        throw e;
    }

    /* To customize topic QoS, use 
    the configuration file USER_QOS_PROFILES.xml */
    DDS::Topic^ topic = participant->create_topic(
        "Example HelloWorld",
        type_name,
        DDS::DomainParticipant::TOPIC_QOS_DEFAULT,
        nullptr /* listener */,
        DDS::StatusMask::STATUS_MASK_NONE);
    if (topic == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_topic error");
    }

    /* To customize data writer QoS, use 
    the configuration file USER_QOS_PROFILES.xml */
    DDS::DataWriter^ writer = publisher->create_datawriter(
        topic,
        DDS::Publisher::DATAWRITER_QOS_DEFAULT,
        nullptr /* listener */,
        DDS::StatusMask::STATUS_MASK_NONE);
    if (writer == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_datawriter error");
    }
    HelloWorldDataWriter^ HelloWorld_writer =
    safe_cast<HelloWorldDataWriter^>(writer);

    /* Create data sample for writing */
    HelloWorld^ instance = HelloWorldTypeSupport::create_data();
    if (instance == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException(
            "HelloWorldTypeSupport::create_data error");
    }

    /* For a data type that has a key, if the same instance is going to be
    written multiple times, initialize the key here
    and register the keyed instance prior to writing */
    DDS::InstanceHandle_t instance_handle = DDS::InstanceHandle_t::HANDLE_NIL;
    /*
    instance_handle = HelloWorld_writer->register_instance(instance);
    */

    /* Main loop */
    const System::Int32 send_period = 4000; // milliseconds
    for (int count=0; (sample_count == 0) || (count < sample_count); ++count) {
        Console::WriteLine("Writing HelloWorld, count {0}", count);

        /* Modify the data to be sent here */

        try {
            HelloWorld_writer->write(instance, instance_handle);
        }
        catch(DDS::Exception ^e) {
            Console::WriteLine("write error: {0}", e);
        }

        System::Threading::Thread::Sleep(send_period);
    }

    /*
    try {
        HelloWorld_writer->unregister_instance(
            instance, instance_handle);
    }
    catch(DDS::Exception ^e) {
        Console::WriteLine("unregister instance error: {0}", e);
    }
    */

    /* Delete data sample */
    try {
        HelloWorldTypeSupport::delete_data(instance);
    }
    catch(DDS::Exception ^e) {
        Console::WriteLine("HelloWorldTypeSupport::delete_data error: {0}", e);
    }

    /* Delete all entities */
    shutdown(participant);
}

/* Delete all entities */
void HelloWorldPublisher::shutdown(
    DDS::DomainParticipant^ participant) {

    if (participant != nullptr) {
        participant->delete_contained_entities();
        DDS::DomainParticipantFactory::get_instance()->delete_participant(participant);
    }

    /* RTI Connext provides finalize_instance() method on
    domain participant factory for people who want to release memory used
    by the participant factory. Uncomment the following block of code for
    clean destruction of the singleton. */
    /*
    DDS::DomainParticipantFactory::finalize_instance();
    */
}