dds.hh

Go to the documentation of this file.

/*****************************************************************
 *
 *   file:   dds.hh
 *   desc:   This file provides the C++ language binding for CoreDX DDS.
 *
 *****************************************************************
 *
 *   Copyright(C) 2006-2016 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_HH
#define _DDS_HH

#include <dds/dds.h>
#include <dds/dds_seq.hh>
#include <dds/dds_map.hh>

namespace coredx { namespace rpc {
    class Requester;
  }
}

namespace DDS
{
  // -------------------------------------------------------------
  //   FORWARDS
  // -------------------------------------------------------------
  class Entity;
  class DomainEntity;
  class DomainParticipantFactory;
  class DomainParticipant;
  class Publisher;
  class Subscriber;
  class DataReader;
  class DataWriter;
  class TopicDescription;
  class Topic;
  class ContentFilteredTopic;
  class Listener;
  class DomainParticipantListener;
  class PublisherListener;
  class SubscriberListener;
  class TopicListener;
  class DataReaderListener;
  class DataWriterListener;
  class Condition;
  class GuardCondition;
  class StatusCondition;
  class ReadCondition;
  class QueryCondition;
  class TypeSupport;

  // -------------------------------------------------------------
  //  Status 
  // -------------------------------------------------------------
  typedef struct DDS_InconsistentTopicStatus        InconsistentTopicStatus;
  typedef struct DDS_SampleLostStatus               SampleLostStatus;
  typedef struct DDS_SampleRejectedStatus           SampleRejectedStatus;
  typedef struct DDS_LivelinessLostStatus           LivelinessLostStatus;
  typedef struct DDS_LivelinessChangedStatus        LivelinessChangedStatus;
  typedef struct DDS_OfferedDeadlineMissedStatus    OfferedDeadlineMissedStatus;
  typedef struct DDS_RequestedDeadlineMissedStatus  RequestedDeadlineMissedStatus;
  typedef struct DDS_QosPolicyCount                 QosPolicyCount;
  typedef struct DDS_OfferedIncompatibleQosStatus   OfferedIncompatibleQosStatus;
  typedef struct DDS_RequestedIncompatibleQosStatus RequestedIncompatibleQosStatus;
  typedef struct DDS_PublicationMatchedStatus       PublicationMatchedStatus;
  typedef struct DDS_SubscriptionMatchedStatus      SubscriptionMatchedStatus;
  typedef struct DDS_CacheStatistics                CacheStatistics;

  // -------------------------------------------------------------
  //   BASIC TYPES
  // -------------------------------------------------------------
  typedef unsigned char             Octet;
  typedef DDS_DOMAINID_TYPE_NATIVE  DomainId_t; 
  typedef DDS_HANDLE_TYPE_NATIVE    InstanceHandle_t; 
  typedef long                      ReturnCode_t; 
  typedef long                      QosPolicyId_t;
  typedef unsigned long             SampleStateKind;
  typedef unsigned long             SampleStateMask;
  typedef unsigned long             ViewStateKind;
  typedef unsigned long             ViewStateMask;
  typedef unsigned long             InstanceStateKind;
  typedef unsigned long             InstanceStateMask;
  typedef unsigned long             StatusKind;
  typedef unsigned long             StatusMask;   
  struct         Time_t
  {
    Time_t() : sec(0),nanosec(0) {};
    Time_t(int32_t s, uint32_t nsec) : sec(s), nanosec(nsec) {};
    Time_t(const DDS_Time_t & other)
      : sec(other.sec), nanosec(other.nanosec) {}

    operator DDS_Time_t () const { DDS_Time_t retval; retval.sec = sec; retval.nanosec=nanosec; return retval; }
    int32_t  sec;
    uint32_t nanosec;
  };

  
  typedef struct DDS_SampleInfo        SampleInfo;

  /*
   * The builtin data types
   */
  typedef struct DCPSParticipant       ParticipantBuiltinTopicData;
  typedef struct DCPSTopic             TopicBuiltinTopicData;
  typedef struct DCPSPublication       PublicationBuiltinTopicData;
  typedef struct DCPSSubscription      SubscriptionBuiltinTopicData;

  // -------------------------------------------------------------
  //  Common Sequences
  // -------------------------------------------------------------
  typedef DDS::sequence<SampleInfo *>     SampleInfoSeq;
  typedef DDS::sequence<DataReader *>     DataReaderSeq;
  typedef DDS::sequence<InstanceHandle_t> InstanceHandleSeq;
  typedef DDS::sequence<Condition  *>     ConditionSeq;
  typedef DDS::sequence<void *>           Sequence;
  typedef DDS::sequence<char *>           StringSeq;
  typedef DDS::sequence<unsigned char>    OctetSeq;
  
  //disable warnings on extern before template instantiation 
  // (this is the only way to build Windows DLL, but it makes the Windows Compiler unhappy, odd.)
#if defined(_WIN32) && !defined(__MINGW32__)
#  pragma warning (disable : 4231)
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<unsigned char>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<SampleInfo *>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<DataReader *>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<InstanceHandle_t>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<Condition *>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<char *>;
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<void *>;
#endif


} /* namespace DDS */
#include <dds/dds_builtin.hh>

