dds.h

Go to the documentation of this file.

/*****************************************************************
 *
 *   file:   dds.h
 *   desc:   This file provides the C language binding for CoreDX DDS.
 *
 *****************************************************************
 *
 *   Coypright(C) 2006-2011 Twin Oaks Computing, Inc
 *   All rights reserved.   Castle Rock, CO 80108
 *
 *****************************************************************
 *
 *  This software has been provided pursuant to a License Agreement
 *  containing restrictions on its use.  This software contains
 *  valuable trade secrets and proprietary information of
 *  Twin Oaks Computing, Inc and is protected by law.  It may not be
 *  copied or distributed in any form or medium, disclosed to third
 *  parties, reverse engineered or used in any manner not provided
 *  for in said License Agreement except with the prior written
 *  authorization from Twin Oaks Computing, Inc. 
 *
 *****************************************************************/
#ifndef _DDS_H
#define _DDS_H

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#include <dds/dds_types.h>
#include <dds/dds_export.h>
#include <dds/coredx_version.h>

#define DDS_DOMAINID_TYPE_NATIVE          unsigned int
#define DDS_HANDLE_TYPE_NATIVE            unsigned long
#define DDS_HANDLE_NIL_NATIVE             0
#define DDS_HANDLE_DEFAULT_NATIVE         1
#define DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE int

#define CDX_UNUSED(x) (void)(x)

  typedef unsigned char             DDS_Octet;
  typedef DDS_DOMAINID_TYPE_NATIVE  DDS_DomainId_t;
  typedef DDS_HANDLE_TYPE_NATIVE    DDS_InstanceHandle_t;

  typedef int                       DDS_ReturnCode_t;
  typedef int                       DDS_QosPolicyId_t;
  typedef unsigned int              DDS_SampleStateKind;
  typedef unsigned int              DDS_SampleStateMask;
  typedef unsigned int              DDS_ViewStateKind;
  typedef unsigned int              DDS_ViewStateMask;
  typedef unsigned int              DDS_InstanceStateKind;
  typedef unsigned int              DDS_InstanceStateMask;

  /* for IDL that references 'boolean', these are used: */
# define DDS_TRUE  1
# define DDS_FALSE 0

  typedef struct DDS_BuiltinTopicKey_t { 
    DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE value[3];
  } DDS_BuiltinTopicKey_t;

  typedef struct DDS_Duration_t
  { 
    int          sec; 
    unsigned int nanosec; 
  } DDS_Duration_t;
  
  typedef struct DDS_Time_t
  {
    int          sec; 
    unsigned int nanosec; 
  } DDS_Time_t;

  /*
   * Pre-defined values
   */
#define  DDS_LENGTH_UNLIMITED         (-1)

#define  DDS_DURATION_INFINITE_SEC    (0x7fffffff)
#define  DDS_DURATION_INFINITE_NSEC   (0xffffffff)
  
#define  DDS_DURATION_ZERO_SEC        ( 0 )
#define  DDS_DURATION_ZERO_NSEC       ( 0 )
  
#define  DDS_TIMESTAMP_INVALID_SEC    ( -1 )
#define  DDS_TIMESTAMP_INVALID_NSEC   ( 0xffffffff )
#define  DDS_TIMESTAMP_INVALID        { DDS_TIMESTAMP_INVALID_SEC, DDS_TIMESTAMP_INVALID_NSEC }

  /*
   * InstanceHandle codes
   */
  COREDX_C_API DDS_InstanceHandle_t DDS_HANDLE_NIL;
  COREDX_C_API DDS_InstanceHandle_t DDS_HANDLE_DEFAULT;          /* TOC, Inc defined */
  COREDX_C_API DDS_InstanceHandle_t DDS_HANDLE_NOT_ENABLED;      /* TOC, Inc defined */

  /*
   * Return codes
   */
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_OK;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_ERROR;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_UNSUPPORTED;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_BAD_PARAMETER;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_PRECONDITION_NOT_MET;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_OUT_OF_RESOURCES;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_NOT_ENABLED;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_IMMUTABLE_POLICY;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_INCONSISTENT_POLICY;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_ALREADY_DELETED;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_TIMEOUT;
  COREDX_C_API DDS_ReturnCode_t DDS_RETCODE_NO_DATA;


#define  DDS_READ_SAMPLE_STATE                     ( 0x0001 )
#define  DDS_NOT_READ_SAMPLE_STATE                 ( 0x0002 )
#define  DDS_ANY_SAMPLE_STATE                      ( 0x00FF )
  
#define  DDS_NEW_VIEW_STATE                        ( 0x0001 )
#define  DDS_NOT_NEW_VIEW_STATE                    ( 0x0002 )
#define  DDS_ANY_VIEW_STATE                        ( 0x00FF )
  
  /* Instance states to support reads */
#define  DDS_ALIVE_INSTANCE_STATE                  ( 0x0001 )
#define  DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE     ( 0x0002 )
#define  DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE   ( 0x0004 )
  
  /* This is a bit-mask InstanceStateKind */
