HelloWorld_publisher.c

[$(NDDSHOME)/example/C/helloWorldTCP/HelloWorld_publisher.c]

/* HelloWorld_publisher.c
 
   A publication of data of type HelloWorld
 
   This file is derived from code automatically generated by the rtiddsgen 
   command:
 
   rtiddsgen -language C -example <arch> HelloWorld.idl
 
   Example publication of type HelloWorld automatically generated by 
   'rtiddsgen'. To test them follow these steps:
 
   (1) Compile this file and the example subscription.
 
   (2) Start the subscription on the same domain used for RTI Connext
       with the command
       objs/<arch>/HelloWorld_subscriber <domain_id> <sample_count>
 
   (3) Start the publication on the same domain used for RTI Connext
       with the command
       objs/<arch>/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>:
                                  
       On Unix: 
       
       objs/<arch>/HelloWorld_publisher <arguments> 
       objs/<arch>/HelloWorld_subscriber <arguments> 
                            
       On Windows:
       
       objs<arch>\HelloWorld_publisher <arguments>  
       objs<arch>\HelloWorld_subscriber <arguments>   
 
       Use the option '--help' to print a list of all
       the accepted command-line options.
       
       
modification history
------------ -------       
*/
 
#include <stdio.h>
#include <stdlib.h>
#include "ndds/ndds_c.h"
#include "HelloWorld.h"
#include "HelloWorldSupport.h"
#include "HelloCommon.h"
 
 
int RTI_SNPRINTF (
   char *buffer,
   size_t count,
   const char *format, ...)
{
    int length;
    va_list ap;
    va_start(ap, format);
#ifdef WIN32
    length = _vsnprintf_s(buffer, count, count, format, ap);
#else
    length = vsnprintf(buffer, count, format, ap);
#endif
     va_end(ap);
     return length;
}
 
/* Delete all entities */
static int publisher_shutdown(
    DDS_DomainParticipant *participant)
{
    DDS_ReturnCode_t retcode;
    int status = 0;
 
    if (participant != NULL) {
        retcode = DDS_DomainParticipant_delete_contained_entities(participant);
        if (retcode != DDS_RETCODE_OK) {
            fprintf(stderr, "delete_contained_entities error %d\n", retcode);
            status = -1;
        }
 
        retcode = DDS_DomainParticipantFactory_delete_participant(
            DDS_TheParticipantFactory, participant);
        if (retcode != DDS_RETCODE_OK) {
            fprintf(stderr, "delete_participant error %d\n", retcode);
            status = -1;
        }
    }
 
    /* 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. */
/*
    retcode = DDS_DomainParticipantFactory_finalize_instance();
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr, "finalize_instance error %d\n", retcode);
        status = -1;
    }
*/
 
    return status;
}
 