namespace DDS {
  typedef struct COREDX_CPP_CLASS_API EntityFactoryQosPolicy {
    unsigned char autoenable_created_entities;  
    void init()  {}
    void copy(const EntityFactoryQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  } EntityFactoryQosPolicy;

  typedef struct COREDX_CPP_CLASS_API WriterDataLifecycleQosPolicy {
    unsigned char autodispose_unregistered_instances; 
    void init()  {}
    void copy(const WriterDataLifecycleQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  }  WriterDataLifecycleQosPolicy;
  typedef struct COREDX_CPP_CLASS_API ReaderDataLifecycleQosPolicy {
    Duration_t autopurge_nowriter_samples_delay; 
    Duration_t autopurge_disposed_samples_delay; 
    void init()  {}
    void copy(const ReaderDataLifecycleQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  }  ReaderDataLifecycleQosPolicy;

  // -------------------------------------------------------------
  // - CoreDX DDS QoS Extensions: 
  // -------------------------------------------------------------
  typedef struct COREDX_CPP_CLASS_API EntityNameQosPolicy {
    char value[COREDX_ENTITY_NAME_MAX];      
  } EntityNameQosPolicy;

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

  typedef struct Locator_t  {
    int                     kind;
    unsigned int            port;
    unsigned char           addr[16];
  } Locator;

  typedef struct ParticipantLocator {
    unsigned int     participant_id;       
    unsigned int     participant_id_max;   
    Locator          participant_locator;  
  } ParticipantLocator;

  typedef sequence<ParticipantLocator>           ParticipantLocatorSeq;
#if defined(_WIN32) && !defined(__MINGW32__)
  COREDX_CPP_TEMPLATE template class COREDX_CPP_CLASS_API DDS::sequence<ParticipantLocator>;
#endif

  typedef struct COREDX_CPP_CLASS_API PeerParticipantQosPolicy {
    ParticipantLocatorSeq value;           
    unsigned char         strict_match;    
    // constructor, copy constructor, assignment, destructor
    PeerParticipantQosPolicy(){ init(); }
    PeerParticipantQosPolicy(const PeerParticipantQosPolicy &other) { copy(&other); }
    PeerParticipantQosPolicy & operator=(const PeerParticipantQosPolicy & other) { this->clear(); this->copy(&other); return *this;}
    ~PeerParticipantQosPolicy() { clear(); }

    void init() { }
    void copy(const PeerParticipantQosPolicy * from) { if (from) { this->value = from->value; this->strict_match = from->strict_match;  }}
    void clear() { this->value.clear(); }
  } PeerParticipantQosPolicy;

  typedef struct COREDX_CPP_CLASS_API RTPSWriterQosPolicy {
    Duration_t      heartbeat_period;    
    Duration_t      nack_response_delay; 
    Duration_t      nack_suppress_delay; 
    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;    
    void init()  {}
    void copy(const RTPSWriterQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  } RTPSWriterQosPolicy;

  typedef struct COREDX_CPP_CLASS_API RTPSReaderQosPolicy {
    Duration_t      heartbeat_response_delay;  
    unsigned char   accept_batch_msg;     
    unsigned char   send_typecode;        
    unsigned char   send_initial_nack;    
    unsigned int    precache_max_samples; 
    void init()  {}
    void copy(const RTPSReaderQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  } RTPSReaderQosPolicy;

  typedef enum DiscoveryQosPolicyDiscoveryKind {
    PEER_DISCOVERY_QOS,   
    CENTRAL_DISCOVERY_QOS 
  } DiscoveryQosPolicyDiscoveryKind;
  
  typedef struct COREDX_CPP_CLASS_API DiscoveryQosPolicy {
    DDS::DiscoveryQosPolicyDiscoveryKind discovery_kind; 
    DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE guid_pid;     
    Duration_t dpd_push_period;      
    Duration_t dpd_lease_duration;   
    Duration_t heartbeat_period;     
    Duration_t nack_response_delay;  
    Duration_t nack_suppress_delay;  
    unsigned int min_buffer_size;    
    unsigned int max_buffer_size;    
    Duration_t heartbeat_response_delay; 
    unsigned char send_initial_nack;  
    unsigned char send_msglen_submsg; 
    // constructor, copy constructor, assignment, destructor
    void init()  {}
    void copy(const DiscoveryQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  } DiscoveryQosPolicy;

  typedef struct COREDX_CPP_CLASS_API ThreadModelQosPolicy {
    unsigned char use_threads;            
    unsigned char create_listener_thread; 
    // constructor, copy constructor, assignment, destructor
    void init()  {}
    void copy(const ThreadModelQosPolicy * from) { if (from) *this = *from; }
    void clear() {}
  } ThreadModelQosPolicy;

  // -------------------------------------------------------------
  //  Entity Quality of Service 
  // -------------------------------------------------------------

  class COREDX_CPP_CLASS_API DomainParticipantFactoryQos {
  public:
    EntityFactoryQosPolicy entity_factory;

    DomainParticipantFactoryQos();
    ~DomainParticipantFactoryQos();
  private:
    DomainParticipantFactoryQos( const DomainParticipantFactoryQos & q );
    DomainParticipantFactoryQos & operator=( const DomainParticipantFactoryQos & rhs );
  };

  class COREDX_CPP_CLASS_API DomainParticipantQos {
  public:
    UserDataQosPolicy             user_data;         
    EntityFactoryQosPolicy        entity_factory;    
    EntityNameQosPolicy           entity_name;       
    LoggingQosPolicy              logging;           
    PeerParticipantQosPolicy      peer_participants; 
    DiscoveryQosPolicy            discovery;         
    ThreadModelQosPolicy          thread_model;      
    PropertyQosPolicy             properties;        
    DomainParticipantQos();
    ~DomainParticipantQos();
    void clear();
  private:
    DomainParticipantQos( const DomainParticipantQos & q );
    DomainParticipantQos & operator=( const DomainParticipantQos & rhs );
  };

  class COREDX_CPP_CLASS_API TopicQos 
  {
  public:
    TopicDataQosPolicy            topic_data;          
    DurabilityQosPolicy           durability;          
    DurabilityServiceQosPolicy    durability_service;  
    DeadlineQosPolicy             deadline;            
    LatencyBudgetQosPolicy        latency_budget;      
    LivelinessQosPolicy           liveliness;          
    ReliabilityQosPolicy          reliability;         
    DestinationOrderQosPolicy     destination_order;   
    HistoryQosPolicy              history;             
    ResourceLimitsQosPolicy       resource_limits;     
    TransportPriorityQosPolicy    transport_priority;  
    LifespanQosPolicy             lifespan;            
    OwnershipQosPolicy            ownership;           
    DataRepresentationQosPolicy   representation;      
    EntityNameQosPolicy           entity_name;         
    LoggingQosPolicy              logging;             
    TopicQos();
    ~TopicQos();
  private:
    TopicQos( const TopicQos & q );
    TopicQos & operator=( const TopicQos & rhs );
  };

  class COREDX_CPP_CLASS_API DataWriterQos 
  {
  public:
    DurabilityQosPolicy           durability;            
    DurabilityServiceQosPolicy    durability_service;    
    DeadlineQosPolicy             deadline;              
    LatencyBudgetQosPolicy        latency_budget;        
    LivelinessQosPolicy           liveliness;            
    ReliabilityQosPolicy          reliability;           
    DestinationOrderQosPolicy     destination_order;     
    HistoryQosPolicy              history;               
    ResourceLimitsQosPolicy       resource_limits;       
    TransportPriorityQosPolicy    transport_priority;    
    LifespanQosPolicy             lifespan;              
    UserDataQosPolicy             user_data;             
    OwnershipQosPolicy            ownership;             
    OwnershipStrengthQosPolicy    ownership_strength;    
    WriterDataLifecycleQosPolicy  writer_data_lifecycle; 
    DataRepresentationQosPolicy   representation;        
    RpcQosPolicy                  rpc;                   
    EntityNameQosPolicy           entity_name;           
    LoggingQosPolicy              logging;               
    RTPSWriterQosPolicy           rtps_writer;           
    DataWriterQos();
    ~DataWriterQos();
    DataWriterQos( const DataWriterQos & q );
    DataWriterQos & operator=( const DataWriterQos & rhs );
  };

  class COREDX_CPP_CLASS_API PublisherQos 
  {
  public:
    PresentationQosPolicy         presentation;   
    PartitionQosPolicy            partition;      
    GroupDataQosPolicy            group_data;     
    EntityFactoryQosPolicy        entity_factory; 
    EntityNameQosPolicy           entity_name;    
    LoggingQosPolicy              logging;        
    PublisherQos();
    ~PublisherQos();
  private:
    PublisherQos( const PublisherQos & q );
    PublisherQos & operator=( const PublisherQos & rhs );
  };

  class COREDX_CPP_CLASS_API DataReaderQos
  {
  public:
    DurabilityQosPolicy           durability;        
    DeadlineQosPolicy             deadline;          
    LatencyBudgetQosPolicy        latency_budget;    
    LivelinessQosPolicy           liveliness;        
    ReliabilityQosPolicy          reliability;       
    DestinationOrderQosPolicy     destination_order; 
    HistoryQosPolicy              history;           
    ResourceLimitsQosPolicy       resource_limits;   
    UserDataQosPolicy             user_data;         
    OwnershipQosPolicy            ownership;         
    TimeBasedFilterQosPolicy      time_based_filter; 
    ReaderDataLifecycleQosPolicy  reader_data_lifecycle;  
    DataRepresentationQosPolicy   representation;    
    TypeConsistencyEnforcementQosPolicy type_consistency; 
    RpcQosPolicy                  rpc;               
    EntityNameQosPolicy           entity_name;       
    LoggingQosPolicy              logging;           
    RTPSReaderQosPolicy           rtps_reader;       
    DataReaderQos();
    ~DataReaderQos();
    DataReaderQos( const DataReaderQos & q );
    DataReaderQos & operator=( const DataReaderQos & rhs );
  };

  class COREDX_CPP_CLASS_API SubscriberQos
  {
  public:
    PresentationQosPolicy         presentation;    
    PartitionQosPolicy            partition;       
    GroupDataQosPolicy            group_data;      
    EntityFactoryQosPolicy        entity_factory;  
    EntityNameQosPolicy           entity_name;     
    LoggingQosPolicy              logging;         
    SubscriberQos();
    ~SubscriberQos();
  private:
    SubscriberQos( const SubscriberQos & q );
    SubscriberQos & operator=( const SubscriberQos & rhs );
  };


  // -------------------------------------------------------------
  //   PRE-DEFINED VALUES
  // Use namespace class DDS::xyz  instead of these (namespace globals)
  // -------------------------------------------------------------
  const long            LENGTH_UNLIMITED                  = DDS_LENGTH_UNLIMITED; 
  const long            DURATION_INFINITE_SEC             = DDS_DURATION_INFINITE_SEC;
  const unsigned long   DURATION_INFINITE_NSEC            = DDS_DURATION_INFINITE_NSEC;
  const long            DURATION_ZERO_SEC                 = DDS_DURATION_ZERO_SEC;
  const unsigned long   DURATION_ZERO_NSEC                = DDS_DURATION_ZERO_NSEC;
  const long            TIMESTAMP_INVALID_SEC             = DDS_TIMESTAMP_INVALID_SEC;
  const unsigned long   TIMESTAMP_INVALID_NSEC            = DDS_TIMESTAMP_INVALID_NSEC;
  
#define  TIMESTAMP_INVALID        { DDS_TIMESTAMP_INVALID_SEC, DDS_TIMESTAMP_INVALID_NSEC }

  // InstanceHandle codes
  const InstanceHandle_t HANDLE_NIL                       = DDS_HANDLE_NIL;
  const InstanceHandle_t HANDLE_DEFAULT                   = DDS_HANDLE_DEFAULT;
  const InstanceHandle_t HANDLE_NOT_ENABLED               = DDS_HANDLE_NOT_ENABLED;

  // Return codes
  const ReturnCode_t   RETCODE_OK                         = DDS_RETCODE_OK;
  const ReturnCode_t   RETCODE_ERROR                      = DDS_RETCODE_ERROR;
  const ReturnCode_t   RETCODE_UNSUPPORTED                = DDS_RETCODE_UNSUPPORTED;
  const ReturnCode_t   RETCODE_BAD_PARAMETER              = DDS_RETCODE_BAD_PARAMETER;
  const ReturnCode_t   RETCODE_PRECONDITION_NOT_MET       = DDS_RETCODE_PRECONDITION_NOT_MET;
  const ReturnCode_t   RETCODE_OUT_OF_RESOURCES           = DDS_RETCODE_OUT_OF_RESOURCES;
  const ReturnCode_t   RETCODE_NOT_ENABLED                = DDS_RETCODE_NOT_ENABLED;
  const ReturnCode_t   RETCODE_IMMUTABLE_POLICY           = DDS_RETCODE_IMMUTABLE_POLICY;
  const ReturnCode_t   RETCODE_INCONSISTENT_POLICY        = DDS_RETCODE_INCONSISTENT_POLICY;
  const ReturnCode_t   RETCODE_ALREADY_DELETED            = DDS_RETCODE_ALREADY_DELETED;
  const ReturnCode_t   RETCODE_TIMEOUT                    = DDS_RETCODE_TIMEOUT;
  const ReturnCode_t   RETCODE_NO_DATA                    = DDS_RETCODE_NO_DATA;

  // Sample states
  const unsigned long  READ_SAMPLE_STATE                  = DDS_READ_SAMPLE_STATE;
  const unsigned long  NOT_READ_SAMPLE_STATE              = DDS_NOT_READ_SAMPLE_STATE;
  const unsigned long  ANY_SAMPLE_STATE                   = DDS_ANY_SAMPLE_STATE;
  
  // View states
  const unsigned long  NEW_VIEW_STATE                     = DDS_NEW_VIEW_STATE;
  const unsigned long  NOT_NEW_VIEW_STATE                 = DDS_NOT_NEW_VIEW_STATE;
  const unsigned long  ANY_VIEW_STATE                     = DDS_ANY_VIEW_STATE;
  
  // Instance states
  const unsigned long  ALIVE_INSTANCE_STATE               = DDS_ALIVE_INSTANCE_STATE;
  const unsigned long  NOT_ALIVE_DISPOSED_INSTANCE_STATE  = DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE;
  const unsigned long  NOT_ALIVE_NO_WRITERS_INSTANCE_STATE= DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE;
  const unsigned long  NOT_ALIVE_INSTANCE_STATE           = DDS_NOT_ALIVE_INSTANCE_STATE;
  const unsigned long  ANY_INSTANCE_STATE                 = DDS_ANY_INSTANCE_STATE;
  
  const StatusKind     NO_STATUS                          = DDS_NO_STATUS;
  const StatusKind     STATUS_MASK_NONE                   = DDS_NO_STATUS;
  const StatusKind     INCONSISTENT_TOPIC_STATUS          = DDS_INCONSISTENT_TOPIC_STATUS;
  const StatusKind     OFFERED_DEADLINE_MISSED_STATUS     = DDS_OFFERED_DEADLINE_MISSED_STATUS;
  const StatusKind     REQUESTED_DEADLINE_MISSED_STATUS   = DDS_REQUESTED_DEADLINE_MISSED_STATUS;
  const StatusKind     OFFERED_INCOMPATIBLE_QOS_STATUS    = DDS_OFFERED_INCOMPATIBLE_QOS_STATUS;
  const StatusKind     REQUESTED_INCOMPATIBLE_QOS_STATUS  = DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS;
  const StatusKind     SAMPLE_LOST_STATUS                 = DDS_SAMPLE_LOST_STATUS;
  const StatusKind     SAMPLE_REJECTED_STATUS             = DDS_SAMPLE_REJECTED_STATUS;
  const StatusKind     DATA_ON_READERS_STATUS             = DDS_DATA_ON_READERS_STATUS;
  const StatusKind     DATA_AVAILABLE_STATUS              = DDS_DATA_AVAILABLE_STATUS;
  const StatusKind     LIVELINESS_LOST_STATUS             = DDS_LIVELINESS_LOST_STATUS;
  const StatusKind     LIVELINESS_CHANGED_STATUS          = DDS_LIVELINESS_CHANGED_STATUS;
  const StatusKind     PUBLICATION_MATCHED_STATUS         = DDS_PUBLICATION_MATCHED_STATUS;
  const StatusKind     SUBSCRIPTION_MATCHED_STATUS        = DDS_SUBSCRIPTION_MATCHED_STATUS;
  const StatusKind     ALL_STATUS                         = DDS_ALL_STATUS;
  
  const QosPolicyId_t   USERDATA_QOS_POLICY_ID            = DDS_USERDATA_QOS_POLICY_ID; 
  const QosPolicyId_t   DURABILITY_QOS_POLICY_ID          = DDS_DURABILITY_QOS_POLICY_ID;
  const QosPolicyId_t   PRESENTATION_QOS_POLICY_ID        = DDS_PRESENTATION_QOS_POLICY_ID;
  const QosPolicyId_t   DEADLINE_QOS_POLICY_ID            = DDS_DEADLINE_QOS_POLICY_ID;
  const QosPolicyId_t   LATENCYBUDGET_QOS_POLICY_ID       = DDS_LATENCYBUDGET_QOS_POLICY_ID;
  const QosPolicyId_t   OWNERSHIP_QOS_POLICY_ID           = DDS_OWNERSHIP_QOS_POLICY_ID;
  const QosPolicyId_t   OWNERSHIPSTRENGTH_QOS_POLICY_ID   = DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID;
  const QosPolicyId_t   LIVELINESS_QOS_POLICY_ID          = DDS_LIVELINESS_QOS_POLICY_ID;
  const QosPolicyId_t   TIMEBASEDFILTER_QOS_POLICY_ID     = DDS_TIMEBASEDFILTER_QOS_POLICY_ID;
  const QosPolicyId_t   PARTITION_QOS_POLICY_ID           = DDS_PARTITION_QOS_POLICY_ID;
  const QosPolicyId_t   RELIABILITY_QOS_POLICY_ID         = DDS_RELIABILITY_QOS_POLICY_ID;
  const QosPolicyId_t   DESTINATIONORDER_QOS_POLICY_ID    = DDS_DESTINATIONORDER_QOS_POLICY_ID;
  const QosPolicyId_t   HISTORY_QOS_POLICY_ID             = DDS_HISTORY_QOS_POLICY_ID;
  const QosPolicyId_t   RESOURCELIMITS_QOS_POLICY_ID      = DDS_RESOURCELIMITS_QOS_POLICY_ID;
  const QosPolicyId_t   ENTITYFACTORY_QOS_POLICY_ID       = DDS_ENTITYFACTORY_QOS_POLICY_ID;
  const QosPolicyId_t   WRITERDATALIFECYCLE_QOS_POLICY_ID = DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID;
  const QosPolicyId_t   READERDATALIFECYCLE_QOS_POLICY_ID = DDS_READERDATALIFECYCLE_QOS_POLICY_ID;
  const QosPolicyId_t   TOPICDATA_QOS_POLICY_ID           = DDS_TOPICDATA_QOS_POLICY_ID;
  const QosPolicyId_t   GROUPDATA_QOS_POLICY_ID           = DDS_GROUPDATA_QOS_POLICY_ID;
  const QosPolicyId_t   TRANSPORTPRIORITY_QOS_POLICY_ID   = DDS_TRANSPORTPRIORITY_QOS_POLICY_ID;
  const QosPolicyId_t   LIFESPAN_QOS_POLICY_ID            = DDS_LIFESPAN_QOS_POLICY_ID;
  const QosPolicyId_t   DURABILITYSERVICE_QOS_POLICY_ID   = DDS_DURABILITYSERVICE_QOS_POLICY_ID;
  const QosPolicyId_t   DATA_REPRESENTATION_QOS_POLICY_ID = DDS_DATA_REPRESENTATION_QOS_POLICY_ID;

  COREDX_CPP_CONST char    * USERDATA_QOS_POLICY_NAME               ;
  COREDX_CPP_CONST char    * DURABILITY_QOS_POLICY_NAME             ;
  COREDX_CPP_CONST char    * PRESENTATION_QOS_POLICY_NAME           ;
  COREDX_CPP_CONST char    * DEADLINE_QOS_POLICY_NAME               ;
  COREDX_CPP_CONST char    * LATENCYBUDGET_QOS_POLICY_NAME          ;
  COREDX_CPP_CONST char    * OWNERSHIP_QOS_POLICY_NAME              ;
  COREDX_CPP_CONST char    * OWNERSHIPSTRENGTH_QOS_POLICY_NAME      ;
  COREDX_CPP_CONST char    * LIVELINESS_QOS_POLICY_NAME             ;
  COREDX_CPP_CONST char    * TIMEBASEDFILTER_QOS_POLICY_NAME        ;
  COREDX_CPP_CONST char    * PARTITION_QOS_POLICY_NAME              ;
  COREDX_CPP_CONST char    * RELIABILITY_QOS_POLICY_NAME            ;
  COREDX_CPP_CONST char    * DESTINATIONORDER_QOS_POLICY_NAME       ;
  COREDX_CPP_CONST char    * HISTORY_QOS_POLICY_NAME                ;
  COREDX_CPP_CONST char    * RESOURCELIMITS_QOS_POLICY_NAME         ;
  COREDX_CPP_CONST char    * ENTITYFACTORY_QOS_POLICY_NAME          ;
  COREDX_CPP_CONST char    * WRITERDATALIFECYCLE_QOS_POLICY_NAME    ;
  COREDX_CPP_CONST char    * READERDATALIFECYCLE_QOS_POLICY_NAME    ;
  COREDX_CPP_CONST char    * TOPICDATA_QOS_POLICY_NAME              ;
  COREDX_CPP_CONST char    * GROUPDATA_QOS_POLICY_NAME              ;
  COREDX_CPP_CONST char    * TRANSPORTPRIORITY_QOS_POLICY_NAME      ;
  COREDX_CPP_CONST char    * LIFESPAN_QOS_POLICY_NAME               ;
  COREDX_CPP_CONST char    * DURABILITYSERVICE_POLICY_NAME          ;
  COREDX_CPP_CONST char    * DATA_REPRESENTATION_POLICY_NAME        ;

  COREDX_CPP_CONST DomainParticipantQos PARTICIPANT_QOS_DEFAULT     ;
  COREDX_CPP_CONST TopicQos             TOPIC_QOS_DEFAULT           ;
  COREDX_CPP_CONST PublisherQos         PUBLISHER_QOS_DEFAULT       ;
  COREDX_CPP_CONST SubscriberQos        SUBSCRIBER_QOS_DEFAULT      ;
  COREDX_CPP_CONST DataWriterQos        DATAWRITER_QOS_DEFAULT      ;
  COREDX_CPP_CONST DataReaderQos        DATAREADER_QOS_DEFAULT      ;
  COREDX_CPP_CONST DataWriterQos        DATAWRITER_QOS_USE_TOPIC_QOS;
  COREDX_CPP_CONST DataReaderQos        DATAREADER_QOS_USE_TOPIC_QOS;

  // -------------------------------------------------------------
  //   ENTITY
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Entity
  {
  public: 
    virtual StatusCondition * get_statuscondition();

    virtual StatusMask        get_status_changes()=0;
    virtual ReturnCode_t      enable();
    virtual InstanceHandle_t  get_instance_handle();
    
  protected:
    Entity( );
    virtual ~Entity();
    void     init(struct _Entity * e);
    struct _Entity        * _entity;
    class StatusCondition * _sc;
  }; // class Entity
  

  // -------------------------------------------------------------
  //   DOMAIN ENTITY
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DomainEntity : public Entity
  {
  public:
    DomainEntity( struct _Entity * e );
    virtual ~DomainEntity() {};
  }; 
  
  class COREDX_CPP_CLASS_API DomainParticipantFactory
  {
    
  public:
    static DomainParticipantFactory * get_instance();
    static void                       destroy(); // delete the single DomainParticipantFactory instance


    DomainParticipant * create_participant( DomainId_t                  domain_id, 
                                            const DomainParticipantQos      & qos, 
                                            DomainParticipantListener * a_listener,
                                            StatusMask                  mask);
    ReturnCode_t        delete_participant ( DomainParticipant *        a_participant );
    DomainParticipant * lookup_participant ( DomainId_t  domain_id );
    ReturnCode_t        set_default_participant_qos (  const DomainParticipantQos & qos );
    ReturnCode_t        get_default_participant_qos (  DomainParticipantQos & qos);
    ReturnCode_t        get_default_participant_qos (  DomainParticipantQos * qos);
    ReturnCode_t        set_qos ( const DomainParticipantFactoryQos & qos ); 
    ReturnCode_t        get_qos ( DomainParticipantFactoryQos & qos );
    
    
  private:
    DomainParticipantFactory() ; // constructor
    ~DomainParticipantFactory(); // destructor
    
    static void         check_cpp_assumptions();     
  };
  
  
  extern "C" void dp_offered_deadline_missed_wrapper( struct _DataWriter * the_c_writer,
                                                      OfferedDeadlineMissedStatus status);
  extern "C" void dp_offered_incompatible_qos_wrapper( struct _DataWriter * the_c_writer,
                                                       OfferedIncompatibleQosStatus status );
  extern "C" void dp_liveliness_lost_wrapper( struct _DataWriter * the_c_writer,
                                              LivelinessLostStatus status );
  extern "C" void dp_publication_matched_wrapper( struct _DataWriter * the_c_writer,
                                                  PublicationMatchedStatus status );
  extern "C" void dp_data_on_readers_wrapper     ( struct _Subscriber * the_subscriber );
  extern "C" void dp_data_available_wrapper      ( struct _DataReader * the_reader );
  extern "C" void dp_sample_rejected_wrapper     ( struct _DataReader * the_reader, 
                                                   SampleRejectedStatus status );
  extern "C" void dp_liveliness_changed_wrapper  ( struct _DataReader * the_reader, 
                                                   LivelinessChangedStatus status );
  extern "C" void dp_requested_deadline_missed_wrapper( struct _DataReader * the_reader, 
                                                        RequestedDeadlineMissedStatus status );
  extern "C" void dp_requested_incompatible_qos_wrapper( struct _DataReader * the_reader, 
                                                         RequestedIncompatibleQosStatus status );
  extern "C" void dp_subscription_matched_wrapper( struct _DataReader * the_reader, 
                                                   SubscriptionMatchedStatus status );
  extern "C" void dp_sample_lost_wrapper         ( struct _DataReader * the_reader, 
                                                   SampleLostStatus status );
  extern "C" void dp_inconsistent_topic_wrapper( struct _Topic * the_topic,
                                                 InconsistentTopicStatus status );
  
  // -------------------------------------------------------------
  //   DOMAIN PARTICIPANT
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DomainParticipant : public Entity
  {
    friend class DomainParticipantFactory;
  public:
    
    ReturnCode_t                get_qos( DomainParticipantQos & qos);
    ReturnCode_t                set_qos( const DomainParticipantQos & qos);
    
    StatusMask                  get_status_changes();
    ReturnCode_t                set_listener( DomainParticipantListener * a_listener, 
                                              StatusMask                  mask);
    DomainParticipantListener * get_listener( );
    class Publisher *           create_publisher ( const PublisherQos &      qos, 
                                                   PublisherListener * a_listener,
                                                   StatusMask          mask);
    ReturnCode_t                delete_publisher ( class Publisher *   p);
    class Subscriber *          create_subscriber( const SubscriberQos &      qos,
                                                   SubscriberListener * a_listener,
                                                   StatusMask           mask);
    ReturnCode_t                delete_subscriber( class Subscriber *   s);
    class Topic *               create_topic( const char *     topic_name, 
                                              const char *     type_name,
                                              const TopicQos & qos, 
                                              TopicListener *  a_listener,
                                              StatusMask       mask);
    ReturnCode_t                delete_topic( class Topic *    a_topic);
    class Topic *               find_topic  ( const char         * topic_name, 
                                              const Duration_t   & timeout);
    class Topic *               find_topic  ( const char            * topic_name, 
                                              const DDS_Duration_t  & timeout);
    class TopicDescription *    lookup_topicdescription( const char * name );
    class Subscriber *          get_builtin_subscriber();
    ReturnCode_t                ignore_participant  ( InstanceHandle_t &handle);
    ReturnCode_t                ignore_topic        ( InstanceHandle_t &handle);
    ReturnCode_t                ignore_publication  ( InstanceHandle_t &handle);
    ReturnCode_t                ignore_subscription ( InstanceHandle_t &handle);
    DomainId_t                  get_domain_id(  );
    ReturnCode_t                delete_contained_entities( );
    ReturnCode_t                assert_liveliness(  );
    ReturnCode_t                set_default_publisher_qos( const PublisherQos & qos);
    ReturnCode_t                get_default_publisher_qos( PublisherQos & qos);
    ReturnCode_t                get_default_publisher_qos( PublisherQos * qos);
    ReturnCode_t                set_default_subscriber_qos( const SubscriberQos & qos);
    ReturnCode_t                get_default_subscriber_qos( SubscriberQos & qos);
    ReturnCode_t                get_default_subscriber_qos( SubscriberQos * qos);
    ReturnCode_t                set_default_topic_qos( const TopicQos & qos);  
    ReturnCode_t                get_default_topic_qos( TopicQos & qos);
    ReturnCode_t                get_default_topic_qos( TopicQos * qos);
    ReturnCode_t                get_discovered_participants( InstanceHandleSeq * participant_handles );
    ReturnCode_t                get_discovered_participant_data( ParticipantBuiltinTopicData * participant_data, 
                                                                 InstanceHandle_t &            participant_handle );
    ReturnCode_t                get_discovered_topics( InstanceHandleSeq * topic_handles);
    class ContentFilteredTopic *create_contentfilteredtopic( const char          * name,
                                                             class Topic         * related_topic,
                                                             const char          * filter_expression,
                                                             const StringSeq &     filter_parameters);
    ReturnCode_t                delete_contentfilteredtopic( class ContentFilteredTopic * a_cft);
    class MultiTopic *          create_multitopic( const char *       name,
                                                   const char *       type_name, 
                                                   const char *       subscription_expression,
                                                   const StringSeq &  expression_params);
    ReturnCode_t                delete_multitopic( class MultiTopic * a_multitopic);
    ReturnCode_t                get_discovered_topic_data( TopicBuiltinTopicData * topic_data, 
                                                           InstanceHandle_t &      topic_handle );
    
    bool                        contains_entity( InstanceHandle_t a_handle);
    ReturnCode_t                get_current_time( Time_t * current_time);
    ReturnCode_t                get_current_time( Time_t & current_time);
    
    ReturnCode_t                do_work( const Duration_t     & time_slice );

    ReturnCode_t                builtin_wait_for_acknowledgments( const Duration_t     & max_wait );
    ReturnCode_t                get_guid(GUID_t           * guid);

    ReturnCode_t                add_transport(struct CoreDX_Transport  * transport);

    DDS_DomainParticipant       get_core_participant();

   
    //----
    // Inherited from class Entity
    
    ReturnCode_t                enable( );
    InstanceHandle_t            get_instance_handle( );
    
  protected:
    struct DP_impl            * _impl;
    
    // Create / Destory via DomainParticipantFactory
    DomainParticipant();
    ~DomainParticipant();
    
    void init();
    // Listener Wrapper Methods
    static void initialize_listener( DDS_DomainParticipantListener * core_listener,
                                     StatusMask nil_listener );

    friend void dp_offered_deadline_missed_wrapper( struct _DataWriter * the_c_writer,
                                                    OfferedDeadlineMissedStatus status);
    friend void dp_offered_incompatible_qos_wrapper( struct _DataWriter * the_c_writer,
                                                     OfferedIncompatibleQosStatus status );
    friend void dp_liveliness_lost_wrapper( struct _DataWriter * the_c_writer,
                                            LivelinessLostStatus status );
    friend void dp_publication_matched_wrapper( struct _DataWriter * the_c_writer,
                                                PublicationMatchedStatus status );
    friend void dp_data_on_readers_wrapper     ( struct _Subscriber * the_subscriber );
    friend void dp_data_available_wrapper      ( struct _DataReader * the_reader );
    friend void dp_sample_rejected_wrapper     ( struct _DataReader * the_reader, 
                                                 SampleRejectedStatus status );
    friend void dp_liveliness_changed_wrapper  ( struct _DataReader * the_reader, 
                                                 LivelinessChangedStatus status );
    friend void dp_requested_deadline_missed_wrapper( struct _DataReader * the_reader, 
                                                      RequestedDeadlineMissedStatus status );
    friend void dp_requested_incompatible_qos_wrapper( struct _DataReader * the_reader, 
                                                       RequestedIncompatibleQosStatus status );
    friend void dp_subscription_matched_wrapper( struct _DataReader * the_reader, 
                                                 SubscriptionMatchedStatus status );
    friend void dp_sample_lost_wrapper         ( struct _DataReader * the_reader, 
                                                 SampleLostStatus status );
    friend void dp_inconsistent_topic_wrapper( struct _Topic * the_topic,
                                               InconsistentTopicStatus status );
    
  public:
    ReturnCode_t  register_type( TypeSupport * ts, const char  * type_name );
    int           check_version( const char * major, const char * minor, const char * patch);
    int           validate_version( const char * tname, const char * major, const char * minor, const char * patch);
    TypeSupport * get_type( const char * type_name );
    void          print_stats( );
    
  }; // class DomainParticipant


  extern "C" void pub_offered_deadline_missed_wrapper( _DataWriter * the_c_writer,
                                                       OfferedDeadlineMissedStatus status);
  extern "C" void pub_offered_incompatible_qos_wrapper( _DataWriter * the_c_writer,
                                                        OfferedIncompatibleQosStatus status );
  extern "C" void pub_liveliness_lost_wrapper( _DataWriter * the_c_writer,
                                               LivelinessLostStatus status );
  extern "C" void pub_publication_matched_wrapper( _DataWriter * the_c_writer,
                                                   PublicationMatchedStatus status );

  // -------------------------------------------------------------
  //   PUBLISHER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Publisher : public Entity
  {
    friend class DomainParticipant;
  public:
    ReturnCode_t              enable( );
    InstanceHandle_t          get_instance_handle( );
    StatusMask                get_status_changes();
    
    class DomainParticipant * get_participant( );
    class DataWriter *        create_datawriter( Topic              * a_topic, 
                                                 const DataWriterQos      & qos,
                                                 DataWriterListener * a_listener,
                                                 StatusMask           mask);
    ReturnCode_t              delete_datawriter( DataWriter * a_datawriter);
    class DataWriter *        lookup_datawriter( const char * topic_name);
    ReturnCode_t              delete_contained_entities( );
    ReturnCode_t              set_qos( const PublisherQos & qos);
    ReturnCode_t              get_qos( PublisherQos & qos);
    ReturnCode_t              set_listener( PublisherListener * a_listener, 
                                            StatusMask          mask);
    class PublisherListener * get_listener( );
    ReturnCode_t              suspend_publications( );
    ReturnCode_t              resume_publications( );
    ReturnCode_t              begin_coherent_changes( );
    ReturnCode_t              end_coherent_changes( );
    ReturnCode_t              wait_for_acknowledgments(const Duration_t     & max_wait);

    ReturnCode_t              set_default_datawriter_qos( const DataWriterQos & qos);
    ReturnCode_t              get_default_datawriter_qos( DataWriterQos & qos);
    ReturnCode_t              get_default_datawriter_qos( DataWriterQos * qos);
    ReturnCode_t              copy_from_topic_qos( DataWriterQos & a_datawriter_qos, 
                                                   const TopicQos & a_topic_qos);
  protected:
    // Create / Destory via DomainParticipant
    Publisher();
    ~Publisher();
    
    // Listener Wrapper Methods
    static void initialize_listener( DDS_PublisherListener * core_listener,
                                     StatusMask nil_listeners );
    friend void pub_offered_deadline_missed_wrapper( _DataWriter * the_c_writer,
                                                     OfferedDeadlineMissedStatus status);
    friend void pub_offered_incompatible_qos_wrapper( _DataWriter * the_c_writer,
                                                      OfferedIncompatibleQosStatus status );
    friend void pub_liveliness_lost_wrapper( _DataWriter * the_c_writer,
                                             LivelinessLostStatus status );
    friend void pub_publication_matched_wrapper( _DataWriter * the_c_writer,
                                                 PublicationMatchedStatus status );
    
    struct PUB_impl    * _impl;
  };  // class Publisher

  extern "C" void sub_data_on_readers_wrapper     ( struct _Subscriber * the_subscriber );
  extern "C" void sub_data_available_wrapper      ( struct _DataReader * the_reader );
  extern "C" void sub_sample_rejected_wrapper     ( struct _DataReader * the_reader, 
                                                    SampleRejectedStatus status );
  extern "C" void sub_liveliness_changed_wrapper  ( struct _DataReader * the_reader, 
                                                    LivelinessChangedStatus status );
  extern "C" void sub_requested_deadline_missed_wrapper( struct _DataReader * the_reader, 
                                                         RequestedDeadlineMissedStatus status );
  extern "C" void sub_requested_incompatible_qos_wrapper( struct _DataReader * the_reader, 
                                                          RequestedIncompatibleQosStatus status );
  extern "C" void sub_subscription_matched_wrapper( struct _DataReader * the_reader, 
                                                    SubscriptionMatchedStatus status );
  extern "C" void sub_sample_lost_wrapper         ( struct _DataReader * the_reader, 
                                                    SampleLostStatus status );
  // -------------------------------------------------------------
  //   SUBSCRIBER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Subscriber : public Entity
  {
    friend class DomainParticipant;
  public: 
    ReturnCode_t         enable( );
    InstanceHandle_t     get_instance_handle(  );
    StatusMask           get_status_changes();
    DataReader         * create_datareader( TopicDescription  * a_topic,
                                            const DataReaderQos     & qos,
                                            DataReaderListener* a_listener,
                                            StatusMask          mask);
    ReturnCode_t         delete_datareader(  class DataReader * a_datareader);
    ReturnCode_t         delete_contained_entities(  );
    DataReader         * lookup_datareader( const char * topic_name);
    ReturnCode_t         get_datareaders( DataReaderSeq    * readers,
                                          SampleStateMask    sample_states,
                                          ViewStateMask      view_states,
                                          InstanceStateMask  instance_states) ;
    DomainParticipant  * get_participant();
    ReturnCode_t         set_qos(  const SubscriberQos & qos);
    ReturnCode_t         get_qos( SubscriberQos & qos);
    ReturnCode_t         set_listener( SubscriberListener * a_listener,
                                       StatusMask           mask);
    SubscriberListener * get_listener( );
    ReturnCode_t         begin_access( );
    ReturnCode_t         end_access(  );
    ReturnCode_t         set_default_datareader_qos( const DataReaderQos & qos);
    ReturnCode_t         get_default_datareader_qos( DataReaderQos & qos);
    ReturnCode_t         get_default_datareader_qos( DataReaderQos * qos);
    ReturnCode_t         copy_from_topic_qos(        DataReaderQos & a_datareader_qos,
                                              const  TopicQos      & a_topic_qos);
    
  protected:
    // Create / Destroy via DomainParticipant
    Subscriber( );
    ~Subscriber();
    
    static void initialize_listener( DDS_SubscriberListener * core_listener,
                                     StatusMask nil_listeners );
    friend void sub_data_on_readers_wrapper     ( struct _Subscriber * the_subscriber );
    friend void sub_data_available_wrapper      ( struct _DataReader * the_reader );
    friend void sub_sample_rejected_wrapper     ( struct _DataReader * the_reader, 
                                                  SampleRejectedStatus status );
    friend void sub_liveliness_changed_wrapper  ( struct _DataReader * the_reader, 
                                                  LivelinessChangedStatus status );
    friend void sub_requested_deadline_missed_wrapper( struct _DataReader * the_reader, 
                                                       RequestedDeadlineMissedStatus status );
    friend void sub_requested_incompatible_qos_wrapper( struct _DataReader * the_reader, 
                                                        RequestedIncompatibleQosStatus status );
    friend void sub_subscription_matched_wrapper( struct _DataReader * the_reader, 
                                                  SubscriptionMatchedStatus status );
    friend void sub_sample_lost_wrapper         ( struct _DataReader * the_reader, 
                                                  SampleLostStatus status );
    
    struct SUB_impl    * _impl;
  }; // class Subscriber

  // -------------------------------------------------------------
  //   TOPIC DESCRIPTION
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API TopicDescription
  {
    friend class Subscriber;
    friend class DomainParticipant;
  public:
    TopicDescription();
    virtual ~TopicDescription();
  
    virtual DomainParticipant * get_participant( );
    virtual const char *        get_type_name  ( );
    virtual const char *        get_name       ( );
  private:
    struct _TopicDescription * _td;
  };

  extern "C" void top_inconsistent_topic_wrapper( struct _Topic * topic, 
                                                  InconsistentTopicStatus status );
  // -------------------------------------------------------------
  //   TOPIC
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Topic : public TopicDescription,
                                     public Entity
  {
    friend class DomainParticipant;
    friend class Publisher;
  public:
    const char              * get_type_name ( );
    const char              * get_name      ( );
    DomainParticipant       * get_participant( );
    StatusMask                get_status_changes();
    ReturnCode_t              enable( );
    ReturnCode_t              set_qos( const TopicQos & qos);
    ReturnCode_t              get_qos( TopicQos & qos);
    ReturnCode_t              set_listener( TopicListener   * a_listener, 
                                            StatusMask       mask);
    TopicListener           * get_listener( );
    ReturnCode_t              get_inconsistent_topic_status( InconsistentTopicStatus * a_status);
  protected:
    Topic( );
    virtual ~Topic();

    static void initialize_listener( DDS_TopicListener * core_listener,
                                     StatusMask nil_listeners );
    friend void top_inconsistent_topic_wrapper( struct _Topic * topic, 
                                                InconsistentTopicStatus status );
    struct _Topic * _topic;
    TopicListener * _listener;
  };

  // -------------------------------------------------------------
  //   CONTENT FILTERED TOPIC
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API ContentFilteredTopic : public TopicDescription
  {
    friend class DomainParticipant;
    friend class Publisher;
  public:
    const char              * get_type_name ( );
    const char              * get_name      ( );
    Topic                   * get_related_topic( );
    ReturnCode_t              get_expression_parameters(       StringSeq & params);
    ReturnCode_t              set_expression_parameters( const StringSeq & params);
  protected:
    ContentFilteredTopic( );
    virtual ~ContentFilteredTopic();

    struct _ContentFilteredTopic * _cf_topic;
    Topic                        * _related_topic;
  };

  extern "C" void dw_offered_deadline_missed_wrapper( _DataWriter * the_c_writer,
                                                      OfferedDeadlineMissedStatus status);
  extern "C" void dw_offered_incompatible_qos_wrapper( _DataWriter * the_c_writer,
                                                       OfferedIncompatibleQosStatus status );
  extern "C" void dw_liveliness_lost_wrapper( _DataWriter * the_c_writer,
                                              LivelinessLostStatus status );
  extern "C" void dw_publication_matched_wrapper( _DataWriter * the_c_writer,
                                                  PublicationMatchedStatus status );
  // -------------------------------------------------------------
  //   DATA WRITER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DataWriter : public Entity
  {
    friend class Publisher;          
    friend class DomainParticipant;
  public:
    ReturnCode_t                enable( );
    InstanceHandle_t            get_instance_handle( );
    StatusMask                  get_status_changes();
    ReturnCode_t                set_qos(const DataWriterQos  & qos);
    ReturnCode_t                get_qos(DataWriterQos  & qos);
    ReturnCode_t                set_listener(DataWriterListener  * a_listener, 
                                             StatusMask            mask);
    DataWriterListener        * get_listener();
    class Topic               * get_topic();
    class Publisher           * get_publisher();
    ReturnCode_t                wait_for_acknowledgments(const  Duration_t       & max_wait);
    ReturnCode_t                assert_liveliness();
    InstanceHandle_t    register_instance(const void *  instance_data);
    InstanceHandle_t    register_instance_w_timestamp(const void *  instance_data,
                                                      const Time_t  & source_timestamp);
    ReturnCode_t        unregister_instance( const void * instance_data, 
                                             const InstanceHandle_t  handle);
    ReturnCode_t        unregister_instance_w_timestamp( const void * instance_data, 
                                                         const InstanceHandle_t  handle,
                                                         const Time_t  & source_timestamp);
    ReturnCode_t        write( const void * instance_data, 
                               const InstanceHandle_t  handle);
    ReturnCode_t        write_w_timestamp(const void * instance_data, 
                                          const InstanceHandle_t  handle, 
                                          const Time_t  & source_timestamp);
    ReturnCode_t        dispose(const void * instance_data, 
                                const InstanceHandle_t  instance_handle);
    ReturnCode_t        dispose_w_timestamp( const void * instance_data,
                                             const InstanceHandle_t  instance_handle, 
                                             const Time_t  & source_timestamp);
    ReturnCode_t        get_key_value( void * key_holder, 
                                       const InstanceHandle_t  handle);
    InstanceHandle_t    lookup_instance( const void * instance_data);
    
    ReturnCode_t        write_request( const void * instance_data, 
                                       const InstanceHandle_t  h,
                                       DDS::SampleIdentity_t * req_id );
    ReturnCode_t        write_reply( const void * instance_data, 
                                       const InstanceHandle_t  h,
                                       DDS::SampleIdentity_t  * rep_id);
    

    // Access the status
    ReturnCode_t                get_liveliness_lost_status         ( LivelinessLostStatus         *status );
    ReturnCode_t                get_offered_deadline_missed_status ( OfferedDeadlineMissedStatus  *status );
    ReturnCode_t                get_offered_incompatible_qos_status( OfferedIncompatibleQosStatus *status );
    ReturnCode_t                get_publication_matched_status     ( PublicationMatchedStatus     *status );
    ReturnCode_t                get_matched_subscriptions( InstanceHandleSeq  * subscription_handles);
    ReturnCode_t                get_matched_subscription_data( SubscriptionBuiltinTopicData * subscription_data,
                                                               InstanceHandle_t  &   subscription_handle);

    ReturnCode_t  get_cache_stats( CacheStatistics & stats );
    ReturnCode_t                get_guid(GUID_t           * guid);
   
    virtual DataWriter        * narrow() = 0;
  protected:
    // Create / Destroy via Publisher
    DataWriter( );
    virtual ~DataWriter();

    static void initialize_listener( DDS_DataWriterListener * core_listener,
                                     StatusMask nil_listener );
    friend void dw_offered_deadline_missed_wrapper( _DataWriter * the_c_writer,
                                                    OfferedDeadlineMissedStatus status);
    friend void dw_offered_incompatible_qos_wrapper( _DataWriter * the_c_writer,
                                                     OfferedIncompatibleQosStatus status );
    friend void dw_liveliness_lost_wrapper( _DataWriter * the_c_writer,
                                            LivelinessLostStatus status );
    friend void dw_publication_matched_wrapper( _DataWriter * the_c_writer,
                                                PublicationMatchedStatus status );
    
    struct DW_impl     * _impl;
  }; // class DataWrtier
  

  extern "C" void dr_requested_deadline_missed_wrapper( _DataReader * dr, RequestedDeadlineMissedStatus status );
  extern "C" void dr_requested_incompatible_qos_wrapper( _DataReader * dr, RequestedIncompatibleQosStatus status );
  extern "C" void dr_sample_rejected_wrapper( _DataReader * dr, SampleRejectedStatus status );
  extern "C" void dr_liveliness_changed_wrapper( _DataReader * dr, LivelinessChangedStatus status );
  extern "C" void dr_data_available_wrapper( _DataReader * dr );
  extern "C" void dr_subscription_matched_wrapper( _DataReader * dr, SubscriptionMatchedStatus status );
  extern "C" void dr_sample_lost_wrapper( _DataReader * dr, SampleLostStatus status );

  // -------------------------------------------------------------
  //   DATA READER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DataReader  : public Entity
  {
    friend class Subscriber;
    friend class DomainParticipant;
    friend class coredx::rpc::Requester;

  public:
    InstanceHandle_t        get_instance_handle( );
    StatusMask              get_status_changes ( );
    ReturnCode_t            enable ( );
    StatusCondition       * get_statuscondition( ); 

    ReadCondition *         create_readcondition( SampleStateMask    sample_states, 
                                                  ViewStateMask      view_states,
                                                  InstanceStateMask  instance_states);
    ReturnCode_t            delete_readcondition(  ReadCondition * a_condition);
    ReturnCode_t            delete_contained_entities( );
    ReturnCode_t            set_qos( const DataReaderQos & qos);
    ReturnCode_t            get_qos( DataReaderQos & qos);
    ReturnCode_t            set_listener( DataReaderListener * a_listener, 
                                          StatusMask           mask);
    DataReaderListener    * get_listener();
    TopicDescription      * get_topicdescription(  );
    Subscriber            * get_subscriber(  );
    ReturnCode_t            get_sample_rejected_status   ( SampleRejectedStatus     * status);
    ReturnCode_t            get_liveliness_changed_status( LivelinessChangedStatus  * status);
    ReturnCode_t            get_requested_deadline_missed_status ( RequestedDeadlineMissedStatus   * status);
    ReturnCode_t            get_requested_incompatible_qos_status( RequestedIncompatibleQosStatus  * status);
    ReturnCode_t            get_subscription_matched_status ( SubscriptionMatchedStatus  * status);
    ReturnCode_t            get_sample_lost_status       ( SampleLostStatus         * status); 
    ReturnCode_t            wait_for_historical_data( const Duration_t     & max_wait);
    ReturnCode_t            get_matched_publications( InstanceHandleSeq * publication_handles);
    ReturnCode_t            get_matched_publication_data(  PublicationBuiltinTopicData * publication_data,
                                                           const InstanceHandle_t  publication_handle);
    QueryCondition        * create_querycondition( SampleStateMask    sample_states, 
                                                   ViewStateMask      view_states,
                                                   InstanceStateMask  instance_states,
                                                   const char *       query_expression,
                                                   const StringSeq  & query_parameters);

    // BASE read/take operations
    ReturnCode_t    read( Sequence         * received_data,
                          SampleInfoSeq    * sample_infos,
                          long               max_samples,
                          SampleStateMask    sample_states, 
                          ViewStateMask      view_states, 
                          InstanceStateMask  instance_states);
    ReturnCode_t    take( Sequence        * received_data,
                          SampleInfoSeq   * sample_infos,
                          long              max_samples,
                          SampleStateMask   sample_states, 
                          ViewStateMask     view_states, 
                          InstanceStateMask instance_states);
    ReturnCode_t    read_w_condition( Sequence       * received_data,
                                      SampleInfoSeq  * sample_infos,
                                      long          max_samples,
                                      ReadCondition * a_condition);
    ReturnCode_t    take_w_condition( Sequence       * received_data,
                                      SampleInfoSeq  * sample_infos,
                                      long             max_samples,
                                      ReadCondition  * a_condition);
    ReturnCode_t    read_next_sample( void       * received_data,
                                      SampleInfo * sample_info);
    ReturnCode_t    take_next_sample( void       * received_data,
                                      SampleInfo * sample_info);
    ReturnCode_t    read_instance(Sequence       * received_data,
                                  SampleInfoSeq  * sample_infos,
                                  long             max_samples,
                                  InstanceHandle_t a_handle,
                                  SampleStateMask  sample_states, 
                                  ViewStateMask    view_states, 
                                  InstanceStateMask instance_states);
    ReturnCode_t    take_instance(Sequence        * received_data,
                                  SampleInfoSeq   * sample_infos,
                                  long              max_samples,
                                  InstanceHandle_t  a_handle,
                                  SampleStateMask   sample_states, 
                                  ViewStateMask     view_states, 
                                  InstanceStateMask instance_states);
    ReturnCode_t    read_next_instance( Sequence          * received_data,
                                        SampleInfoSeq     * sample_infos,
                                        long                max_samples,
                                        InstanceHandle_t    previous_handle,
                                        SampleStateMask     sample_states, 
                                        ViewStateMask       view_states, 
                                        InstanceStateMask   instance_states);
    ReturnCode_t    take_next_instance( Sequence         * received_data,
                                        SampleInfoSeq    * sample_infos,
                                        long               max_samples,
                                        InstanceHandle_t   previous_handle,
                                        SampleStateMask    sample_states, 
                                        ViewStateMask      view_states, 
                                        InstanceStateMask  instance_states);
    ReturnCode_t    read_next_instance_w_condition( Sequence          * received_data,
                                                    SampleInfoSeq     * sample_infos,
                                                    long                max_samples,
                                                    InstanceHandle_t    previous_handle,
                                                    ReadCondition     * a_condition);
    ReturnCode_t    take_next_instance_w_condition( Sequence       * received_data,
                                                    SampleInfoSeq  * sample_infos,
                                                    long             max_samples,
                                                    InstanceHandle_t previous_handle,
                                                    ReadCondition  * a_condition);
    ReturnCode_t    return_loan( Sequence       * received_data,
                                 SampleInfoSeq  * sample_infos);
    ReturnCode_t    get_key_value( void *  key_holder, 
                                   InstanceHandle_t handle);
    InstanceHandle_t lookup_instance(  void * instance_data);
    ReturnCode_t                get_guid(GUID_t           * guid);
    virtual DataReader  * narrow() = 0;
    ReturnCode_t  get_cache_stats( CacheStatistics & stats );
    ReturnCode_t  print_cache( );

  protected:
    DataReader( );
    virtual ~DataReader( );
    
    static void initialize_listener( DDS_DataReaderListener * core_listener,
                                     StatusMask nil_listeners );
    friend void dr_requested_deadline_missed_wrapper( _DataReader * dr, RequestedDeadlineMissedStatus status );
    friend void dr_requested_incompatible_qos_wrapper( _DataReader * dr, RequestedIncompatibleQosStatus status );
    friend void dr_sample_rejected_wrapper( _DataReader * dr, SampleRejectedStatus status );
    friend void dr_liveliness_changed_wrapper( _DataReader * dr, LivelinessChangedStatus status );
    friend void dr_data_available_wrapper( _DataReader * dr );
    friend void dr_subscription_matched_wrapper( _DataReader * dr, SubscriptionMatchedStatus status );
    friend void dr_sample_lost_wrapper( _DataReader * dr, SampleLostStatus status );
    
    struct DR_impl     * _impl;
  }; // class DataReader
  

  // -------------------------------------------------------------
  //   CONDITION 
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Condition
  {
    //friend  ConditionSeq;
    friend class WaitSet;
  public:
    virtual bool get_trigger_value();
  protected:
    Condition( struct _Condition * c );
    Condition(void);
    virtual ~Condition();
    struct _Condition * _condition;
  }; // class Condition
  

  // -------------------------------------------------------------
  //   GUARD CONDITION
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API GuardCondition : public Condition
  {
  public:
    GuardCondition( );
    GuardCondition( struct _GuardCondition * gc ); // deprecated - do not use
    ~GuardCondition( );
    bool         get_trigger_value();
    ReturnCode_t set_trigger_value( bool v );
  protected:
    struct _GuardCondition * _guard_condition;
  }; // class GuardCondition
  
  // -------------------------------------------------------------
  //   STATUS CONDITION
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API StatusCondition : public Condition
  {
    friend class Entity;
  public:
    bool         get_trigger_value();
    ReturnCode_t set_enabled_statuses( StatusMask mask );
    StatusMask   get_enabled_statuses();
    Entity *     get_entity();
  protected:
    StatusCondition( struct _StatusCondition * sc );
    ~StatusCondition();
    struct _StatusCondition * _status_condition;
  }; // Class StatusCondition

  // -------------------------------------------------------------
  //   READ CONDITION
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API ReadCondition : public Condition
  {
    friend class DataReader;
  public:
    bool                get_trigger_value();
    DataReader *        get_datareader();
    SampleStateKind     get_sample_state_mask();
    ViewStateKind       get_view_state_mask();
    InstanceStateKind   get_instance_state_mask();
  protected:
    ReadCondition( struct _ReadCondition * rc );
    ~ReadCondition();
    struct _ReadCondition * _read_condition;
  }; // class ReadCondition

  // -------------------------------------------------------------
  //   QUERY CONDITION
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API QueryCondition : public ReadCondition
  {
    friend class DataReader;
  public:
    QueryCondition( struct _QueryCondition * qc );
    ~QueryCondition();
    const char *     get_query_expression ( void );
    ReturnCode_t     get_query_parameters  (       StringSeq  & seq);
    ReturnCode_t     set_query_parameters  ( const StringSeq  & seq);

  protected:
    struct _QueryCondition * _query_condition;
  }; // class QueryCondition

  // -------------------------------------------------------------
  //   WAIT SET
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API WaitSet
  {
  public:
    WaitSet( );
    ~WaitSet();
    ReturnCode_t attach_condition( Condition & a_condition );
    ReturnCode_t attach_condition( Condition * a_condition );
    ReturnCode_t detach_condition( Condition & a_condition );
    ReturnCode_t wait            ( ConditionSeq & active_conditions, const Duration_t  & timeout );
    ReturnCode_t get_conditions  ( ConditionSeq & attached_conditions );
  protected:
    struct _WaitSet * _wait_set;
  };

  // -------------------------------------------------------------
  //   LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API Listener
  {
  public:
    Listener() { nil_listeners = 0; }
    virtual ~Listener() {};
    
    /* nil_listeners usage:
     * Set bits for those listeners you wish to declare as 'NIL' listeners.
     * Default is NO BITS SET, in other words, all of your listeners should
     * be called if enabled; there are no 'NIL' listeners.
     * In generally, this will only be used by those applications installing 
     * both listeners AND condition variables on the same statuses.
     */
    StatusMask nil_listeners;
  };
  
  // -------------------------------------------------------------
  //   DATA WRITER LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DataWriterListener : virtual public Listener
  {
  public:
    DataWriterListener() {};
    virtual ~DataWriterListener() {};
    virtual void on_offered_deadline_missed ( DataWriter                        * /* the_writer */,
                                              const OfferedDeadlineMissedStatus &  /* status     */) {};
    virtual void on_offered_incompatible_qos( DataWriter                         * /* the_writer */,
                                              const OfferedIncompatibleQosStatus & /* status     */) {};
    virtual void on_liveliness_lost         ( DataWriter                       * /* the_writer */, 
                                              const LivelinessLostStatus       &  /* status     */) {};
    virtual void on_publication_matched     ( DataWriter                        * /* the_writer */,
                                              const PublicationMatchedStatus    & /* status     */) {};
  };
  
  // -------------------------------------------------------------
  //   PUBLISHER LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API PublisherListener : virtual public DataWriterListener
  {
  public:
    PublisherListener() {};
    virtual ~PublisherListener() {};
  };
  
  // -------------------------------------------------------------
  //   TOPIC LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API TopicListener : virtual public Listener
  {
  public:
    TopicListener() {};
    virtual ~TopicListener() {};
    virtual void on_inconsistent_topic( Topic                          * /* the_topic */,
                                        const InconsistentTopicStatus  & /* status    */) {};
  };
  
  // -------------------------------------------------------------
  //   DATA READER LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DataReaderListener : virtual public Listener
  {
  public:
    DataReaderListener() {};
    virtual ~DataReaderListener() {};
    virtual void on_requested_deadline_missed ( DataReader                          * /* the_reader */, 
                                                const RequestedDeadlineMissedStatus &  /* status     */) {};
    virtual void on_requested_incompatible_qos( DataReader                           * /* the_reader */, 
                                                const RequestedIncompatibleQosStatus & /* status     */) {};
    virtual void on_sample_rejected           ( DataReader                   * /* the_reader */, 
                                                const SampleRejectedStatus   & /* status     */) {};
    virtual void on_liveliness_changed        ( DataReader                    * /* the_reader */, 
                                                const LivelinessChangedStatus & /* status     */) {};
    virtual void on_data_available            ( DataReader                   * /* the_reader */) {}; 
    virtual void on_subscription_matched      ( DataReader                       * /* the_reader */, 
                                                const SubscriptionMatchedStatus  & /* status     */) {};
    virtual void on_sample_lost               ( DataReader                   * /* the_reader */, 
                                                const SampleLostStatus       & /* status     */) {};
  };
  
  // -------------------------------------------------------------
  //   SUBSCRIBER LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API SubscriberListener : virtual public DataReaderListener
  {
  public:
    SubscriberListener() {};
    virtual ~SubscriberListener() {};
    virtual void on_data_on_readers( Subscriber *  /* the_subscriber */ ) {};
  };
  
  // -------------------------------------------------------------
  //   DOMAIN PARTICIPANT LISTENER
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DomainParticipantListener : virtual public PublisherListener, 
                                                         virtual public TopicListener, 
                                                         virtual public SubscriberListener
  {
  public:
    DomainParticipantListener() {};
    virtual ~DomainParticipantListener() {};
  };

  /*  DDS_Time_t     operator +(const DDS_Time_t &t1, const DDS_Duration_t &t2);
  DDS_Time_t     operator +(const DDS_Time_t &t1, const DDS_Time_t &t2);
  DDS_Duration_t operator -(const DDS_Time_t &t1, const DDS_Time_t &t2);
  bool           operator <(const DDS_Time_t &t1, const DDS_Time_t &t2);
  bool           operator <=(const DDS_Time_t &t1, const DDS_Time_t &t2);
  bool           operator ==(const DDS_Time_t &t1, const DDS_Time_t &t2);
  bool           operator >=(const DDS_Time_t &t1, const DDS_Time_t &t2);
  bool           operator >(const DDS_Time_t &t1, const DDS_Time_t &t2);

  DDS_Duration_t operator +(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  DDS_Duration_t operator -(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  bool           operator <(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  bool           operator <=(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  bool           operator ==(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  bool           operator >=(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  bool           operator >(const DDS_Duration_t &t1, const DDS_Duration_t &t2);
  */

  Time_t         operator+(const Time_t &t1, const Duration_t & t2);
  Time_t         operator+(const Time_t &t1, const Time_t & t2);
  Duration_t     operator-(const Time_t &t1, const Time_t & t2);
  bool           operator <(const Time_t &t1, const Time_t &t2);
  bool           operator <=(const Time_t &t1, const Time_t &t2);
  bool           operator ==(const Time_t &t1, const Time_t &t2);
  bool           operator >=(const Time_t &t1, const Time_t &t2);
  bool           operator >(const Time_t &t1, const Time_t &t2);


  Duration_t     operator+(const Duration_t &t1, const Duration_t & t2);
  Duration_t     operator-(const Duration_t &t1, const Duration_t & t2);


  void           String_free(char * str);
  char *         String_dup(const char * other);

} // namespace DDS


#endif