#define  DDS_NOT_ALIVE_INSTANCE_STATE              ( 0x0006 )
#define  DDS_ANY_INSTANCE_STATE                    ( 0x00FF )

  /*
   * Status to support listeners and conditions
   */
  typedef unsigned int DDS_StatusKind;
  typedef unsigned int DDS_StatusMask;    /* bit-mask StatusKind */
  
  COREDX_C_API DDS_StatusKind DDS_INCONSISTENT_TOPIC_STATUS;
  COREDX_C_API DDS_StatusKind DDS_OFFERED_DEADLINE_MISSED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_REQUESTED_DEADLINE_MISSED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_OFFERED_INCOMPATIBLE_QOS_STATUS;
  COREDX_C_API DDS_StatusKind DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS;
  COREDX_C_API DDS_StatusKind DDS_SAMPLE_LOST_STATUS;
  COREDX_C_API DDS_StatusKind DDS_SAMPLE_REJECTED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_DATA_ON_READERS_STATUS;
  COREDX_C_API DDS_StatusKind DDS_DATA_AVAILABLE_STATUS;
  COREDX_C_API DDS_StatusKind DDS_LIVELINESS_LOST_STATUS;
  COREDX_C_API DDS_StatusKind DDS_LIVELINESS_CHANGED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_PUBLICATION_MATCHED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_SUBSCRIPTION_MATCHED_STATUS;
  COREDX_C_API DDS_StatusKind DDS_ALL_STATUS;
  
  /***********************************************************
   *     SampleInfo                                          *
   ***********************************************************/
  typedef struct DDS_SampleInfo 
  {
    DDS_SampleStateKind     sample_state; 
    DDS_ViewStateKind       view_state;   
    DDS_InstanceStateKind   instance_state; 
    DDS_Time_t              source_timestamp; 
    DDS_Time_t              reception_timestamp; 
    DDS_InstanceHandle_t    instance_handle;  
    DDS_InstanceHandle_t    publication_handle;
    int                     disposed_generation_count; 
    int                     no_writers_generation_count;
    int                     sample_rank;
    int                     generation_rank;
    int                     absolute_generation_rank;
    unsigned char           valid_data;
  } DDS_SampleInfo ;

  
  /***********************************************************
   *     STATUS types                                        *
   ***********************************************************/
  typedef struct DDS_InconsistentTopicStatus
  {
    int     total_count;           
    int     total_count_change;    
  } DDS_InconsistentTopicStatus;

  typedef struct DDS_SampleLostStatus
  {
    int     total_count;           
    int     total_count_change;    
  } DDS_SampleLostStatus;          

  typedef enum DDS_SampleRejectedStatusKind
    {
      DDS_NOT_REJECTED,
      DDS_REJECTED_BY_INSTANCE_LIMIT,
      DDS_REJECTED_BY_SAMPLES_LIMIT,
      DDS_REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT
    } DDS_SampleRejectedStatusKind;

  typedef struct DDS_SampleRejectedStatus
  {
    int     total_count;                       
    int     total_count_change;                
    DDS_SampleRejectedStatusKind last_reason;  
    DDS_InstanceHandle_t last_instance_handle; 
  } DDS_SampleRejectedStatus;

  typedef struct DDS_LivelinessLostStatus
  { 
    int     total_count;             
    int     total_count_change;      
  } DDS_LivelinessLostStatus;

  typedef struct DDS_LivelinessChangedStatus
  {
    int     alive_count;                 
    int     not_alive_count;             
    int     alive_count_change;          
    int     not_alive_count_change;      
    DDS_InstanceHandle_t last_publication_handle; 
  } DDS_LivelinessChangedStatus;

  typedef struct DDS_OfferedDeadlineMissedStatus
  {
    int     total_count;           
    int     total_count_change;    
    DDS_InstanceHandle_t last_instance_handle; 
  } DDS_OfferedDeadlineMissedStatus;
  typedef struct DDS_RequestedDeadlineMissedStatus
  {
    int     total_count;         
    int     total_count_change;  
    DDS_InstanceHandle_t last_instance_handle; 
  } DDS_RequestedDeadlineMissedStatus;

  typedef struct DDS_QosPolicyCount {
    DDS_QosPolicyId_t policy_id;
    int     count;
  } DDS_QosPolicyCount;

  DECLARE_SEQ(DDS_QosPolicyCount*, DDS_QosPolicyCountSeq);

  typedef struct DDS_OfferedIncompatibleQosStatus 
  {
    int     total_count;            
    int     total_count_change;     
    DDS_QosPolicyId_t last_policy_id;  
    DDS_QosPolicyCountSeq policies;    
  } DDS_OfferedIncompatibleQosStatus; 

  typedef struct DDS_RequestedIncompatibleQosStatus
  {
    int     total_count;                
    int     total_count_change;         
    DDS_QosPolicyId_t last_policy_id;   
    DDS_QosPolicyCountSeq policies;     
  } DDS_RequestedIncompatibleQosStatus; 

  typedef struct DDS_PublicationMatchedStatus
  {
    int     total_count;           
    int     total_count_change;    
    int     current_count;         
    int     current_count_change;  
    DDS_InstanceHandle_t last_subscription_handle;  
  } DDS_PublicationMatchedStatus;

  typedef struct DDS_SubscriptionMatchedStatus
  {
    int     total_count;           
    int     total_count_change;    
    int     current_count;         
    int     current_count_change;  
    DDS_InstanceHandle_t last_publication_handle;  
  } DDS_SubscriptionMatchedStatus;

  /***********************************************************
   *     Fundamental DDS Object types (Opaque)               *
   ***********************************************************/
  typedef struct _DomainParticipantFactory  * DDS_DomainParticipantFactory;
  typedef struct _Entity                    * DDS_Entity;
  typedef struct _DomainParticipant         * DDS_DomainParticipant;
  typedef struct _Publisher                 * DDS_Publisher;
  typedef struct _Subscriber                * DDS_Subscriber;
  typedef struct _DataReader                * DDS_DataReader;
  typedef struct _DataWriter                * DDS_DataWriter;
  typedef struct _TopicDescription          * DDS_TopicDescription;
  typedef struct _Topic                     * DDS_Topic;
  typedef struct _ContentFilteredTopic      * DDS_ContentFilteredTopic;
  typedef struct _MultiTopic                * DDS_MultiTopic;

  typedef struct _Condition                 * DDS_Condition;
  typedef struct _StatusCondition           * DDS_StatusCondition;
  typedef struct _ReadCondition             * DDS_ReadCondition;
  typedef struct _GuardCondition            * DDS_GuardCondition;
  typedef struct _QueryCondition            * DDS_QueryCondition;
  typedef struct _WaitSet                   * DDS_WaitSet;
  typedef struct _TypeSupport               * DDS_TypeSupport;

  /* Builtin Topic Data Types */
  typedef struct DDS_DCPSParticipant          DDS_ParticipantBuiltinTopicData;
  typedef struct DDS_DCPSTopic                DDS_TopicBuiltinTopicData;
  typedef struct DDS_DCPSPublication          DDS_PublicationBuiltinTopicData;
  typedef struct DDS_DCPSSubscription         DDS_SubscriptionBuiltinTopicData;
  
  /***********************************************************
   *            Common Sequence Types                        *
   ***********************************************************/

  DECLARE_SEQ( DDS_SampleInfo *,            DDS_SampleInfoSeq );
  DECLARE_SEQ(        char*,                DDS_StringSeq); 
  DECLARE_SEQ( DDS_Octet,                   DDS_OctetSeq);
  DECLARE_SEQ( DDS_DataWriter,              DDS_DataWriterSeq );
  DECLARE_SEQ( DDS_DataReader,              DDS_DataReaderSeq );
  DECLARE_SEQ( DDS_InstanceHandle_t,        DDS_InstanceHandleSeq); 
  DECLARE_SEQ(        void*,                DDS_PointerSeq);
  DECLARE_SEQ( DDS_Condition,               DDS_ConditionSeq );

  COREDX_C_API DDS_SampleInfoSeq     * DDS_SampleInfoSeq__alloc(void);
  COREDX_C_API DDS_StringSeq         * DDS_StringSeq__alloc(void);
  COREDX_C_API DDS_DataWriterSeq     * DDS_DataWriterSeq__alloc(void);
  COREDX_C_API DDS_DataReaderSeq     * DDS_DataReaderSeq__alloc(void);
  COREDX_C_API DDS_InstanceHandleSeq * DDS_InstanceHandleSeq__alloc(void);
  COREDX_C_API DDS_PointerSeq        * DDS_PointerSeq__alloc(void);
  COREDX_C_API DDS_ConditionSeq      * DDS_ConditionSeq__alloc(void);

  /***********************************************************
   *            Listeners                                    *
   ***********************************************************/
  typedef struct DDS_TopicListener
  {
    void (*on_inconsistent_topic)(DDS_Topic the_topic, 
                                  DDS_InconsistentTopicStatus status); 

  } DDS_TopicListener;
  typedef struct DDS_TopicListener_cd
  {
    void (*on_inconsistent_topic)(struct DDS_TopicListener_cd * self, 
                                  DDS_Topic                     the_topic, 
                                  DDS_InconsistentTopicStatus   status, 
                                  void                        * callback_data); 

  } DDS_TopicListener_cd;
  
  typedef struct DDS_DataWriterListener
  {
    void (*on_offered_deadline_missed)(DDS_DataWriter writer, 
                                       DDS_OfferedDeadlineMissedStatus status);
    void (*on_offered_incompatible_qos)(DDS_DataWriter writer, 
                                        DDS_OfferedIncompatibleQosStatus status);
    void (*on_liveliness_lost)(DDS_DataWriter writer,
                               DDS_LivelinessLostStatus status);
    void (*on_publication_matched)(DDS_DataWriter writer, 
                                   DDS_PublicationMatchedStatus status);
  } DDS_DataWriterListener;
  typedef struct DDS_DataWriterListener_cd
  {
    void (*on_offered_deadline_missed)(struct DDS_DataWriterListener_cd  * self,
                                       DDS_DataWriter                      writer, 
                                       DDS_OfferedDeadlineMissedStatus     status,
                                       void                              * callback_data);
    void (*on_offered_incompatible_qos)(struct DDS_DataWriterListener_cd  * self,
                                        DDS_DataWriter                      writer, 
                                        DDS_OfferedIncompatibleQosStatus    status,
                                        void                              * callback_data);
    void (*on_liveliness_lost)(struct DDS_DataWriterListener_cd  * self,
                               DDS_DataWriter                      writer,
                               DDS_LivelinessLostStatus            status,
                               void                              * callback_data);
    void (*on_publication_matched)(struct DDS_DataWriterListener_cd  * self,
                                   DDS_DataWriter                      writer, 
                                   DDS_PublicationMatchedStatus        status,
                                   void                              * callback_data);
  } DDS_DataWriterListener_cd;

  typedef struct DDS_PublisherListener
  {
    void (*on_offered_deadline_missed)(DDS_DataWriter writer, 
                                       DDS_OfferedDeadlineMissedStatus status);
    void (*on_offered_incompatible_qos)(DDS_DataWriter writer, 
                                        DDS_OfferedIncompatibleQosStatus status);
    void (*on_liveliness_lost)(DDS_DataWriter writer,
                               DDS_LivelinessLostStatus status);
    void (*on_publication_matched)(DDS_DataWriter writer, 
                                   DDS_PublicationMatchedStatus status);
  } DDS_PublisherListener;
  typedef struct DDS_PublisherListener_cd
  {
    void (*on_offered_deadline_missed)(struct DDS_PublisherListener_cd * self, 
                                       DDS_DataWriter                    writer, 
                                       DDS_OfferedDeadlineMissedStatus   status, 
                                       void                            * callback_data);
    void (*on_offered_incompatible_qos)(struct DDS_PublisherListener_cd * self, 
                                        DDS_DataWriter                    writer, 
                                        DDS_OfferedIncompatibleQosStatus  status, 
                                        void                            * callback_data);
    void (*on_liveliness_lost)(struct DDS_PublisherListener_cd * self, 
                               DDS_DataWriter                    writer,
                               DDS_LivelinessLostStatus          status, 
                               void                            * callback_data);
    void (*on_publication_matched)(struct DDS_PublisherListener_cd * self, 
                                   DDS_DataWriter                    writer, 
                                   DDS_PublicationMatchedStatus      status, 
                                   void                            * callback_data);
  } DDS_PublisherListener_cd;

  typedef struct DDS_DataReaderListener
  {
    void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
                                         DDS_RequestedDeadlineMissedStatus status);
    void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
                                          DDS_RequestedIncompatibleQosStatus status);
    void (*on_sample_rejected)(DDS_DataReader the_reader, 
                               DDS_SampleRejectedStatus status);
    void (*on_liveliness_changed)(DDS_DataReader the_reader,
                                  DDS_LivelinessChangedStatus status);
    void (*on_data_available)(DDS_DataReader the_reader);
    void (*on_subscription_matched)(DDS_DataReader the_reader, 
                                    DDS_SubscriptionMatchedStatus status);
    void (*on_sample_lost)(DDS_DataReader the_reader, 
                           DDS_SampleLostStatus status);
  } DDS_DataReaderListener;
  typedef struct DDS_DataReaderListener_cd
  {
    void (*on_requested_deadline_missed)(struct DDS_DataReaderListener_cd  * self,
                                         DDS_DataReader                      the_reader,
                                         DDS_RequestedDeadlineMissedStatus   status, 
                                         void                              * callback_data);
    void (*on_requested_incompatible_qos)(struct DDS_DataReaderListener_cd  * self,
                                          DDS_DataReader                      the_reader,
                                          DDS_RequestedIncompatibleQosStatus  status, 
                                          void                              * callback_data);
    void (*on_sample_rejected)(struct DDS_DataReaderListener_cd  * self,
                               DDS_DataReader                      the_reader, 
                               DDS_SampleRejectedStatus            status, 
                               void                              * callback_data);
    void (*on_liveliness_changed)(struct DDS_DataReaderListener_cd  * self,
                                  DDS_DataReader                      the_reader,
                                  DDS_LivelinessChangedStatus         status, 
                                  void                              * callback_data);
    void (*on_data_available)(struct DDS_DataReaderListener_cd  * self,
                              DDS_DataReader                      the_reader, 
                              void                              * callback_data);
    void (*on_subscription_matched)(struct DDS_DataReaderListener_cd  * self,
                                    DDS_DataReader                      the_reader, 
                                    DDS_SubscriptionMatchedStatus       status, 
                                    void                              * callback_data);
    void (*on_sample_lost)(struct DDS_DataReaderListener_cd  * self,
                           DDS_DataReader                      the_reader, 
                           DDS_SampleLostStatus                status, 
                           void                              * callback_data);
  } DDS_DataReaderListener_cd;

  typedef struct  DDS_SubscriberListener  
  {
    void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
                                         DDS_RequestedDeadlineMissedStatus status);
    void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
                                          DDS_RequestedIncompatibleQosStatus status);
    void (*on_sample_rejected)(DDS_DataReader the_reader, 
                               DDS_SampleRejectedStatus status);
    void (*on_liveliness_changed)(DDS_DataReader the_reader,
                                  DDS_LivelinessChangedStatus status);
    void (*on_data_available)(DDS_DataReader the_reader);
    void (*on_subscription_matched)(DDS_DataReader the_reader, 
                                    DDS_SubscriptionMatchedStatus status);
    void (*on_sample_lost)(DDS_DataReader the_reader, 
                           DDS_SampleLostStatus status);
    void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
  } DDS_SubscriberListener;

  typedef struct DDS_SubscriberListener_cd
  {
    void (*on_requested_deadline_missed)(struct DDS_SubscriberListener_cd  * self, 
                                         DDS_DataReader                      the_reader,
                                         DDS_RequestedDeadlineMissedStatus   status, 
                                         void                              * callback_data);
    void (*on_requested_incompatible_qos)(struct DDS_SubscriberListener_cd  * self, 
                                          DDS_DataReader                      the_reader,
                                          DDS_RequestedIncompatibleQosStatus  status, 
                                          void                              * callback_data);
    void (*on_sample_rejected)(struct DDS_SubscriberListener_cd  * self, 
                               DDS_DataReader                      the_reader, 
                               DDS_SampleRejectedStatus            status, 
                               void                              * callback_data);
    void (*on_liveliness_changed)(struct DDS_SubscriberListener_cd  * self, 
                                  DDS_DataReader                      the_reader,
                                  DDS_LivelinessChangedStatus         status, 
                                  void                              * callback_data);
    void (*on_data_available)(struct DDS_SubscriberListener_cd  * self, 
                              DDS_DataReader                      the_reader, 
                              void                              * callback_data);
    void (*on_subscription_matched)(struct DDS_SubscriberListener_cd  * self, 
                                    DDS_DataReader                      the_reader, 
                                    DDS_SubscriptionMatchedStatus       status, 
                                    void                              * callback_data);
    void (*on_sample_lost)(struct DDS_SubscriberListener_cd  * self, 
                           DDS_DataReader                      the_reader, 
                           DDS_SampleLostStatus                status, 
                           void                              * callback_data);
    void (*on_data_on_readers)(struct DDS_SubscriberListener_cd  * self, 
                               DDS_Subscriber                      the_subscriber, 
                               void                              * callback_data);
  } DDS_SubscriberListener_cd;



  typedef struct  DDS_DomainParticipantListener
  {
    void (*on_inconsistent_topic)(DDS_Topic the_topic, 
                                  DDS_InconsistentTopicStatus status);
    void (*on_offered_deadline_missed)(DDS_DataWriter writer, 
                                       DDS_OfferedDeadlineMissedStatus status);
    void (*on_offered_incompatible_qos)(DDS_DataWriter writer, 
                                        DDS_OfferedIncompatibleQosStatus status);
    void (*on_liveliness_lost)(DDS_DataWriter writer, 
                               DDS_LivelinessLostStatus status);
    void (*on_publication_matched)(DDS_DataWriter writer, 
                                   DDS_PublicationMatchedStatus status);

    void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
                                         DDS_RequestedDeadlineMissedStatus status);
    void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
                                          DDS_RequestedIncompatibleQosStatus status);
    void (*on_sample_rejected)(DDS_DataReader the_reader, 
                               DDS_SampleRejectedStatus status);
    void (*on_liveliness_changed)(DDS_DataReader the_reader,
                                  DDS_LivelinessChangedStatus status);
    void (*on_data_available)(DDS_DataReader the_reader);
    void (*on_subscription_matched)(DDS_DataReader the_reader, 
                                    DDS_SubscriptionMatchedStatus status);
    void (*on_sample_lost)(DDS_DataReader the_reader, 
                           DDS_SampleLostStatus status);
    void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
  } DDS_DomainParticipantListener;


  typedef struct  DDS_DomainParticipantListener_cd
  {
    void (*on_inconsistent_topic)(struct DDS_DomainParticipantListener_cd * self, 
                                  DDS_Topic                   the_topic, 
                                  DDS_InconsistentTopicStatus status, 
                                  void                      * callback_data);
    void (*on_offered_deadline_missed)(struct DDS_DomainParticipantListener_cd * self, 
                                       DDS_DataWriter                    writer, 
                                       DDS_OfferedDeadlineMissedStatus   status, 
                                       void                            * callback_data);
    void (*on_offered_incompatible_qos)(struct DDS_DomainParticipantListener_cd * self, 
                                        DDS_DataWriter                     writer, 
                                        DDS_OfferedIncompatibleQosStatus   status, 
                                        void                             * callback_data);
    void (*on_liveliness_lost)(struct DDS_DomainParticipantListener_cd * self, 
                               DDS_DataWriter              writer, 
                               DDS_LivelinessLostStatus    status, 
                               void                      * callback_data);
    void (*on_publication_matched)(struct DDS_DomainParticipantListener_cd * self, 
                                   DDS_DataWriter                  writer, 
                                   DDS_PublicationMatchedStatus    status, 
                                   void                          * callback_data);

    void (*on_requested_deadline_missed)(struct DDS_DomainParticipantListener_cd * self, 
                                         DDS_DataReader                    the_reader,
                                         DDS_RequestedDeadlineMissedStatus status, 
                                         void                            * callback_data);
    void (*on_requested_incompatible_qos)(struct DDS_DomainParticipantListener_cd * self, 
                                          DDS_DataReader                     the_reader,
                                          DDS_RequestedIncompatibleQosStatus status, 
                                          void                             * callback_data);
    void (*on_sample_rejected)(struct DDS_DomainParticipantListener_cd * self, 
                               DDS_DataReader              the_reader, 
                               DDS_SampleRejectedStatus    status, 
                               void                      * callback_data);
    void (*on_liveliness_changed)(struct DDS_DomainParticipantListener_cd * self, 
                                  DDS_DataReader              the_reader,
                                  DDS_LivelinessChangedStatus status, 
                                  void                      * callback_data);
    void (*on_data_available)(struct DDS_DomainParticipantListener_cd * self, 
                              DDS_DataReader              the_reader, 
                              void                      * callback_data);
    void (*on_subscription_matched)(struct DDS_DomainParticipantListener_cd * self, 
                                    DDS_DataReader                 the_reader, 
                                    DDS_SubscriptionMatchedStatus  status, 
                                    void                         * callback_data);
    void (*on_sample_lost)(struct DDS_DomainParticipantListener_cd * self, 
                           DDS_DataReader              the_reader, 
                           DDS_SampleLostStatus        status, 
                           void                      * callback_data);
    void (*on_data_on_readers)(struct DDS_DomainParticipantListener_cd * self, 
                               DDS_Subscriber              the_subscriber, 
                               void                      * callback_data);
  } DDS_DomainParticipantListener_cd;

  /***********************************************************
   *            QOS                                          *
   ***********************************************************/
  COREDX_C_API const char        * DDS_USERDATA_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_DURABILITY_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_PRESENTATION_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_DEADLINE_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_LATENCYBUDGET_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_OWNERSHIP_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_OWNERSHIPSTRENGTH_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_LIVELINESS_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_TIMEBASEDFILTER_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_PARTITION_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_RELIABILITY_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_DESTINATIONORDER_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_HISTORY_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_RESOURCELIMITS_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_ENTITYFACTORY_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_WRITERDATALIFECYCLE_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_READERDATALIFECYCLE_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_TOPICDATA_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_GROUPDATA_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_TRANSPORTPRIORITY_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_LIFESPAN_QOS_POLICY_NAME;
  COREDX_C_API const char        * DDS_DURABILITYSERVICE_POLICY_NAME;

  COREDX_C_API DDS_QosPolicyId_t   DDS_USERDATA_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_DURABILITY_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_PRESENTATION_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_DEADLINE_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_LATENCYBUDGET_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_OWNERSHIP_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_LIVELINESS_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_TIMEBASEDFILTER_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_PARTITION_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_RELIABILITY_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_DESTINATIONORDER_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_HISTORY_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_RESOURCELIMITS_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_ENTITYFACTORY_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_READERDATALIFECYCLE_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_TOPICDATA_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_GROUPDATA_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_TRANSPORTPRIORITY_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_LIFESPAN_QOS_POLICY_ID;
  COREDX_C_API DDS_QosPolicyId_t   DDS_DURABILITYSERVICE_QOS_POLICY_ID;