static int publisher_main(const struct CmdLineArgs * const args)
{
    DDS_DomainParticipant *participant = NULL;
    DDS_Publisher *publisher = NULL;
    DDS_Topic *topic = NULL;
    DDS_DataWriter *writer = NULL;
    HelloWorldDataWriter *HelloWorld_writer = NULL;
    HelloWorld *instance = NULL;
    DDS_ReturnCode_t retcode;
    DDS_InstanceHandle_t instance_handle = DDS_HANDLE_NIL;
    struct DDS_DomainParticipantQos domain_participant_qos =
            DDS_DomainParticipantQos_INITIALIZER;
    const char *type_name = NULL;
    int count = 0;
    struct DDS_Duration_t send_period = {4,0};
    int result = -1;
 
    retcode = DDS_DomainParticipantFactory_get_default_participant_qos(
            DDS_TheParticipantFactory,
            &domain_participant_qos);
 
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr, "get_default_participant_qos error\n");
        goto done;
    }
 
    /* Now we configure the TCP transport */
    retcode = configureTcpTransport(args, &domain_participant_qos);
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr, "assert_property error\n");
        goto done;
    }
 
    participant = DDS_DomainParticipantFactory_create_participant(
            DDS_TheParticipantFactory,
            args->domain_id,
            &domain_participant_qos,
            NULL /* listener */,
            DDS_STATUS_MASK_NONE);
    if (participant == NULL) {
        fprintf(stderr, "create_participant error\n");
        goto done;
    }
 
    /*
     * To customize publisher QoS, use
     * the configuration file USER_QOS_PROFILES.xml
     */
    publisher = DDS_DomainParticipant_create_publisher(
            participant,
            &DDS_PUBLISHER_QOS_DEFAULT,
            NULL /* listener */,
            DDS_STATUS_MASK_NONE);
    if (publisher == NULL) {
        fprintf(stderr, "create_publisher error\n");
        goto done;
    }
 
    /* Register type before creating topic */
    type_name = HelloWorldTypeSupport_get_type_name();
    retcode = HelloWorldTypeSupport_register_type(participant, type_name);
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr, "register_type error %d\n", retcode);
        goto done;
    }
 
    /*
     * To customize topic QoS, use
     * the configuration file USER_QOS_PROFILES.xml
     */
    topic = DDS_DomainParticipant_create_topic(
            participant,
            "Example HelloWorld",
            type_name,
            &DDS_TOPIC_QOS_DEFAULT,
            NULL /* listener */,
            DDS_STATUS_MASK_NONE);
    if (topic == NULL) {
        fprintf(stderr, "create_topic error\n");
        goto done;
    }
 
    /*
     * To customize data writer QoS, use
     * the configuration file USER_QOS_PROFILES.xml
     */
    writer = DDS_Publisher_create_datawriter(
            publisher,
            topic,
            &DDS_DATAWRITER_QOS_DEFAULT,
            NULL /* listener */,
            DDS_STATUS_MASK_NONE);
    if (writer == NULL) {
        fprintf(stderr, "create_datawriter error\n");
        goto done;
    }
    HelloWorld_writer = HelloWorldDataWriter_narrow(writer);
    if (HelloWorld_writer == NULL) {
        fprintf(stderr, "DataWriter narrow error\n");
        goto done;
    }
 
    /* Create data sample for writing */
    instance = HelloWorldTypeSupport_create_data_ex(DDS_BOOLEAN_TRUE);
    if (instance == NULL) {
        fprintf(stderr, "HelloWorldTypeSupport_create_data error\n");
        goto done;
    }
 
    /*
     * 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
     */
    /*
        instance_handle = HelloWorldDataWriter_register_instance(
            HelloWorld_writer, instance);
    */
 
    /* Main loop */
    for (count=0; (args->sample_count == 0) || (count < args->sample_count); ++count) {
        printf("Writing HelloWorld, count %d\n", count);
        fflush(stdout);
 
        /* Modify the data to be written here */
        RTI_SNPRINTF(instance->msg, 128, "Hello, this is sample #%d", count);
 
        /* Write data */
        retcode = HelloWorldDataWriter_write(
                HelloWorld_writer,
                instance,
                &instance_handle);
        if (retcode != DDS_RETCODE_OK) {
            fprintf(stderr, "write error %d\n", retcode);
        }
 
        NDDS_Utility_sleep(&send_period);
    }
 
    result = 0;
done:
    /*
        retcode = HelloWorldDataWriter_unregister_instance(
            HelloWorld_writer, instance, &instance_handle);
        if (retcode != DDS_RETCODE_OK) {
            fprintf(stderr, "unregister instance error %d\n", retcode);
        }
    */
 
    /* Delete data sample */
    retcode = HelloWorldTypeSupport_delete_data_ex(instance, DDS_BOOLEAN_TRUE);
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr, "HelloWorldTypeSupport_delete_data error %d\n", retcode);
        result = -1;
    }
 
    /* Cleanup and delete delete all entities */
    if (publisher_shutdown(participant) != 0) {
        fprintf(stderr, "publisher_shutdown error\n");
        result = -1;
    }
 
    /* Cleanup any resource allocated with Domain Participant QoS */
    retcode = DDS_DomainParticipantQos_finalize(&domain_participant_qos);
    if (retcode != DDS_RETCODE_OK) {
        fprintf(stderr,
                "DDS_DomainParticipantQos_finalize error %d\n",
                retcode);
        result = -1;
    }
 
    return result;
}
 
int main(int argc, const char **argv)
{
    struct CmdLineArgs args;
 
    if (!parseCmdline(&args, argc, argv)) {
        return 1;
    }
 
    if (args.verbose > 1) {
        /*
         NDDS_Config_Logger_set_verbosity_by_category(
            NDDS_Config_Logger_get_instance(),
            NDDS_CONFIG_LOG_CATEGORY_COMMUNICATION, 
            NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL);
        */
         NDDS_Config_Logger_set_verbosity(
            NDDS_Config_Logger_get_instance(),
            NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL);
    }
 
    return publisher_main(&args);
}