HelloWorld_subscriber.cpp

RTI Data Distribution Service Subscription Example

The unmodified subscription example generated by rtiddsgen.

HelloWorld_subscriber.cpp

[$(NDDSHOME)/example/CPPCLI/helloWorld/HelloWorld_subscriber.cpp]

/* HelloWorld_subscriber.cpp

   A subscription example

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

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

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

   (1) Compile this file and the example publication.

   (2) Start the subscription on the same domain used for RTI Data Distribution
       Service with the command
       HelloWorld_subscriber <domain_id> <sample_count>

   (3) Start the publication on the same domain used for RTI Data Distribution
       with the command
       HelloWorld_publisher <domain_id> <sample_count>

   (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 publishers and subscribers programs, and can 
   add and remove them dynamically from the domain.
                                   
   Example:
        
       To run the example application on domain <domain_id>:
                          
       HelloWorld_publisher <domain_id> <sample_count>  
       HelloWorld_subscriber <domain_id> <sample_count>
*/

#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 HelloWorldSubscriber {
public:
    static void subscribe(int domain_id, int sample_count);

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

public ref class HelloWorldListener : public DDS::DataReaderListener {
  public:
    virtual void on_requested_deadline_missed(
        DDS::DataReader^ /*reader*/,
        DDS::RequestedDeadlineMissedStatus% /*status*/) override {}
    
    virtual void on_requested_incompatible_qos(
        DDS::DataReader^ /*reader*/,
        DDS::RequestedIncompatibleQosStatus^ /*status*/) override {}
    
    virtual void on_sample_rejected(
        DDS::DataReader^ /*reader*/,
        DDS::SampleRejectedStatus% /*status*/) override {}

    virtual void on_liveliness_changed(
        DDS::DataReader^ /*reader*/,
        DDS::LivelinessChangedStatus% /*status*/) override {}

    virtual void on_sample_lost(
        DDS::DataReader^ /*reader*/,
        DDS::SampleLostStatus% /*status*/) override {}

    virtual void on_subscription_matched(
        DDS::DataReader^ /*reader*/,
        DDS::SubscriptionMatchedStatus% /*status*/) override {}

    virtual void on_data_available(DDS::DataReader^ reader) override;

    HelloWorldListener() {
        data_seq = gcnew HelloWorldSeq();
        info_seq = gcnew DDS::SampleInfoSeq();
    }

  private:
    HelloWorldSeq^ data_seq;
    DDS::SampleInfoSeq^ info_seq;
};

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 {
        HelloWorldSubscriber::subscribe(
            domain_id, sample_count);
    }
    catch(DDS::Exception^) {
        return -1;
    }
    return 0;
}

void HelloWorldSubscriber::subscribe(
        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 subscriber QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    DDS::Subscriber^ subscriber = participant->create_subscriber(
        DDS::DomainParticipant::SUBSCRIBER_QOS_DEFAULT,
        nullptr /* listener */,
        DDS::StatusMask::STATUS_MASK_NONE);
    if (subscriber == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_subscriber error");
    }

    /* Register the type before creating the 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");
    }

    /* Create a data reader listener */
    HelloWorldListener^ reader_listener =
        gcnew HelloWorldListener();

    /* To customize the data reader QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    DDS::DataReader^ reader = subscriber->create_datareader(
        topic,
        DDS::Subscriber::DATAREADER_QOS_DEFAULT,
        reader_listener,
        DDS::StatusMask::STATUS_MASK_ALL);
    if (reader == nullptr) {
        shutdown(participant);
        throw gcnew ApplicationException("create_datareader error");
    }

    /* Main loop */
    const System::Int32 receive_period = 4000; // milliseconds
    for (int count=0; (sample_count == 0) || (count < sample_count); ++count) {
        Console::WriteLine(
            "HelloWorld subscriber sleeping for {0} sec...",
            receive_period / 1000);

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

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

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

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

    /* RTI Data Distribution Service provides finalize_instance() method on
       domain participant factory for users 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();
*/
}

void HelloWorldListener::on_data_available(DDS::DataReader^ reader) {
    HelloWorldDataReader^ HelloWorld_reader =
        safe_cast<HelloWorldDataReader^>(reader);

    try {
        HelloWorld_reader->take(
            data_seq,
            info_seq,
            DDS::ResourceLimitsQosPolicy::LENGTH_UNLIMITED,
            DDS::SampleStateKind::ANY_SAMPLE_STATE,
            DDS::ViewStateKind::ANY_VIEW_STATE,
            DDS::InstanceStateKind::ANY_INSTANCE_STATE);
    }
    catch(DDS::Retcode_NoData^) {
        return;
    }
    catch(DDS::Exception ^e) {
        Console::WriteLine("take error {0}", e);
        return;
    }

    System::Int32 data_length = data_seq->length;
    for (int i = 0; i < data_length; ++i) {
        if (info_seq->get_at(i)->valid_data) {
            HelloWorldTypeSupport::print_data(data_seq->get_at(i));
        }
    }

    try {
        HelloWorld_reader->return_loan(data_seq, info_seq);
    }
    catch(DDS::Exception ^e) {
        Console::WriteLine("return loan error {0}", e);
    }
}