#define DDS_MAXIMUM_QOS_POLICY_ID 22


  typedef struct DDS_UserDataQosPolicy {
    DDS_OctetSeq value;
  } DDS_UserDataQosPolicy;

  typedef struct DDS_TopicDataQosPolicy {
    DDS_OctetSeq value;
  } DDS_TopicDataQosPolicy;

  typedef struct DDS_GroupDataQosPolicy {
    DDS_OctetSeq value;
  } DDS_GroupDataQosPolicy;

  typedef struct DDS_TransportPriorityQosPolicy {
    int     value;
  } DDS_TransportPriorityQosPolicy;

  typedef struct DDS_LifespanQosPolicy {
    DDS_Duration_t duration;
  } DDS_LifespanQosPolicy;

  typedef enum DDS_DurabilityQosPolicyKind {
    DDS_VOLATILE_DURABILITY_QOS,
    DDS_TRANSIENT_LOCAL_DURABILITY_QOS,
    DDS_TRANSIENT_DURABILITY_QOS,
    DDS_PERSISTENT_DURABILITY_QOS
  } DDS_DurabilityQosPolicyKind;

  typedef struct DDS_DurabilityQosPolicy {
    DDS_DurabilityQosPolicyKind kind;
  } DDS_DurabilityQosPolicy;

  typedef enum DDS_PresentationQosPolicyAccessScopeKind {
    DDS_INSTANCE_PRESENTATION_QOS,
    DDS_TOPIC_PRESENTATION_QOS,
    DDS_GROUP_PRESENTATION_QOS
  } DDS_PresentationQosPolicyAccessScopeKind;

  typedef struct DDS_PresentationQosPolicy {
    DDS_PresentationQosPolicyAccessScopeKind access_scope; 
    unsigned char coherent_access;
    unsigned char ordered_access;
  } DDS_PresentationQosPolicy;

  typedef struct DDS_DeadlineQosPolicy {
    DDS_Duration_t period;
  } DDS_DeadlineQosPolicy;

  typedef struct DDS_LatencyBudgetQosPolicy {
    DDS_Duration_t duration;
  } DDS_LatencyBudgetQosPolicy;

  typedef enum DDS_OwnershipQosPolicyKind {
    DDS_SHARED_OWNERSHIP_QOS,
    DDS_EXCLUSIVE_OWNERSHIP_QOS
  } DDS_OwnershipQosPolicyKind;

  typedef struct DDS_OwnershipQosPolicy {
    DDS_OwnershipQosPolicyKind kind;
  } DDS_OwnershipQosPolicy;

  typedef struct DDS_OwnershipStrengthQosPolicy {
    int     value;
  } DDS_OwnershipStrengthQosPolicy;

  typedef enum DDS_LivelinessQosPolicyKind {
    DDS_AUTOMATIC_LIVELINESS_QOS,
    DDS_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
    DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS
  } DDS_LivelinessQosPolicyKind;

  typedef struct DDS_LivelinessQosPolicy {
    DDS_LivelinessQosPolicyKind kind;
    DDS_Duration_t lease_duration;
  } DDS_LivelinessQosPolicy;

  typedef struct DDS_TimeBasedFilterQosPolicy {
    DDS_Duration_t minimum_separation;
  } DDS_TimeBasedFilterQosPolicy;

  typedef struct DDS_PartitionQosPolicy {
    struct DDS_StringSeq name;
  } DDS_PartitionQosPolicy;

  typedef enum DDS_ReliabilityQosPolicyKind {
    DDS_RELIABILITY_PLACEHOLDER_QOS, 
    DDS_BEST_EFFORT_RELIABILITY_QOS,
    DDS_RELIABLE_RELIABILITY_QOS
  } DDS_ReliabilityQosPolicyKind;

  typedef struct DDS_ReliabilityQosPolicy {
    DDS_ReliabilityQosPolicyKind kind;
    DDS_Duration_t max_blocking_time;
  } DDS_ReliabilityQosPolicy;

  typedef enum DDS_DestinationOrderQosPolicyKind {
    DDS_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,
    DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
  } DDS_DestinationOrderQosPolicyKind;

  typedef struct DDS_DestinationOrderQosPolicy {
    DDS_DestinationOrderQosPolicyKind kind;
  } DDS_DestinationOrderQosPolicy;

  typedef enum DDS_HistoryQosPolicyKind {
    DDS_KEEP_LAST_HISTORY_QOS,
    DDS_KEEP_ALL_HISTORY_QOS
  } DDS_HistoryQosPolicyKind;

  typedef struct DDS_HistoryQosPolicy {
    DDS_HistoryQosPolicyKind kind;
    int     depth;
  } DDS_HistoryQosPolicy;

  typedef struct DDS_ResourceLimitsQosPolicy {
    int     max_samples;
    int     max_instances;
    int     max_samples_per_instance;
  }  DDS_ResourceLimitsQosPolicy;

  typedef struct DDS_EntityFactoryQosPolicy {
    unsigned char autoenable_created_entities;
  } DDS_EntityFactoryQosPolicy;

  typedef struct DDS_WriterDataLifecycleQosPolicy {
    unsigned char autodispose_unregistered_instances;
  }  DDS_WriterDataLifecycleQosPolicy;

  typedef struct DDS_ReaderDataLifecycleQosPolicy {
    DDS_Duration_t autopurge_nowriter_samples_delay;
    DDS_Duration_t autopurge_disposed_samples_delay;
  }  DDS_ReaderDataLifecycleQosPolicy;

  typedef struct DDS_DurabilityServiceQosPolicy {
    DDS_Duration_t service_cleanup_delay;
    DDS_HistoryQosPolicyKind history_kind;
    int     history_depth;
    int     max_samples;
    int     max_instances;
    int     max_samples_per_instance;
  } DDS_DurabilityServiceQosPolicy; 

  /* CoreDX QoS Extensions: 
   */
  typedef struct CoreDX_EntityNameQosPolicy {
  #define COREDX_ENTITY_NAME_MAX 32
    char value[COREDX_ENTITY_NAME_MAX];
  } CoreDX_EntityNameQosPolicy;

  #define COREDX_ERROR_LOGGING_QOS       0x0001
  #define COREDX_DATA_LOGGING_QOS        0x0002
  #define COREDX_DISCOVERY_LOGGING_QOS   0x0004
  #define COREDX_FACTORY_LOGGING_QOS     0x0008
  #define COREDX_LIVELINESS_LOGGING_QOS  0x0010
  #define COREDX_STATUS_LOGGING_QOS      0x0020
  #define COREDX_TRACE_LOGGING_QOS       0x8000 /* debug build only */

  typedef struct CoreDX_LoggingQosPolicy {
    unsigned int flags;
    /* 
       logging uri examples:
       'file:///tmp/dds.log', 
       'stdout', 
       'stderr' 
    */
#define COREDX_LOGGING_URI_MAX  256
    char         uri[COREDX_LOGGING_URI_MAX]; 
  } CoreDX_LoggingQosPolicy;

#define  COREDX_RESERVED_LOCATOR_KIND_QOS 0
#define  COREDX_UDPV4_LOCATOR_KIND_QOS    1
#define  COREDX_UDPV6_LOCATOR_KIND_QOS    2
#define  COREDX_SHM_LOCATOR_KIND_QO       3

  typedef struct CoreDX_Locator_t  {
    int                    kind;
    unsigned int           port;
    unsigned char          addr[16];
  } CoreDX_Locator;
  DECLARE_SEQ(CoreDX_Locator, CoreDX_LocatorSeq);

  typedef struct CoreDX_ParticipantLocator_t {
    unsigned int     participant_id; 
    CoreDX_Locator   participant_locator;
  } CoreDX_ParticipantLocator;
  DECLARE_SEQ(CoreDX_ParticipantLocator, CoreDX_ParticipantLocatorSeq);

  typedef struct CoreDX_PeerParticipantQosPolicy_t {
    CoreDX_ParticipantLocatorSeq value;
  } CoreDX_PeerParticipantQosPolicy;

  typedef struct DDS_TypecodeQosPolicy {
    DDS_OctetSeq  value;
    unsigned char encoding;
  } DDS_TypecodeQosPolicy;

  typedef struct CoreDX_RTPSWriterQosPolicy {
    DDS_Duration_t  heartbeat_period;
    DDS_Duration_t  nack_response_delay;
    DDS_Duration_t  nack_suppress_delay;
    DDS_Duration_t  ack_deadline;     
    unsigned int    min_buffer_size;  
    unsigned int    max_buffer_size;  
    unsigned char   apply_filters;    
    unsigned char   enable_batch_msg; 
    unsigned char   send_typecode;    
  } CoreDX_RTPSWriterQosPolicy;

  typedef struct CoreDX_RTPSReaderQosPolicy {
    DDS_Duration_t  heartbeat_response_delay;
    unsigned char   accept_batch_msg; 
    unsigned char   send_typecode;    
    unsigned char   send_initial_nack; 
  } CoreDX_RTPSReaderQosPolicy;

  typedef enum DDS_DiscoveryQosPolicyDiscoveryKind {
    DDS_PEER_DISCOVERY_QOS,
    DDS_CENTRAL_DISCOVERY_QOS
  } DDS_DiscoveryQosPolicyDiscoveryKind;
  
  typedef struct CoreDX_DiscoveryQosPolicy {
    DDS_DiscoveryQosPolicyDiscoveryKind discovery_kind; 
    DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE   guid_pid;       
    /* configure Participant Writer */
    DDS_Duration_t  dpd_push_period;      
    DDS_Duration_t  dpd_lease_duration;   
    /* configure Pub/Sub/Topic Builtin writers: */
    DDS_Duration_t  heartbeat_period;
    DDS_Duration_t  nack_response_delay;
    DDS_Duration_t  nack_suppress_delay;
    unsigned int    min_buffer_size; /* minimum tx buffer size in bytes for builtin writers */
    unsigned int    max_buffer_size; /* maximum tx buffer size in bytes for builtin writers */

    /* configure Builtin readers: */
    DDS_Duration_t  heartbeat_response_delay;
    unsigned char   send_initial_nack; 
  } CoreDX_DiscoveryQosPolicy;

  typedef struct CoreDX_ThreadModelQosPolicy {
    unsigned char use_threads;
    unsigned char create_listener_thread; /* create a distinct thread for application Listener callbacks */
  } CoreDX_ThreadModelQosPolicy;

  typedef struct DDS_DomainParticipantFactoryQos {
    DDS_EntityFactoryQosPolicy entity_factory;  
  } DDS_DomainParticipantFactoryQos;
  COREDX_C_API DDS_DomainParticipantFactoryQos * DDS_DomainParticipantFactoryQos__alloc(void);

  typedef struct DDS_DomainParticipantQos {
    DDS_UserDataQosPolicy           user_data;         
    DDS_EntityFactoryQosPolicy      entity_factory;    
    CoreDX_EntityNameQosPolicy      entity_name;
    CoreDX_LoggingQosPolicy         logging;
    CoreDX_PeerParticipantQosPolicy peer_participants; 
    CoreDX_DiscoveryQosPolicy       discovery;         
    CoreDX_ThreadModelQosPolicy     thread_model;      
  } DDS_DomainParticipantQos;
  COREDX_C_API DDS_DomainParticipantQos * DDS_DomainParticipantQos__alloc(void);

#define DDS_DATAWRITER_QOS_USE_TOPIC_QOS    (-1)
#define DDS_DATAREADER_QOS_USE_TOPIC_QOS    (-1)

  typedef struct DDS_TopicQos {
    DDS_TopicDataQosPolicy            topic_data;         
    DDS_DurabilityQosPolicy           durability;         
    DDS_DurabilityServiceQosPolicy    durability_service; 
    DDS_DeadlineQosPolicy             deadline;           
    DDS_LatencyBudgetQosPolicy        latency_budget;     
    DDS_LivelinessQosPolicy           liveliness;         
    DDS_ReliabilityQosPolicy          reliability;        
    DDS_DestinationOrderQosPolicy     destination_order;  
    DDS_HistoryQosPolicy              history;            
    DDS_ResourceLimitsQosPolicy       resource_limits;    
    DDS_TransportPriorityQosPolicy    transport_priority; 
    DDS_LifespanQosPolicy             lifespan;           
    DDS_OwnershipQosPolicy            ownership;          
    CoreDX_EntityNameQosPolicy        entity_name;
    CoreDX_LoggingQosPolicy           logging;
  } DDS_TopicQos;
  COREDX_C_API DDS_TopicQos * DDS_TopicQos__alloc(void);

  typedef struct DDS_DataWriterQos {
    DDS_DurabilityQosPolicy           durability;          
    DDS_DurabilityServiceQosPolicy    durability_service;  
    DDS_DeadlineQosPolicy             deadline;            
    DDS_LatencyBudgetQosPolicy        latency_budget;      
    DDS_LivelinessQosPolicy           liveliness;          
    DDS_ReliabilityQosPolicy          reliability;         
    DDS_DestinationOrderQosPolicy     destination_order;   
    DDS_HistoryQosPolicy              history;             
    DDS_ResourceLimitsQosPolicy       resource_limits;     
    DDS_TransportPriorityQosPolicy    transport_priority;  
    DDS_LifespanQosPolicy             lifespan;            
    DDS_UserDataQosPolicy             user_data;           
    DDS_OwnershipQosPolicy            ownership;           
    DDS_OwnershipStrengthQosPolicy    ownership_strength;  
    DDS_WriterDataLifecycleQosPolicy  writer_data_lifecycle;  
    CoreDX_EntityNameQosPolicy        entity_name;
    CoreDX_LoggingQosPolicy           logging;
    CoreDX_RTPSWriterQosPolicy        rtps_writer;
  } DDS_DataWriterQos;
  COREDX_C_API DDS_DataWriterQos * DDS_DataWriterQos__alloc(void);

  typedef struct DDS_PublisherQos {
    DDS_PresentationQosPolicy         presentation;     
    DDS_PartitionQosPolicy            partition;        
    DDS_GroupDataQosPolicy            group_data;       
    DDS_EntityFactoryQosPolicy        entity_factory;   
    CoreDX_EntityNameQosPolicy        entity_name;
    CoreDX_LoggingQosPolicy           logging;
  } DDS_PublisherQos;
  COREDX_C_API DDS_PublisherQos * DDS_PublisherQos__alloc(void);

  typedef struct DDS_DataReaderQos {
    DDS_DurabilityQosPolicy           durability;            
    DDS_DeadlineQosPolicy             deadline;              
    DDS_LatencyBudgetQosPolicy        latency_budget;        
    DDS_LivelinessQosPolicy           liveliness;            
    DDS_ReliabilityQosPolicy          reliability;           
    DDS_DestinationOrderQosPolicy     destination_order;     
    DDS_HistoryQosPolicy              history;               
    DDS_ResourceLimitsQosPolicy       resource_limits;       
    DDS_UserDataQosPolicy             user_data;             
    DDS_OwnershipQosPolicy            ownership;             
    DDS_TimeBasedFilterQosPolicy      time_based_filter;     
    DDS_ReaderDataLifecycleQosPolicy  reader_data_lifecycle; 
    CoreDX_EntityNameQosPolicy        entity_name;
    CoreDX_LoggingQosPolicy           logging;
    CoreDX_RTPSReaderQosPolicy        rtps_reader;
  } DDS_DataReaderQos;
  COREDX_C_API DDS_DataReaderQos * DDS_DataReaderQos__alloc(void);

  typedef struct DDS_SubscriberQos {
    DDS_PresentationQosPolicy         presentation;    
    DDS_PartitionQosPolicy            partition;       
    DDS_GroupDataQosPolicy            group_data;      
    DDS_EntityFactoryQosPolicy        entity_factory;  
    CoreDX_EntityNameQosPolicy        entity_name;
    CoreDX_LoggingQosPolicy           logging;
  } DDS_SubscriberQos;
  COREDX_C_API DDS_SubscriberQos * DDS_SubscriberQos__alloc(void);

#define DDS_PARTICIPANT_QOS_DEFAULT         NULL
#define DDS_TOPIC_QOS_DEFAULT               NULL
#define DDS_PUBLISHER_QOS_DEFAULT           NULL
#define DDS_SUBSCRIBER_QOS_DEFAULT          NULL
#define DDS_DATAWRITER_QOS_DEFAULT          NULL
#define DDS_DATAREADER_QOS_DEFAULT          NULL

  /****************************************************
   **                                                **
   **      CONDITION                                 **
   **                                                **
   ****************************************************/
  COREDX_C_API unsigned char          DDS_Condition_get_trigger_value(DDS_Condition  c);

  /****************************************************
   **                                                **
   **      GUARD CONDITION                           **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_GuardCondition     DDS_GuardCondition__alloc(); 
  COREDX_C_API void                   DDS_GuardCondition__free(struct _GuardCondition  * gc);
  COREDX_C_API unsigned char          DDS_GuardCondition_get_trigger_value(DDS_GuardCondition  gc);
  COREDX_C_API DDS_ReturnCode_t       DDS_GuardCondition_set_trigger_value(DDS_GuardCondition  gc, 
                                                              unsigned char       v );
  
  /****************************************************
   **                                                **
   **      STATUS CONDITION                          **
   **                                                **
   ****************************************************/
  COREDX_C_API unsigned char          DDS_StatusCondition_get_trigger_value   ( DDS_StatusCondition  sc);
  COREDX_C_API DDS_StatusMask         DDS_StatusCondition_get_enabled_statuses( DDS_StatusCondition  sc);
  COREDX_C_API DDS_ReturnCode_t       DDS_StatusCondition_set_enabled_statuses( DDS_StatusCondition  sc,
                                                                   DDS_StatusMask       mask );
  COREDX_C_API DDS_Entity             DDS_StatusCondition_get_entity( DDS_StatusCondition  sc); 
  
  /****************************************************
   **                                                **
   **      READ CONDITION                            **
   **                                                **
   ****************************************************/
  COREDX_C_API unsigned char          DDS_ReadCondition_get_trigger_value      ( DDS_ReadCondition rc);
  COREDX_C_API DDS_DataReader         DDS_ReadCondition_get_datareader         ( DDS_ReadCondition rc);
  COREDX_C_API DDS_SampleStateKind    DDS_ReadCondition_get_sample_state_mask  ( DDS_ReadCondition rc);
  COREDX_C_API DDS_ViewStateKind      DDS_ReadCondition_get_view_state_mask    ( DDS_ReadCondition rc);
  COREDX_C_API DDS_InstanceStateKind  DDS_ReadCondition_get_instance_state_mask( DDS_ReadCondition rc);

  /****************************************************
   **                                                **
   **      QUERY CONDITION                           **
   **                                                **
   ****************************************************/
  COREDX_C_API unsigned char          DDS_QueryCondition_get_trigger_value      ( DDS_QueryCondition qc);
  COREDX_C_API DDS_DataReader         DDS_QueryCondition_get_datareader         ( DDS_QueryCondition qc);
  COREDX_C_API DDS_SampleStateKind    DDS_QueryCondition_get_sample_state_mask  ( DDS_QueryCondition qc);
  COREDX_C_API DDS_ViewStateKind      DDS_QueryCondition_get_view_state_mask    ( DDS_QueryCondition qc);
  COREDX_C_API DDS_InstanceStateKind  DDS_QueryCondition_get_instance_state_mask( DDS_QueryCondition qc);
  COREDX_C_API const char *           DDS_QueryCondition_get_query_expression   ( DDS_QueryCondition qc);
  COREDX_C_API DDS_ReturnCode_t       DDS_QueryCondition_get_query_parameters   ( DDS_QueryCondition qc, 
                                                                                  DDS_StringSeq     *seq);
  COREDX_C_API DDS_ReturnCode_t       DDS_QueryCondition_set_query_parameters   ( DDS_QueryCondition qc, 
                                                                                  DDS_StringSeq     *parameters);

  /****************************************************
   **                                                **
   **      WAIT SET                                  **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_WaitSet            DDS_WaitSet__alloc(); 
  COREDX_C_API void                   DDS_WaitSet__free(DDS_WaitSet ws);

  COREDX_C_API DDS_ReturnCode_t       DDS_WaitSet_wait(DDS_WaitSet        ws, 
                                          DDS_ConditionSeq * active_conditions, 
                                          DDS_Duration_t   * timeout );
  COREDX_C_API DDS_ReturnCode_t       DDS_WaitSet_attach_condition( DDS_WaitSet   ws, 
                                                       DDS_Condition c );
  COREDX_C_API DDS_ReturnCode_t       DDS_WaitSet_detach_condition( DDS_WaitSet   ws, 
                                                       DDS_Condition c );
  COREDX_C_API DDS_ReturnCode_t       DDS_WaitSet_get_conditions  ( DDS_WaitSet        ws, 
                                                       DDS_ConditionSeq * attached_conditions);
  
  /****************************************************
   **                                                **
   **      ENTITY                                    **
   **                                                **
   ****************************************************/
  /*DDS_ReturnCode_t       DDS_Entity_enable             ( DDS_Entity  e ); */
  /*unsigned char          DDS_Entity_is_enabled         ( DDS_Entity  e ); */
  COREDX_C_API DDS_StatusCondition    DDS_Entity_get_statuscondition( DDS_Entity  e );
  COREDX_C_API DDS_StatusMask         DDS_Entity_get_status_changes ( DDS_Entity  e );
  COREDX_C_API DDS_InstanceHandle_t   DDS_Entity_get_instance_handle( DDS_Entity  e );

  /****************************************************
   **                                                **
   **      DOMAIN PARTICIPANT FACTORY                **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_DomainParticipant  DDS_DomainParticipantFactory_create_participant( DDS_DomainId_t                  domain_id, 
                                                                                       DDS_DomainParticipantQos      * qos, 
                                                                                       DDS_DomainParticipantListener * a_listener,
                                                                                       DDS_StatusMask                  mask);

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_set_license ( const char * lic );
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_delete_participant ( DDS_DomainParticipant a_participant );
  COREDX_C_API DDS_DomainParticipant  DDS_DomainParticipantFactory_lookup_participant ( DDS_DomainId_t  domain_id );
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_set_default_participant_qos ( DDS_DomainParticipantQos  * qos );
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_get_default_participant_qos ( DDS_DomainParticipantQos  * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_set_qos ( const DDS_DomainParticipantFactoryQos * qos ); 
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipantFactory_get_qos ( DDS_DomainParticipantFactoryQos * qos );

  /****************************************************
   **                                                **
   **      DOMAIN PARTICIPANT                        **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_enable             ( DDS_DomainParticipant dp );
  COREDX_C_API unsigned char          DDS_DomainParticipant_is_enabled         ( DDS_DomainParticipant dp );
  COREDX_C_API DDS_InstanceHandle_t   DDS_DomainParticipant_get_instance_handle( DDS_DomainParticipant dp );
  COREDX_C_API DDS_StatusCondition    DDS_DomainParticipant_get_statuscondition( DDS_DomainParticipant dp );
  COREDX_C_API DDS_StatusMask         DDS_DomainParticipant_get_status_changes ( DDS_DomainParticipant dp );
  COREDX_C_API DDS_Publisher          DDS_DomainParticipant_create_publisher ( DDS_DomainParticipant    dp,
                                                                               DDS_PublisherQos       * qos, 
                                                                               DDS_PublisherListener  * a_listener,
                                                                               DDS_StatusMask           mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_publisher ( DDS_DomainParticipant    dp,
                                                                               DDS_Publisher            p);
  COREDX_C_API DDS_Subscriber         DDS_DomainParticipant_create_subscriber( DDS_DomainParticipant    dp,
                                                                               DDS_SubscriberQos      * qos,
                                                                               DDS_SubscriberListener * a_listener,
                                                                               DDS_StatusMask           mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_subscriber( DDS_DomainParticipant    dp,
                                                                               DDS_Subscriber           s);
  COREDX_C_API DDS_Subscriber         DDS_DomainParticipant_get_builtin_subscriber( struct _DomainParticipant *d );

  COREDX_C_API DDS_Topic              DDS_DomainParticipant_create_topic( DDS_DomainParticipant  dp,
                                                                          const char           * topic_name, 
                                                                          const char           * type_name,
                                                                          DDS_TopicQos         * qos, 
                                                                          DDS_TopicListener    * a_listener,
                                                                          DDS_StatusMask       mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_topic( DDS_DomainParticipant   dp,
                                                                          DDS_Topic               a_topic);
  COREDX_C_API DDS_Topic              DDS_DomainParticipant_find_topic( DDS_DomainParticipant     dp,
                                                                        const char              * topic_name, 
                                                                        DDS_Duration_t          * timeout);
  COREDX_C_API DDS_TopicDescription   DDS_DomainParticipant_lookup_topicdescription( DDS_DomainParticipant  dp,
                                                                                     const char           * name);
  COREDX_C_API DDS_ContentFilteredTopic   DDS_DomainParticipant_create_contentfilteredtopic( DDS_DomainParticipant dp,
                                                                                             const char          * name,
                                                                                             const DDS_Topic       related_topic,
                                                                                             const char          * filter_expression,
                                                                                             const DDS_StringSeq * filter_parameters);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_contentfilteredtopic( DDS_DomainParticipant      dp,
                                                                                         DDS_ContentFilteredTopic   a_contentfilteredtopic);
  COREDX_C_API DDS_MultiTopic         DDS_DomainParticipant_create_multitopic( DDS_DomainParticipant dp,
                                                                               const char          * name,
                                                                               const char          * type_name, 
                                                                               const char          * subscription_expression,
                                                                               const DDS_StringSeq * expression_parameters);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_multitopic( DDS_DomainParticipant  dp,
                                                                               DDS_MultiTopic         a_multitopic);

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_delete_contained_entities( DDS_DomainParticipant  dp );
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_qos( DDS_DomainParticipant            dp,
                                                                     const DDS_DomainParticipantQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_qos( DDS_DomainParticipant            dp,
                                                                     DDS_DomainParticipantQos       * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_listener( DDS_DomainParticipant           dp,
                                                                          DDS_DomainParticipantListener * a_listener, 
                                                                          DDS_StatusMask                  mask);

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_listener_cd( DDS_DomainParticipant              dp,
                                                                             DDS_DomainParticipantListener_cd * a_listener, 
                                                                             DDS_StatusMask                     mask, 
                                                                             void                             * callback_data);
  COREDX_C_API DDS_DomainParticipantListener * DDS_DomainParticipant_get_listener( DDS_DomainParticipant dp );
  COREDX_C_API DDS_DomainParticipantListener_cd * DDS_DomainParticipant_get_listener_cd( DDS_DomainParticipant dp );
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_ignore_participant  ( DDS_DomainParticipant       dp,
                                                                                  const DDS_InstanceHandle_t  handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_ignore_topic        ( DDS_DomainParticipant       dp,
                                                                                  const DDS_InstanceHandle_t  handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_ignore_publication  ( DDS_DomainParticipant       dp,
                                                                                  const DDS_InstanceHandle_t  handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_ignore_subscription ( DDS_DomainParticipant       dp,
                                                                                  const DDS_InstanceHandle_t  handle);
  COREDX_C_API DDS_DomainId_t         DDS_DomainParticipant_get_domain_id( DDS_DomainParticipant dp );

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_assert_liveliness( DDS_DomainParticipant dp );

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_default_publisher_qos( DDS_DomainParticipant d,
                                                                                       DDS_PublisherQos * qos);

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_default_publisher_qos( DDS_DomainParticipant d,
                                                                                       DDS_PublisherQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_default_subscriber_qos( DDS_DomainParticipant d,
                                                                                        DDS_SubscriberQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_default_subscriber_qos( DDS_DomainParticipant d,
                                                                                        DDS_SubscriberQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_set_default_topic_qos( DDS_DomainParticipant d,
                                                                                   DDS_TopicQos * qos);  
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_default_topic_qos( DDS_DomainParticipant d,
                                                                                   DDS_TopicQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_discovered_participants( DDS_DomainParticipant d,
                                                                                         DDS_InstanceHandleSeq * participant_handles );
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_discovered_participant_data( DDS_DomainParticipant d,
                                                                                             DDS_ParticipantBuiltinTopicData * participant_data, 
                                                                                             const DDS_InstanceHandle_t  participant_handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_discovered_topics( DDS_DomainParticipant d,
                                                                                   DDS_InstanceHandleSeq * topic_handles);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_discovered_topic_data( DDS_DomainParticipant d,
                                                                                       DDS_TopicBuiltinTopicData * topic_data,
                                                                                       const DDS_InstanceHandle_t  topic_handle);
  COREDX_C_API unsigned char          DDS_DomainParticipant_contains_entity( DDS_DomainParticipant d,
                                                                             const DDS_InstanceHandle_t  a_handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_get_current_time( DDS_DomainParticipant d,
                                                                              DDS_Time_t * current_time);
  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_register_type( DDS_DomainParticipant dp,  
                                                                           DDS_TypeSupport      ts, 
                                                                           const char         * type_name );
  
  COREDX_C_API int                    DDS_DomainParticipant_check_version( DDS_DomainParticipant dp,  
                                                                           const char * major,
                                                                           const char * minor, 
                                                                           const char * patch);

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_do_work( DDS_DomainParticipant dp, 
                                                                     DDS_Duration_t       *time_slice );

  COREDX_C_API DDS_ReturnCode_t       DDS_DomainParticipant_builtin_wait_for_acknowledgments( DDS_DomainParticipant dp, 
                                                                                              DDS_Duration_t       *max_wait );
  
  /****************************************************
   **                                                **
   **      SUBSCRIBER                                **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_enable             ( DDS_Subscriber  s );
  COREDX_C_API unsigned char          DDS_Subscriber_is_enabled         ( DDS_Subscriber s );
  COREDX_C_API DDS_InstanceHandle_t   DDS_Subscriber_get_instance_handle( DDS_Subscriber  s );
  COREDX_C_API DDS_DomainParticipant  DDS_Subscriber_get_participant    ( DDS_Subscriber  s );
  COREDX_C_API DDS_StatusCondition    DDS_Subscriber_get_statuscondition( DDS_Subscriber s );
  COREDX_C_API DDS_StatusMask         DDS_Subscriber_get_status_changes ( DDS_Subscriber  s );
  COREDX_C_API DDS_DataReader         DDS_Subscriber_create_datareader  (  DDS_Subscriber          s,
                                                                           DDS_TopicDescription    a_topic,
                                                                           DDS_DataReaderQos     * qos,
                                                                           DDS_DataReaderListener* a_listener,
                                                                           DDS_StatusMask          mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_delete_datareader  ( DDS_Subscriber  s,
                                                                          DDS_DataReader  a_datareader);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_delete_contained_entities( DDS_Subscriber  s );
  COREDX_C_API DDS_DataReader         DDS_Subscriber_lookup_datareader( DDS_Subscriber   s,
                                                                        const char     * topic_name);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_get_datareaders( DDS_Subscriber         s,
                                                                      DDS_DataReaderSeq    * readers,
                                                                      DDS_SampleStateMask    sample_states,
                                                                      DDS_ViewStateMask      view_states,
                                                                      DDS_InstanceStateMask  instance_states) ;
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_notify_datareaders( DDS_Subscriber  s );
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_set_qos(  DDS_Subscriber  s,
                                                               DDS_SubscriberQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_get_qos(  DDS_Subscriber  s,
                                                               DDS_SubscriberQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_set_listener(  DDS_Subscriber           s,
                                                                    DDS_SubscriberListener * a_listener,
                                                                    DDS_StatusMask           mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_set_listener_cd(  DDS_Subscriber              s,
                                                                       DDS_SubscriberListener_cd * listener_cd,
                                                                       DDS_StatusMask              mask,
                                                                       void                      * callback_data);
  COREDX_C_API DDS_SubscriberListener *DDS_Subscriber_get_listener( DDS_Subscriber  s );
  COREDX_C_API DDS_SubscriberListener_cd *DDS_Subscriber_get_listener_cd( DDS_Subscriber  s );
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_begin_access( DDS_Subscriber  s );
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_end_access( DDS_Subscriber  s );
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_set_default_datareader_qos( DDS_Subscriber  s,
                                                                    const DDS_DataReaderQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_get_default_datareader_qos( DDS_Subscriber  s,
                                                                    DDS_DataReaderQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Subscriber_copy_from_topic_qos( DDS_Subscriber  s,
                                                             DDS_DataReaderQos * a_datareader_qos,
                                                             DDS_TopicQos * a_topic_qos);


  /****************************************************
   **                                                **
   **      PUBLISHER                                 **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_enable             ( DDS_Publisher p );
  COREDX_C_API unsigned char          DDS_Publisher_is_enabled         ( DDS_Publisher p );
  COREDX_C_API DDS_InstanceHandle_t   DDS_Publisher_get_instance_handle( DDS_Publisher  p );
  COREDX_C_API DDS_DomainParticipant  DDS_Publisher_get_participant    ( DDS_Publisher  p );
  COREDX_C_API DDS_StatusCondition    DDS_Publisher_get_statuscondition( DDS_Publisher  p );
  COREDX_C_API DDS_StatusMask         DDS_Publisher_get_status_changes ( DDS_Publisher  p );
  COREDX_C_API DDS_DataWriter         DDS_Publisher_create_datawriter  ( DDS_Publisher             p, 
                                                                         DDS_Topic                 a_topic, 
                                                                         const DDS_DataWriterQos * qos,
                                                                         DDS_DataWriterListener  * a_listener,
                                                                         DDS_StatusMask            mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_delete_datawriter  (DDS_Publisher   p, 
                                                                        DDS_DataWriter  a_datawriter);
  COREDX_C_API DDS_DataWriter         DDS_Publisher_lookup_datawriter(DDS_Publisher p, 
                                                                      const char  * topic_name);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_delete_contained_entities(DDS_Publisher p );
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_set_qos( DDS_Publisher            p, 
                                                             const DDS_PublisherQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_get_qos( DDS_Publisher       p, 
                                                             DDS_PublisherQos *  qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_set_listener( DDS_Publisher           p, 
                                                                  DDS_PublisherListener * a_listener, 
                                                                  DDS_StatusMask          mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_set_listener_cd( DDS_Publisher              p, 
                                                                     DDS_PublisherListener_cd * a_listener, 
                                                                     DDS_StatusMask             mask, 
                                                                     void                     * callback_data);
  COREDX_C_API DDS_PublisherListener *DDS_Publisher_get_listener(DDS_Publisher p );
  COREDX_C_API DDS_PublisherListener_cd *DDS_Publisher_get_listener_cd(DDS_Publisher p );
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_suspend_publications(DDS_Publisher p );
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_resume_publications(DDS_Publisher p  );
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_begin_coherent_changes(DDS_Publisher p );
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_end_coherent_changes(DDS_Publisher p );
#define DDS_Publisher_wait_for_acknowledgements  DDS_Publisher_wait_for_acknowledgments
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_wait_for_acknowledgments(DDS_Publisher           p, 
                                                                             const DDS_Duration_t  * max_wait);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_set_default_datawriter_qos(DDS_Publisher             p, 
                                                                               const DDS_DataWriterQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_get_default_datawriter_qos(DDS_Publisher              p, 
                                                                               struct DDS_DataWriterQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Publisher_copy_from_topic_qos(DDS_Publisher              p, 
                                                                        struct DDS_DataWriterQos * a_datawriter_qos, 
                                                                        const DDS_TopicQos       * a_topic_qos);

  /****************************************************
   **                                                **
   **      TOPIC DESCRIPTION                         **
   **                                                **
   ****************************************************/
  COREDX_C_API const char *           DDS_TopicDescription_get_type_name( DDS_TopicDescription  td );
  COREDX_C_API const char *           DDS_TopicDescription_get_name ( DDS_TopicDescription  td );
  COREDX_C_API DDS_DomainParticipant  DDS_TopicDescription_get_participant( DDS_TopicDescription  td );

  /****************************************************
   **                                                **
   **      TOPIC                                     **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_TopicDescription   DDS_Topic_TopicDescription(DDS_Topic t);
  COREDX_C_API const char *           DDS_Topic_get_type_name( DDS_Topic  t);
  COREDX_C_API const char *           DDS_Topic_get_name( DDS_Topic  t ) ;
  COREDX_C_API DDS_DomainParticipant  DDS_Topic_get_participant( DDS_Topic t );
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_enable( DDS_Topic t );
  COREDX_C_API unsigned char          DDS_Topic_is_enabled( DDS_Topic t );
  COREDX_C_API DDS_InstanceHandle_t   DDS_Topic_get_instance_handle(DDS_Topic t);
  COREDX_C_API DDS_StatusCondition    DDS_Topic_get_statuscondition( DDS_Topic t );
  COREDX_C_API DDS_StatusMask         DDS_Topic_get_status_changes( DDS_Topic t );
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_set_qos( DDS_Topic           t, 
                                                         const DDS_TopicQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_get_qos( DDS_Topic t, 
                                                         DDS_TopicQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_set_listener( DDS_Topic           t, 
                                                              DDS_TopicListener * a_listener, 
                                                              DDS_StatusMask      mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_set_listener_cd( DDS_Topic              t, 
                                                                 DDS_TopicListener_cd * a_listener, 
                                                                 DDS_StatusMask         mask, 
                                                                 void                 * callback_data);
  COREDX_C_API DDS_TopicListener   *  DDS_Topic_get_listener( DDS_Topic t );
  COREDX_C_API DDS_TopicListener_cd *  DDS_Topic_get_listener_cd( DDS_Topic t );
  COREDX_C_API DDS_ReturnCode_t       DDS_Topic_get_inconsistent_topic_status ( DDS_Topic t,  
                                                                                DDS_InconsistentTopicStatus * a_status);
  
  /****************************************************
   **                                                **
   **      CONTENT FILTERED TOPIC                    **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_TopicDescription   DDS_ContentFilteredTopic_TopicDescription(DDS_ContentFilteredTopic t);
  COREDX_C_API const char *           DDS_ContentFilteredTopic_get_type_name( DDS_ContentFilteredTopic  t);
  COREDX_C_API const char *           DDS_ContentFilteredTopic_get_name( DDS_ContentFilteredTopic  t );
  COREDX_C_API DDS_DomainParticipant  DDS_ContentFilteredTopic_get_participant( DDS_Topic t );
  COREDX_C_API DDS_Topic              DDS_ContentFilteredTopic_get_related_topic( DDS_ContentFilteredTopic t);
  COREDX_C_API DDS_ReturnCode_t       DDS_ContentFilteredTopic_get_expression_parameters(DDS_ContentFilteredTopic t, 
                                                                            DDS_StringSeq           *parameters);
  COREDX_C_API DDS_ReturnCode_t       DDS_ContentFilteredTopic_set_expression_parameters(DDS_ContentFilteredTopic t, 
                                                                            const DDS_StringSeq     *parameters);

  /****************************************************
   **                                                **
   **      MULTI TOPIC                               **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_TopicDescription   DDS_MultiTopic_TopicDescription(DDS_MultiTopic t);
  COREDX_C_API const char *           DDS_MultiTopic_get_type_name( DDS_MultiTopic  t);
  COREDX_C_API const char *           DDS_MultiTopic_get_name( DDS_MultiTopic  t );
  COREDX_C_API DDS_DomainParticipant  DDS_MultiTopic_get_participant( DDS_Topic t );
  COREDX_C_API DDS_ReturnCode_t       DDS_MultiTopic_get_expression_parameters(DDS_MultiTopic t, 
                                                                            DDS_StringSeq           *parameters);
  COREDX_C_API DDS_ReturnCode_t       DDS_MultiTopic_set_expression_parameters(DDS_MultiTopic t, 
                                                                            const DDS_StringSeq     *parameters);

  /****************************************************
   **                                                **
   **      DATA WRITER                               **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_enable             ( DDS_DataWriter dw );
  COREDX_C_API unsigned char          DDS_DataWriter_is_enabled         ( DDS_DataWriter dw );
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataWriter_get_instance_handle( DDS_DataWriter dw );
  COREDX_C_API DDS_StatusCondition    DDS_DataWriter_get_statuscondition( DDS_DataWriter dw );
  COREDX_C_API DDS_StatusMask         DDS_DataWriter_get_status_changes ( DDS_DataWriter dw );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_set_qos(DDS_DataWriter             dw,  
                                                             const DDS_DataWriterQos  * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_qos(DDS_DataWriter       dw,  
                                                             DDS_DataWriterQos  * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_set_listener(DDS_DataWriter            dw,  
                                                                  DDS_DataWriterListener  * a_listener, 
                                                                  DDS_StatusMask            mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_set_listener_cd(DDS_DataWriter              dw,  
                                                                     DDS_DataWriterListener_cd * a_listener, 
                                                                     DDS_StatusMask              mask, 
                                                                     void                      * callback_data);
  COREDX_C_API DDS_DataWriterListener * DDS_DataWriter_get_listener(DDS_DataWriter dw);
  COREDX_C_API DDS_DataWriterListener_cd * DDS_DataWriter_get_listener_cd(DDS_DataWriter dw);
#define DDS_DataWriter_wait_for_acknowledgements  DDS_DataWriter_wait_for_acknowledgments
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_wait_for_acknowledgments(DDS_DataWriter          dw,
                                                                              const DDS_Duration_t  * max_wait);
  COREDX_C_API DDS_Topic              DDS_DataWriter_get_topic(DDS_DataWriter dw);
  COREDX_C_API DDS_Publisher          DDS_DataWriter_get_publisher(DDS_DataWriter dw);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_assert_liveliness(DDS_DataWriter dw);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_matched_subscriptions(DDS_DataWriter dw, 
                                                                               DDS_InstanceHandleSeq  *subscription_handles);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_matched_subscription_data(DDS_DataWriter dw, 
                                                                                   DDS_SubscriptionBuiltinTopicData * subscription_data,
                                                                                   const  DDS_InstanceHandle_t    subscription_handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_liveliness_lost_status ( DDS_DataWriter dw,
                                                                                  DDS_LivelinessLostStatus *status);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_offered_deadline_missed_status ( DDS_DataWriter dw,
                                                                                          DDS_OfferedDeadlineMissedStatus *status);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_offered_incompatible_qos_status ( DDS_DataWriter dw,
                                                                                           DDS_OfferedIncompatibleQosStatus *status);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_publication_matched_status ( DDS_DataWriter dw,
                                                                                      DDS_PublicationMatchedStatus *status);

  /***********************************************************************/
  /*                                                                     */
  /* BASE read/take operations used by generated application DataWriters */
  /*                                                                     */
  /* NOTE:                                                               */
  /*                                                                     */
  /* DDS Users should not call these directly.  Call the corresponding   */
  /* type specific routines found in the DDL Generated code.             */
  /*                                                                     */

  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_get_key_value( DDS_DataWriter dw,
                                                                    void * key_holder, 
                                                                    const DDS_InstanceHandle_t  handle);
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataWriter_lookup_instance(DDS_DataWriter dw,
                                                                     const void * instance_data);
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataWriter_register_instance(DDS_DataWriter dw, 
                                                                       const void *  instance_data);
  
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataWriter_register_instance_w_timestamp(DDS_DataWriter dw,
                                                                                   const void *  instance_data,
                                                                                   const DDS_Time_t  source_timestamp);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_unregister_instance(DDS_DataWriter dw,
                                                                         const void * instance_data, 
                                                                         const DDS_InstanceHandle_t  handle);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_unregister_instance_w_timestamp(DDS_DataWriter dw,
                                                                                     const void * instance_data, 
                                                                                     DDS_InstanceHandle_t  handle,
                                                                                     const DDS_Time_t  source_timestamp);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_write(DDS_DataWriter dw,
                                                           const void * instance_data, 
                                                           const DDS_InstanceHandle_t  handle);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_write_w_timestamp(DDS_DataWriter dw,
                                                                       const void * instance_data, 
                                                                       const DDS_InstanceHandle_t  handle, 
                                                                       const DDS_Time_t  source_timestamp);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_dispose(DDS_DataWriter dw,
                                                             const void * instance_data, 
                                                             const DDS_InstanceHandle_t  instance_handle);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataWriter_dispose_w_timestamp(DDS_DataWriter dw,
                                                                         const void * instance_data, 
                                                                         const DDS_InstanceHandle_t  instance_handle, 
                                                                         const DDS_Time_t  source_timestamp);
  /* END                                                                 */
  /* BASE read/take operations used by generated application DataWriters */
  /***********************************************************************/

  /****************************************************
   **                                                **
   **      DATA READER                               **
   **                                                **
   ****************************************************/
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_enable             ( DDS_DataReader dr );
  COREDX_C_API unsigned char          DDS_DataReader_is_enabled         ( DDS_DataReader dr );
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataReader_get_instance_handle( DDS_DataReader dr );
  COREDX_C_API DDS_StatusMask         DDS_DataReader_get_status_changes ( DDS_DataReader dr );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_delete_contained_entities(DDS_DataReader dr );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_set_qos (DDS_DataReader            dr, 
                                                              const DDS_DataReaderQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_qos(DDS_DataReader      dr, 
                                                             DDS_DataReaderQos * qos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_set_listener(DDS_DataReader           dr, 
                                                                  DDS_DataReaderListener * a_listener, 
                                                                  DDS_StatusMask           mask);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_set_listener_cd(DDS_DataReader              dr, 
                                                                     DDS_DataReaderListener_cd * a_listener, 
                                                                     DDS_StatusMask              mask, 
                                                                     void                      * callback_data);
  COREDX_C_API DDS_DataReaderListener  * DDS_DataReader_get_listener(DDS_DataReader dr);
  COREDX_C_API DDS_DataReaderListener_cd  * DDS_DataReader_get_listener_cd(DDS_DataReader dr);
  COREDX_C_API DDS_TopicDescription   DDS_DataReader_get_topicdescription( DDS_DataReader dr );
  COREDX_C_API DDS_Subscriber         DDS_DataReader_get_subscriber( DDS_DataReader dr );

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_wait_for_historical_data( DDS_DataReader  dr, 
                                                                               const DDS_Duration_t * max_wait);
  COREDX_C_API DDS_StatusCondition    DDS_DataReader_get_statuscondition( DDS_DataReader dr );
  COREDX_C_API DDS_ReadCondition      DDS_DataReader_create_readcondition( DDS_DataReader dr, 
                                                                           DDS_SampleStateMask    sample_states, 
                                                                           DDS_ViewStateMask      view_states,
                                                                           DDS_InstanceStateMask  instance_states);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_delete_readcondition(DDS_DataReader       dr, 
                                                                          DDS_ReadCondition    a_condition);
  COREDX_C_API DDS_QueryCondition     DDS_DataReader_create_querycondition(DDS_DataReader         dr, 
                                                                           DDS_SampleStateMask    sample_states, 
                                                                           DDS_ViewStateMask      view_states,
                                                                           DDS_InstanceStateMask  instance_states,
                                                                           const char           * query_expression,
                                                                           const DDS_StringSeq  * query_parameters);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_matched_publications(DDS_DataReader           dr, 
                                                                              DDS_InstanceHandleSeq  * publication_handles);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_matched_publication_data( DDS_DataReader                    dr, 
                                                                                   DDS_PublicationBuiltinTopicData * publication_data,
                                                                                   const DDS_InstanceHandle_t        publication_handle);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_return_loan(DDS_DataReader       dr, 
                                                                 DDS_PointerSeq     * received_data,
                                                                 DDS_SampleInfoSeq  * sample_infos);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_sample_rejected_status(DDS_DataReader            dr,
                                                                                DDS_SampleRejectedStatus *status );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_liveliness_changed_status(DDS_DataReader               dr,
                                                                                   DDS_LivelinessChangedStatus *status);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_requested_deadline_missed_status(DDS_DataReader                     dr,
                                                                                          DDS_RequestedDeadlineMissedStatus *status);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_requested_incompatible_qos_status(DDS_DataReader                      dr,
                                                                                           DDS_RequestedIncompatibleQosStatus *status );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_subscription_matched_status(DDS_DataReader                  dr,
                                                                                     DDS_SubscriptionMatchedStatus  *status );
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_sample_lost_status(DDS_DataReader         dr,
                                                                            DDS_SampleLostStatus  *status ); 

  
  /***********************************************************************/
  /*                                                                     */
  /* BASE read/take operations used by generated application DataReaders */
  /*                                                                     */
  /* NOTE:                                                               */
  /*                                                                     */
  /* DDS Users should not call these directly.  Call the corresponding   */
  /* type specific routines found in the DDL Generated code.             */
  /*                                                                     */

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_get_key_value(DDS_DataReader       dr, 
                                                                   void               * key_holder, 
                                                                   DDS_InstanceHandle_t handle);
  COREDX_C_API DDS_InstanceHandle_t   DDS_DataReader_lookup_instance(DDS_DataReader dr, 
                                                                     void         * instance_data);
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read(DDS_DataReader          dr, 
                                                          DDS_PointerSeq        * received_data,
                                                          DDS_SampleInfoSeq     * sample_infos,
                                                          int                     max_samples,
                                                          DDS_SampleStateMask     sample_states, 
                                                          DDS_ViewStateMask       view_states, 
                                                          DDS_InstanceStateMask   instance_states);
  

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take(DDS_DataReader          dr, 
                                                          DDS_PointerSeq        * received_data,
                                                          DDS_SampleInfoSeq     * sample_infos,
                                                          int                     max_samples,
                                                          DDS_SampleStateMask     sample_states, 
                                                          DDS_ViewStateMask       view_states, 
                                                          DDS_InstanceStateMask   instance_states);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read_w_condition(DDS_DataReader         dr, 
                                                                      DDS_PointerSeq       * received_data,
                                                                      DDS_SampleInfoSeq    * sample_infos,
                                                                      int                    max_samples,
                                                                      DDS_ReadCondition      a_condition);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take_w_condition(DDS_DataReader        dr, 
                                                                      DDS_PointerSeq      * received_data,
                                                                      DDS_SampleInfoSeq   * sample_infos,
                                                                      int                   max_samples,
                                                                      DDS_ReadCondition     a_condition);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read_next_sample(DDS_DataReader       dr, 
                                                                      void               * received_data,
                                                                      DDS_SampleInfo     * sample_info);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take_next_sample(DDS_DataReader       dr, 
                                                                      void               * received_data,
                                                                      DDS_SampleInfo     * sample_info);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read_instance(DDS_DataReader        dr, 
                                                                   DDS_PointerSeq      * received_data,
                                                                   DDS_SampleInfoSeq   * sample_infos,
                                                                   int                   max_samples,
                                                                   DDS_InstanceHandle_t  a_handle,
                                                                   DDS_SampleStateMask   sample_states, 
                                                                   DDS_ViewStateMask     view_states, 
                                                                   DDS_InstanceStateMask instance_states);
  

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take_instance(DDS_DataReader        dr, 
                                                                   DDS_PointerSeq      * received_data,
                                                                   DDS_SampleInfoSeq   * sample_infos,
                                                                   int                   max_samples,
                                                                   DDS_InstanceHandle_t  a_handle,
                                                                   DDS_SampleStateMask   sample_states, 
                                                                   DDS_ViewStateMask     view_states, 
                                                                   DDS_InstanceStateMask instance_states);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read_next_instance(DDS_DataReader          dr, 
                                                                        DDS_PointerSeq        * received_data,
                                                                        DDS_SampleInfoSeq     * sample_infos,
                                                                        int                     max_samples,
                                                                        DDS_InstanceHandle_t    previous_handle,
                                                                        DDS_SampleStateMask     sample_states, 
                                                                        DDS_ViewStateMask       view_states, 
                                                                        DDS_InstanceStateMask   instance_states);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take_next_instance(DDS_DataReader         dr, 
                                                                        DDS_PointerSeq       * received_data,
                                                                        DDS_SampleInfoSeq    * sample_infos,
                                                                        int                    max_samples,
                                                                        DDS_InstanceHandle_t   previous_handle,
                                                                        DDS_SampleStateMask    sample_states, 
                                                                        DDS_ViewStateMask      view_states, 
                                                                        DDS_InstanceStateMask  instance_states);

  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_read_next_instance_w_condition(DDS_DataReader          dr, 
                                                                                    DDS_PointerSeq        * received_data,
                                                                                    DDS_SampleInfoSeq     * sample_infos,
                                                                                    int                     max_samples,
                                                                                    DDS_InstanceHandle_t    previous_handle,
                                                                                    DDS_ReadCondition       a_condition);
  
  COREDX_C_API DDS_ReturnCode_t       DDS_DataReader_take_next_instance_w_condition(DDS_DataReader         dr, 
                                                                                    DDS_PointerSeq       * received_data,
                                                                                    DDS_SampleInfoSeq    * sample_infos,
                                                                                    int                    max_samples,
                                                                                    DDS_InstanceHandle_t   previous_handle,
                                                                                    DDS_ReadCondition      a_condition);
  /* END                                                                 */
  /* BASE read/take operations used by generated application DataReaders */
  /***********************************************************************/
  
  /* TWIN OAKS HELPER EXTENSIONS: */
  COREDX_C_API const char *  DDS_qos_policy_str(DDS_QosPolicyId_t policy);
  COREDX_C_API const char *  DDS_error( DDS_ReturnCode_t retcode );
  COREDX_C_API const char *  DDS_sample_state( DDS_SampleStateMask sm );
  COREDX_C_API const char *  DDS_view_state ( DDS_ViewStateMask vm );
  COREDX_C_API const char *  DDS_instance_state (DDS_InstanceStateMask im );
  
  COREDX_C_API void DDS_BuiltinTopicKey_t_copy(DDS_BuiltinTopicKey_t * to, DDS_BuiltinTopicKey_t * from);
  COREDX_C_API void DDS_UserDataQosPolicy_copy(DDS_UserDataQosPolicy * to, DDS_UserDataQosPolicy * from);
  COREDX_C_API void DDS_TopicDataQosPolicy_copy(DDS_TopicDataQosPolicy * to, DDS_TopicDataQosPolicy * from);
  COREDX_C_API void DDS_GroupDataQosPolicy_copy(DDS_GroupDataQosPolicy * to, DDS_GroupDataQosPolicy * from );
  COREDX_C_API void DDS_TransportPriorityQosPolicy_copy(DDS_TransportPriorityQosPolicy * to, DDS_TransportPriorityQosPolicy * from);
  COREDX_C_API void DDS_LifespanQosPolicy_copy(DDS_LifespanQosPolicy * to, DDS_LifespanQosPolicy * from );
  COREDX_C_API void DDS_DurabilityQosPolicy_copy(DDS_DurabilityQosPolicy * to, DDS_DurabilityQosPolicy * from);
  COREDX_C_API void DDS_PresentationQosPolicy_copy(DDS_PresentationQosPolicy * to, DDS_PresentationQosPolicy * from);
  COREDX_C_API void DDS_DeadlineQosPolicy_copy(DDS_DeadlineQosPolicy * to, DDS_DeadlineQosPolicy * from);
  COREDX_C_API void DDS_LatencyBudgetQosPolicy_copy(DDS_LatencyBudgetQosPolicy * to, DDS_LatencyBudgetQosPolicy * from);
  COREDX_C_API void DDS_OwnershipQosPolicy_copy(DDS_OwnershipQosPolicy * to, DDS_OwnershipQosPolicy * from);
  COREDX_C_API void DDS_OwnershipStrengthQosPolicy_copy(DDS_OwnershipStrengthQosPolicy *to, DDS_OwnershipStrengthQosPolicy * from);
  COREDX_C_API void DDS_LivelinessQosPolicy_copy(DDS_LivelinessQosPolicy * to, DDS_LivelinessQosPolicy * from);
  COREDX_C_API void DDS_TimeBasedFilterQosPolicy_copy(DDS_TimeBasedFilterQosPolicy * to, DDS_TimeBasedFilterQosPolicy * from);
  COREDX_C_API void DDS_PartitionQosPolicy_copy(DDS_PartitionQosPolicy * to, DDS_PartitionQosPolicy * from );
  COREDX_C_API void DDS_ReliabilityQosPolicy_copy(DDS_ReliabilityQosPolicy * to, DDS_ReliabilityQosPolicy * from);
  COREDX_C_API void DDS_DestinationOrderQosPolicy_copy(DDS_DestinationOrderQosPolicy * to, DDS_DestinationOrderQosPolicy * from);
  COREDX_C_API void DDS_HistoryQosPolicy_copy(DDS_HistoryQosPolicy * to, DDS_HistoryQosPolicy * from);
  COREDX_C_API void DDS_ResourceLimitsQosPolicy_copy(DDS_ResourceLimitsQosPolicy * to, DDS_ResourceLimitsQosPolicy * from);
  COREDX_C_API void DDS_EntityFactoryQosPolicy_copy(DDS_EntityFactoryQosPolicy * to, DDS_EntityFactoryQosPolicy * from );
  COREDX_C_API void DDS_WriterDataLifecycleQosPolicy_copy(DDS_WriterDataLifecycleQosPolicy * to, DDS_WriterDataLifecycleQosPolicy * from );
  COREDX_C_API void DDS_ReaderDataLifecycleQosPolicy_copy(DDS_ReaderDataLifecycleQosPolicy * to, DDS_ReaderDataLifecycleQosPolicy * from);
  COREDX_C_API void DDS_DurabilityServiceQosPolicy_copy(DDS_DurabilityServiceQosPolicy * to, DDS_DurabilityServiceQosPolicy * from);
  COREDX_C_API void DDS_TypecodeQosPolicy_copy( DDS_TypecodeQosPolicy * to, DDS_TypecodeQosPolicy * from );

  COREDX_C_API void          DDS_UserDataQosPolicy_init( DDS_UserDataQosPolicy * p );
  COREDX_C_API void          DDS_UserDataQosPolicy_clear( DDS_UserDataQosPolicy * p );
  COREDX_C_API void          DDS_GroupDataQosPolicy_init( DDS_GroupDataQosPolicy * p );
  COREDX_C_API void          DDS_GroupDataQosPolicy_clear( DDS_GroupDataQosPolicy * p );
  COREDX_C_API void          DDS_TopicDataQosPolicy_init( DDS_TopicDataQosPolicy * p );
  COREDX_C_API void          DDS_TopicDataQosPolicy_clear( DDS_TopicDataQosPolicy * p );
  COREDX_C_API void          DDS_PartitionQosPolicy_init( DDS_PartitionQosPolicy * p );
  COREDX_C_API void          DDS_PartitionQosPolicy_clear( DDS_PartitionQosPolicy * p );
  COREDX_C_API void          DDS_TypecodeQosPolicy_init( DDS_TypecodeQosPolicy * p );
  COREDX_C_API void          DDS_TypecodeQosPolicy_clear( DDS_TypecodeQosPolicy * p );
  COREDX_C_API void          DDS_DomainParticipantQos_init(DDS_DomainParticipantQos * qos);
  COREDX_C_API void          DDS_TopicQos_init(DDS_TopicQos * qos);
  COREDX_C_API void          DDS_SubscriberQos_init(DDS_SubscriberQos * qos);
  COREDX_C_API void          DDS_PublisherQos_init(DDS_PublisherQos * qos);
  COREDX_C_API void          DDS_DataWriterQos_init(DDS_DataWriterQos * qos);
  COREDX_C_API void          DDS_DataReaderQos_init(DDS_DataReaderQos * qos);

#ifdef __cplusplus
};
#endif /* __cplusplus */


#endif