CoreDX Data Distribution Service
The High Performance, Small Footprint DDS from Twin Oaks Computing, Inc
dds.h
Go to the documentation of this file.
1 /*****************************************************************
2  *
3  * file: dds.h
4  * desc: This file provides the C language binding for CoreDX DDS.
5  *
6  *****************************************************************
7  *
8  * Copyright(C) 2006-2020 Twin Oaks Computing, Inc
9  * All rights reserved. Castle Rock, CO 80108
10  *
11  *****************************************************************
12  *
13  * This software has been provided pursuant to a License Agreement
14  * containing restrictions on its use. This software contains
15  * valuable trade secrets and proprietary information of
16  * Twin Oaks Computing, Inc and is protected by law. It may not be
17  * copied or distributed in any form or medium, disclosed to third
18  * parties, reverse engineered or used in any manner not provided
19  * for in said License Agreement except with the prior written
20  * authorization from Twin Oaks Computing, Inc.
21  *
22  *****************************************************************/
23 #ifndef _DDS_H
24 #define _DDS_H
25 
133 #include <dds/dds_export.h>
134 #include <dds/dds_consts.h>
135 #include <dds/dds_types.h>
136 #include <dds/dds_builtin.h>
137 #include <dds/dds_stats.h>
138 
139 #ifdef __cplusplus
140 extern "C" {
141 #endif /* __cplusplus */
142 
143  /***********************************************************
144  * Fundamental DDS Object types (Opaque) *
145  ***********************************************************/
146  typedef struct _DomainParticipantFactory * DDS_DomainParticipantFactory;
147  typedef struct _Entity * DDS_Entity;
148  typedef struct _DomainParticipant * DDS_DomainParticipant;
149  typedef struct _Publisher * DDS_Publisher;
150  typedef struct _Subscriber * DDS_Subscriber;
151  typedef struct _DataReader * DDS_DataReader;
152  typedef struct _DataWriter * DDS_DataWriter;
153  typedef struct _TopicDescription * DDS_TopicDescription;
154  typedef struct _Topic * DDS_Topic;
155  typedef struct _ContentFilteredTopic * DDS_ContentFilteredTopic;
156  typedef struct _MultiTopic * DDS_MultiTopic;
157 
158  typedef struct _Condition * DDS_Condition;
159  typedef struct _StatusCondition * DDS_StatusCondition;
160  typedef struct _ReadCondition * DDS_ReadCondition;
162  typedef struct _GuardCondition * DDS_GuardCondition;
163  typedef struct _QueryCondition * DDS_QueryCondition;
164  typedef struct _WaitSet * DDS_WaitSet;
165  typedef struct _TypeSupport * DDS_TypeSupport;
166 
167 
168  /* Builtin Topic Data Types */
172  typedef struct DDS_DCPSTopic DDS_TopicBuiltinTopicData;
177 
178  struct CoreDX_Transport;
179 
180  /***********************************************************
181  * DDS Entity Sequence Types *
182  ***********************************************************/
183  DECLARE_SEQ( DDS_DataWriter, DDS_DataWriterSeq );
184  DECLARE_SEQ( DDS_DataReader, DDS_DataReaderSeq );
185  DECLARE_SEQ( DDS_InstanceHandle_t, DDS_InstanceHandleSeq);
186  DECLARE_SEQ( DDS_Condition, DDS_ConditionSeq );
187 
188  COREDX_C_API DDS_DataWriterSeq * DDS_DataWriterSeq__alloc(void);
189  COREDX_C_API DDS_DataReaderSeq * DDS_DataReaderSeq__alloc(void);
190  COREDX_C_API DDS_InstanceHandleSeq * DDS_InstanceHandleSeq__alloc(void);
191  COREDX_C_API DDS_ConditionSeq * DDS_ConditionSeq__alloc(void);
192 
193  /***********************************************************
194  * Listeners *
195  ***********************************************************/
206  typedef struct DDS_TopicListener
207  {
213  void (*on_inconsistent_topic)(DDS_Topic the_topic,
215 
224  typedef struct DDS_TopicListener_cd
225  {
235  DDS_Topic the_topic,
237  void * callback_data);
238 
240 
252  typedef struct DDS_DataWriterListener
253  {
261  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
269  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
276  void (*on_liveliness_lost)(DDS_DataWriter writer,
277  DDS_LivelinessLostStatus status);
284  void (*on_publication_matched)(DDS_DataWriter writer,
298  {
306  void (*on_offered_deadline_missed)(struct DDS_DataWriterListener_cd * self,
307  DDS_DataWriter writer,
309  void * callback_data);
317  DDS_DataWriter writer,
319  void * callback_data);
326  DDS_DataWriter writer,
328  void * callback_data);
336  DDS_DataWriter writer,
338  void * callback_data);
340 
352  typedef struct DDS_PublisherListener
353  {
362  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
373  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
383  void (*on_liveliness_lost)(DDS_DataWriter writer,
384  DDS_LivelinessLostStatus status);
393  void (*on_publication_matched)(DDS_DataWriter writer,
407  {
416  void (*on_offered_deadline_missed)(struct DDS_PublisherListener_cd * self,
417  DDS_DataWriter writer,
419  void * callback_data);
430  DDS_DataWriter writer,
432  void * callback_data);
442  DDS_DataWriter writer,
443  DDS_LivelinessLostStatus status,
444  void * callback_data);
454  DDS_DataWriter writer,
456  void * callback_data);
458 
470  typedef struct DDS_DataReaderListener
471  {
478  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
486  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
493  void (*on_sample_rejected)(DDS_DataReader the_reader,
494  DDS_SampleRejectedStatus status);
500  void (*on_liveliness_changed)(DDS_DataReader the_reader,
507  void (*on_data_available)(DDS_DataReader the_reader);
513  void (*on_subscription_matched)(DDS_DataReader the_reader,
520  void (*on_sample_lost)(DDS_DataReader the_reader,
521  DDS_SampleLostStatus status);
534  {
541  void (*on_requested_deadline_missed)(struct DDS_DataReaderListener_cd * self,
542  DDS_DataReader the_reader,
544  void * callback_data);
552  DDS_DataReader the_reader,
554  void * callback_data);
561  DDS_DataReader the_reader,
562  DDS_SampleRejectedStatus status,
563  void * callback_data);
570  DDS_DataReader the_reader,
572  void * callback_data);
579  DDS_DataReader the_reader,
580  void * callback_data);
587  DDS_DataReader the_reader,
589  void * callback_data);
596  DDS_DataReader the_reader,
597  DDS_SampleLostStatus status,
598  void * callback_data);
600 
612  typedef struct DDS_SubscriberListener
613  {
622  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
633  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
643  void (*on_sample_rejected)(DDS_DataReader the_reader,
644  DDS_SampleRejectedStatus status);
653  void (*on_liveliness_changed)(DDS_DataReader the_reader,
663  void (*on_data_available)(DDS_DataReader the_reader);
672  void (*on_subscription_matched)(DDS_DataReader the_reader,
682  void (*on_sample_lost)(DDS_DataReader the_reader,
683  DDS_SampleLostStatus status);
690  void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
692 
704  {
713  void (*on_requested_deadline_missed)(struct DDS_SubscriberListener_cd * self,
714  DDS_DataReader the_reader,
716  void * callback_data);
727  DDS_DataReader the_reader,
729  void * callback_data);
739  DDS_DataReader the_reader,
740  DDS_SampleRejectedStatus status,
741  void * callback_data);
751  DDS_DataReader the_reader,
753  void * callback_data);
763  DDS_DataReader the_reader,
764  void * callback_data);
774  DDS_DataReader the_reader,
776  void * callback_data);
786  DDS_DataReader the_reader,
787  DDS_SampleLostStatus status,
788  void * callback_data);
796  DDS_Subscriber the_subscriber,
797  void * callback_data);
799 
800 
801 
814  {
824  void (*on_inconsistent_topic)(DDS_Topic the_topic,
836  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
848  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
859  void (*on_liveliness_lost)(DDS_DataWriter writer,
860  DDS_LivelinessLostStatus status);
870  void (*on_publication_matched)(DDS_DataWriter writer,
872 
883  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
895  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
906  void (*on_sample_rejected)(DDS_DataReader the_reader,
907  DDS_SampleRejectedStatus status);
918  void (*on_liveliness_changed)(DDS_DataReader the_reader,
929  void (*on_data_available)(DDS_DataReader the_reader);
939  void (*on_subscription_matched)(DDS_DataReader the_reader,
950  void (*on_sample_lost)(DDS_DataReader the_reader,
951  DDS_SampleLostStatus status);
961  void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
963 
964 
976  {
987  DDS_Topic the_topic,
989  void * callback_data);
1001  DDS_DataWriter writer,
1003  void * callback_data);
1015  DDS_DataWriter writer,
1017  void * callback_data);
1028  DDS_DataWriter writer,
1029  DDS_LivelinessLostStatus status,
1030  void * callback_data);
1041  DDS_DataWriter writer,
1043  void * callback_data);
1044 
1056  DDS_DataReader the_reader,
1058  void * callback_data);
1070  DDS_DataReader the_reader,
1072  void * callback_data);
1083  DDS_DataReader the_reader,
1084  DDS_SampleRejectedStatus status,
1085  void * callback_data);
1097  DDS_DataReader the_reader,
1099  void * callback_data);
1110  DDS_DataReader the_reader,
1111  void * callback_data);
1122  DDS_DataReader the_reader,
1124  void * callback_data);
1135  DDS_DataReader the_reader,
1136  DDS_SampleLostStatus status,
1137  void * callback_data);
1148  DDS_Subscriber the_subscriber,
1149  void * callback_data);
1151 
1152  /***********************************************************
1153  * QOS *
1154  ***********************************************************/
1155  COREDX_C_API const char * DDS_USERDATA_QOS_POLICY_NAME;
1156  COREDX_C_API const char * DDS_DURABILITY_QOS_POLICY_NAME;
1157  COREDX_C_API const char * DDS_PRESENTATION_QOS_POLICY_NAME;
1158  COREDX_C_API const char * DDS_DEADLINE_QOS_POLICY_NAME;
1159  COREDX_C_API const char * DDS_LATENCYBUDGET_QOS_POLICY_NAME;
1160  COREDX_C_API const char * DDS_OWNERSHIP_QOS_POLICY_NAME;
1161  COREDX_C_API const char * DDS_OWNERSHIPSTRENGTH_QOS_POLICY_NAME;
1162  COREDX_C_API const char * DDS_LIVELINESS_QOS_POLICY_NAME;
1163  COREDX_C_API const char * DDS_TIMEBASEDFILTER_QOS_POLICY_NAME;
1164  COREDX_C_API const char * DDS_PARTITION_QOS_POLICY_NAME;
1165  COREDX_C_API const char * DDS_RELIABILITY_QOS_POLICY_NAME;
1166  COREDX_C_API const char * DDS_DESTINATIONORDER_QOS_POLICY_NAME;
1167  COREDX_C_API const char * DDS_HISTORY_QOS_POLICY_NAME;
1168  COREDX_C_API const char * DDS_RESOURCELIMITS_QOS_POLICY_NAME;
1169  COREDX_C_API const char * DDS_ENTITYFACTORY_QOS_POLICY_NAME;
1170  COREDX_C_API const char * DDS_WRITERDATALIFECYCLE_QOS_POLICY_NAME;
1171  COREDX_C_API const char * DDS_READERDATALIFECYCLE_QOS_POLICY_NAME;
1172  COREDX_C_API const char * DDS_TOPICDATA_QOS_POLICY_NAME;
1173  COREDX_C_API const char * DDS_GROUPDATA_QOS_POLICY_NAME;
1174  COREDX_C_API const char * DDS_TRANSPORTPRIORITY_QOS_POLICY_NAME;
1175  COREDX_C_API const char * DDS_LIFESPAN_QOS_POLICY_NAME;
1176  COREDX_C_API const char * DDS_DURABILITYSERVICE_POLICY_NAME;
1177  COREDX_C_API const char * DDS_DATA_REPRESENTATION_POLICY_NAME;
1178  COREDX_C_API const char * DDS_TYPE_CONSISTENCY_ENFORCEMENT_POLICY_NAME;
1179 
1197 
1210 
1222 
1223  /* CoreDX QoS Extensions:
1224  */
1232  #define COREDX_ENTITY_NAME_MAX 32
1233  char value[COREDX_ENTITY_NAME_MAX];
1235 #define DDS_EntityNameQosPolicy CoreDX_EntityNameQosPolicy
1236 
1249  typedef struct CoreDX_LoggingQosPolicy {
1250  uint32_t flags;
1251  /*
1252  logging uri examples:
1253  'file:///tmp/dds.log',
1254  'stdout',
1255  'stderr'
1256  */
1257 #define COREDX_LOGGING_URI_MAX 256
1258  char uri[COREDX_LOGGING_URI_MAX];
1260 #define DDS_LoggingQosPolicy CoreDX_LoggingQosPolicy
1261 
1262 #define COREDX_RESERVED_LOCATOR_KIND_QOS 0
1263 #define COREDX_UDPV4_LOCATOR_KIND_QOS 1
1264 #define COREDX_UDPV6_LOCATOR_KIND_QOS 2
1265 #define COREDX_UDS_LOCATOR_KIND_QOS 4
1266 #define COREDX_TCPV4_LOCATOR_KIND_QOS 0x8001
1267 #define COREDX_TCPV6_LOCATOR_KIND_QOS 0x8002
1268 #define COREDX_RESV2_LOCATOR_KIND_QOS 0x8003
1269 #define COREDX_LMT_LOCATOR_KIND_QOS 0x8004
1270 #define COREDX_SSLV4_LOCATOR_KIND_QOS 0x8005 /* SSL over IPv4 */
1271 #define COREDX_SSLV6_LOCATOR_KIND_QOS 0x8006 /* SSL over IPv6 */
1272 #define COREDX_SSLCLIENT_LOCATOR_KIND_QOS 0x8007 /* SSL CLIENT (GUID) */
1273 #define COREDX_INT178_LOCATOR_KIND_QOS 0x8008 /* INT178 SHM */
1274 #define COREDX_APEX_LOCATOR_KIND_QOS 0x8009 /* APEX (ARINC-653 PORTS) */
1275 
1276 
1277 #define COREDX_LOCATOR_ADDR_LEN (16)
1278 
1284  typedef struct CoreDX_Locator_t {
1285  int kind;
1286  uint32_t port;
1287  unsigned char addr[COREDX_LOCATOR_ADDR_LEN];
1288  } CoreDX_Locator;
1289  DECLARE_SEQ(CoreDX_Locator, CoreDX_LocatorSeq);
1290 
1294  typedef struct CoreDX_ParticipantLocator_t {
1295  uint32_t participant_id;
1299  DECLARE_SEQ(CoreDX_ParticipantLocator, CoreDX_ParticipantLocatorSeq);
1300 
1306  typedef struct CoreDX_PeerParticipantQosPolicy_t {
1307  CoreDX_ParticipantLocatorSeq value;
1308  unsigned char strict_match;
1310 #define DDS_PeerParticipantQosPolicy CoreDX_PeerParticipantQosPolicy
1311 
1312  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_init( CoreDX_PeerParticipantQosPolicy * p );
1313  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_clear( CoreDX_PeerParticipantQosPolicy * p );
1314  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_copy( CoreDX_PeerParticipantQosPolicy * to,
1315  const CoreDX_PeerParticipantQosPolicy * from );
1316 
1324  uint32_t min_buffer_size;
1325  uint32_t max_buffer_size;
1326  unsigned char apply_filters;
1327  unsigned char enable_batch_msg;
1328  unsigned char send_typecode;
1329  unsigned char require_acks;
1332 #define DDS_RTPSWriterQosPolicy CoreDX_RTPSWriterQosPolicy
1333 
1338  unsigned char accept_batch_msg;
1339  unsigned char send_typecode;
1340  unsigned char send_initial_nack;
1342  CoreDX_LocatorSeq locators;
1344 #define DDS_RTPSReaderQosPolicy CoreDX_RTPSReaderQosPolicy
1345  COREDX_C_API void DDS_RTPSReaderQosPolicy_init ( DDS_RTPSReaderQosPolicy * p );
1346  COREDX_C_API void DDS_RTPSReaderQosPolicy_clear( DDS_RTPSReaderQosPolicy * p );
1347  COREDX_C_API void DDS_RTPSReaderQosPolicy_copy ( DDS_RTPSReaderQosPolicy * to,
1348  const DDS_RTPSReaderQosPolicy * from );
1349 
1350 
1358 
1361  typedef struct CoreDX_DiscoveryQosPolicy {
1362  DDS_DiscoveryQosPolicyDiscoveryKind discovery_kind;
1363  DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE guid_pid;
1365  /* configure Participant Writer */
1369  /* configure Pub/Sub/Topic Builtin writers: */
1373  uint32_t min_buffer_size;
1374  uint32_t max_buffer_size;
1376  /* configure Builtin readers: */
1378  unsigned char send_initial_nack;
1380  /* configure RTPS msglen submessage */
1381  unsigned char send_msglen_submsg;
1383 #define DDS_DiscoveryQosPolicy CoreDX_DiscoveryQosPolicy
1384 
1389  unsigned char use_threads;
1390  unsigned char create_listener_thread;
1392 #define DDS_ThreadModelQosPolicy CoreDX_ThreadModelQosPolicy
1393 
1403 #define DDS_DomainParticipantFactoryQos__alloc DDS_DomainParticipantFactoryQos_alloc
1404  COREDX_C_API DDS_DomainParticipantFactoryQos * DDS_DomainParticipantFactoryQos_alloc(void);
1405  COREDX_C_API void DDS_DomainParticipantFactoryQos_destroy(DDS_DomainParticipantFactoryQos * qos);
1406  COREDX_C_API void DDS_DomainParticipantFactoryQos_init(DDS_DomainParticipantFactoryQos * qos);
1407  COREDX_C_API void DDS_DomainParticipantFactoryQos_clear(DDS_DomainParticipantFactoryQos * qos);
1408  COREDX_C_API void DDS_DomainParticipantFactoryQos_copy(DDS_DomainParticipantFactoryQos * to, const DDS_DomainParticipantFactoryQos * from);
1409 
1419  typedef struct DDS_DomainParticipantQos {
1430 #define DDS_DomainParticipantQos__alloc DDS_DomainParticipantQos_alloc
1431  COREDX_C_API DDS_DomainParticipantQos * DDS_DomainParticipantQos_alloc(void);
1432  COREDX_C_API void DDS_DomainParticipantQos_destroy(DDS_DomainParticipantQos * qos);
1433  COREDX_C_API void DDS_DomainParticipantQos_init(DDS_DomainParticipantQos * qos);
1434  COREDX_C_API void DDS_DomainParticipantQos_clear(DDS_DomainParticipantQos * qos);
1435  COREDX_C_API void DDS_DomainParticipantQos_copy(DDS_DomainParticipantQos * to, const DDS_DomainParticipantQos * from);
1436 
1437 #define DDS_DATAWRITER_QOS_USE_TOPIC_QOS (void*)(-1)
1438 #define DDS_DATAREADER_QOS_USE_TOPIC_QOS (void*)(-1)
1439 
1448  typedef struct DDS_TopicQos {
1468  } DDS_TopicQos;
1469 #define DDS_TopicQos__alloc DDS_TopicQos_alloc
1470  COREDX_C_API DDS_TopicQos * DDS_TopicQos_alloc(void);
1471  COREDX_C_API void DDS_TopicQos_destroy(DDS_TopicQos * qos);
1472  COREDX_C_API void DDS_TopicQos_init(DDS_TopicQos * qos);
1473  COREDX_C_API void DDS_TopicQos_clear(DDS_TopicQos * qos);
1474  COREDX_C_API void DDS_TopicQos_copy(DDS_TopicQos * to, const DDS_TopicQos * from);
1475 
1485  typedef struct DDS_DataWriterQos {
1506  /* RPC extensions: */
1510  /* Security extensions: */
1511  DDS_DataTagQosPolicy data_tags;
1516 #define DDS_DataWriterQos__alloc DDS_DataWriterQos_alloc
1517  COREDX_C_API DDS_DataWriterQos * DDS_DataWriterQos_alloc(void);
1518  COREDX_C_API void DDS_DataWriterQos_destroy(DDS_DataWriterQos * qos);
1519  COREDX_C_API void DDS_DataWriterQos_init(DDS_DataWriterQos * qos);
1520  COREDX_C_API void DDS_DataWriterQos_clear(DDS_DataWriterQos * qos);
1521  COREDX_C_API void DDS_DataWriterQos_copy(DDS_DataWriterQos * to, const DDS_DataWriterQos * from);
1522 
1532  typedef struct DDS_PublisherQos {
1550  } DDS_PublisherQos;
1551 #define DDS_PublisherQos__alloc DDS_PublisherQos_alloc
1552  COREDX_C_API DDS_PublisherQos * DDS_PublisherQos_alloc(void);
1553  COREDX_C_API void DDS_PublisherQos_destroy(DDS_PublisherQos * qos);
1554  COREDX_C_API void DDS_PublisherQos_init(DDS_PublisherQos * qos);
1555  COREDX_C_API void DDS_PublisherQos_clear(DDS_PublisherQos * qos);
1556  COREDX_C_API void DDS_PublisherQos_copy(DDS_PublisherQos * to, const DDS_PublisherQos * from);
1557 
1567  typedef struct DDS_DataReaderQos {
1589  /* RPC extensions: */
1593  /* Security extensions: */
1594  DDS_DataTagQosPolicy data_tags;
1595  /* CoreDX DDS extensions: */
1600 #define DDS_DataReaderQos__alloc DDS_DataReaderQos_alloc
1601  COREDX_C_API DDS_DataReaderQos * DDS_DataReaderQos_alloc(void);
1602  COREDX_C_API void DDS_DataReaderQos_destroy(DDS_DataReaderQos * qos);
1603  COREDX_C_API void DDS_DataReaderQos_init(DDS_DataReaderQos * qos);
1604  COREDX_C_API void DDS_DataReaderQos_clear(DDS_DataReaderQos * qos);
1605  COREDX_C_API void DDS_DataReaderQos_copy(DDS_DataReaderQos * to, const DDS_DataReaderQos * from);
1606 
1616  typedef struct DDS_SubscriberQos {
1634 #define DDS_SubscriberQos__alloc DDS_SubscriberQos_alloc
1635  COREDX_C_API DDS_SubscriberQos * DDS_SubscriberQos_alloc(void);
1636  COREDX_C_API void DDS_SubscriberQos_destroy(DDS_SubscriberQos * qos);
1637  COREDX_C_API void DDS_SubscriberQos_init(DDS_SubscriberQos * qos);
1638  COREDX_C_API void DDS_SubscriberQos_clear(DDS_SubscriberQos * qos);
1639  COREDX_C_API void DDS_SubscriberQos_copy(DDS_SubscriberQos * to, const DDS_SubscriberQos * from);
1640 
1641 #define DDS_PARTICIPANT_QOS_DEFAULT NULL
1642 #define DDS_TOPIC_QOS_DEFAULT NULL
1643 #define DDS_PUBLISHER_QOS_DEFAULT NULL
1644 #define DDS_SUBSCRIBER_QOS_DEFAULT NULL
1645 #define DDS_DATAWRITER_QOS_DEFAULT NULL
1646 #define DDS_DATAREADER_QOS_DEFAULT NULL
1647 
1648  /****************************************************
1649  ** **
1650  ** CONDITION **
1651  ** **
1652  ****************************************************/
1665  COREDX_C_API unsigned char DDS_Condition_get_trigger_value(DDS_Condition c);
1666 
1667  /****************************************************
1668  ** **
1669  ** GUARD CONDITION **
1670  ** **
1671  ****************************************************/
1681  COREDX_C_API DDS_GuardCondition DDS_GuardCondition__alloc( void );
1687  COREDX_C_API void DDS_GuardCondition__free(struct _GuardCondition * gc);
1693  COREDX_C_API unsigned char DDS_GuardCondition_get_trigger_value(DDS_GuardCondition gc);
1704  COREDX_C_API DDS_ReturnCode_t DDS_GuardCondition_set_trigger_value(DDS_GuardCondition gc,
1705  unsigned char v );
1706 
1707  /****************************************************
1708  ** **
1709  ** STATUS CONDITION **
1710  ** **
1711  ****************************************************/
1722  COREDX_C_API unsigned char DDS_StatusCondition_get_trigger_value ( DDS_StatusCondition sc);
1727  COREDX_C_API DDS_StatusMask DDS_StatusCondition_get_enabled_statuses( DDS_StatusCondition sc);
1732  COREDX_C_API DDS_ReturnCode_t DDS_StatusCondition_set_enabled_statuses( DDS_StatusCondition sc,
1733  DDS_StatusMask mask );
1737  COREDX_C_API DDS_Entity DDS_StatusCondition_get_entity( DDS_StatusCondition sc);
1738 
1739  /****************************************************
1740  ** **
1741  ** READ CONDITION **
1742  ** **
1743  ****************************************************/
1757  COREDX_C_API unsigned char DDS_ReadCondition_get_trigger_value ( DDS_ReadCondition rc);
1761  COREDX_C_API DDS_DataReader DDS_ReadCondition_get_datareader ( DDS_ReadCondition rc);
1765  COREDX_C_API DDS_SampleStateKind DDS_ReadCondition_get_sample_state_mask ( DDS_ReadCondition rc);
1769  COREDX_C_API DDS_ViewStateKind DDS_ReadCondition_get_view_state_mask ( DDS_ReadCondition rc);
1773  COREDX_C_API DDS_InstanceStateKind DDS_ReadCondition_get_instance_state_mask( DDS_ReadCondition rc);
1774 
1775  /****************************************************
1776  ** **
1777  ** QUERY CONDITION **
1778  ** **
1779  ****************************************************/
1792  COREDX_C_API unsigned char DDS_QueryCondition_get_trigger_value ( DDS_QueryCondition qc);
1796  COREDX_C_API DDS_DataReader DDS_QueryCondition_get_datareader ( DDS_QueryCondition qc);
1800  COREDX_C_API DDS_SampleStateKind DDS_QueryCondition_get_sample_state_mask ( DDS_QueryCondition qc);
1804  COREDX_C_API DDS_ViewStateKind DDS_QueryCondition_get_view_state_mask ( DDS_QueryCondition qc);
1808  COREDX_C_API DDS_InstanceStateKind DDS_QueryCondition_get_instance_state_mask( DDS_QueryCondition qc);
1815  COREDX_C_API const char * DDS_QueryCondition_get_query_expression ( DDS_QueryCondition qc);
1827  COREDX_C_API DDS_ReturnCode_t DDS_QueryCondition_get_query_parameters ( DDS_QueryCondition qc,
1828  DDS_StringSeq *seq);
1844  COREDX_C_API DDS_ReturnCode_t DDS_QueryCondition_set_query_parameters ( DDS_QueryCondition qc,
1845  DDS_StringSeq *parameters);
1846 
1847  /****************************************************
1848  ** **
1849  ** WAIT SET **
1850  ** **
1851  ****************************************************/
1864  COREDX_C_API DDS_WaitSet DDS_WaitSet__alloc( void );
1872  COREDX_C_API void DDS_WaitSet__free(DDS_WaitSet ws);
1873 
1888  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_wait(DDS_WaitSet ws,
1889  DDS_ConditionSeq * active_conditions,
1890  DDS_Duration_t * timeout );
1891 
1892  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_wait_ex( DDS_DomainParticipant dp,
1893  struct _WaitSet * ws,
1894  DDS_ConditionSeq * active_conditions,
1895  DDS_Duration_t * timeout );
1902  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_attach_condition( DDS_WaitSet ws,
1903  DDS_Condition c );
1909  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_detach_condition( DDS_WaitSet ws,
1910  DDS_Condition c );
1916  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_get_conditions ( DDS_WaitSet ws,
1917  DDS_ConditionSeq * attached_conditions);
1918 
1919  /****************************************************
1920  ** **
1921  ** ENTITY **
1922  ** **
1923  ****************************************************/
1924  /*DDS_ReturnCode_t DDS_Entity_enable ( DDS_Entity e ); */
1925  /*unsigned char DDS_Entity_is_enabled ( DDS_Entity e ); */
1926  COREDX_C_API DDS_StatusCondition DDS_Entity_get_statuscondition( DDS_Entity e );
1927  COREDX_C_API DDS_StatusMask DDS_Entity_get_status_changes ( DDS_Entity e );
1928  COREDX_C_API DDS_InstanceHandle_t DDS_Entity_get_instance_handle( DDS_Entity e );
1929 
1930  /****************************************************
1931  ** **
1932  ** DOMAIN PARTICIPANT FACTORY **
1933  ** **
1934  ****************************************************/
1943  COREDX_C_API DDS_DomainParticipantFactory DDS_DomainParticipantFactory_get_instance( void );
1944 
1945 
1957  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_create_participant_ex( DDS_DomainParticipantFactory dpf,
1958  DDS_DomainId_t domain_id,
1959  DDS_DomainParticipantQos * qos,
1960  DDS_DomainParticipantListener * a_listener,
1961  DDS_StatusMask mask);
1962 
1975  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_create_participant( DDS_DomainId_t domain_id,
1976  DDS_DomainParticipantQos * qos,
1977  DDS_DomainParticipantListener * a_listener,
1978  DDS_StatusMask mask);
1979 
1986  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_license ( const char * lic );
1987 
1994  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_license_debug ( unsigned char debug );
1995 
1996 
2003  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_delete_participant ( DDS_DomainParticipant a_participant );
2009  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_lookup_participant ( DDS_DomainId_t domain_id );
2017  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_default_participant_qos ( const DDS_DomainParticipantQos * qos );
2022  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_get_default_participant_qos ( DDS_DomainParticipantQos * qos);
2029  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_qos ( const DDS_DomainParticipantFactoryQos * qos );
2034  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_get_qos ( DDS_DomainParticipantFactoryQos * qos );
2035 
2042  COREDX_C_API char * CoreDX_DDS_get_lib_version(void);
2043 
2051  COREDX_C_API DDS_ReturnCode_t CoreDX_DDS_get_lib_version_string( char * vstring_buf,
2052  int buf_len );
2053 
2054  /****************************************************
2055  ** **
2056  ** DOMAIN PARTICIPANT **
2057  ** **
2058  ****************************************************/
2085  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_enable ( DDS_DomainParticipant dp );
2086  COREDX_C_API unsigned char DDS_DomainParticipant_is_enabled ( DDS_DomainParticipant dp );
2091  COREDX_C_API DDS_InstanceHandle_t DDS_DomainParticipant_get_instance_handle( DDS_DomainParticipant dp );
2096  COREDX_C_API DDS_StatusCondition DDS_DomainParticipant_get_statuscondition( DDS_DomainParticipant dp );
2105  COREDX_C_API DDS_StatusMask DDS_DomainParticipant_get_status_changes ( DDS_DomainParticipant dp );
2113  COREDX_C_API DDS_Publisher DDS_DomainParticipant_create_publisher ( DDS_DomainParticipant dp,
2114  DDS_PublisherQos * qos,
2115  DDS_PublisherListener * a_listener,
2116  DDS_StatusMask mask);
2124  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_publisher ( DDS_DomainParticipant dp,
2125  DDS_Publisher p);
2133  COREDX_C_API DDS_Subscriber DDS_DomainParticipant_create_subscriber( DDS_DomainParticipant dp,
2134  DDS_SubscriberQos * qos,
2135  DDS_SubscriberListener * a_listener,
2136  DDS_StatusMask mask);
2144  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_subscriber( DDS_DomainParticipant dp,
2145  DDS_Subscriber s);
2156  COREDX_C_API DDS_Subscriber DDS_DomainParticipant_get_builtin_subscriber( struct _DomainParticipant *d );
2157 
2169  COREDX_C_API DDS_Topic DDS_DomainParticipant_create_topic( DDS_DomainParticipant dp,
2170  const char * topic_name,
2171  const char * type_name,
2172  DDS_TopicQos * qos,
2173  DDS_TopicListener * a_listener,
2174  DDS_StatusMask mask);
2183  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_topic( DDS_DomainParticipant dp,
2184  DDS_Topic a_topic);
2197  COREDX_C_API DDS_Topic DDS_DomainParticipant_find_topic( DDS_DomainParticipant dp,
2198  const char * topic_name,
2199  DDS_Duration_t * timeout);
2205  COREDX_C_API DDS_TopicDescription DDS_DomainParticipant_lookup_topicdescription( DDS_DomainParticipant dp,
2206  const char * name);
2238  COREDX_C_API DDS_ContentFilteredTopic DDS_DomainParticipant_create_contentfilteredtopic( DDS_DomainParticipant dp,
2239  const char * name,
2240  const DDS_Topic related_topic,
2241  const char * filter_expression,
2242  const DDS_StringSeq * filter_parameters);
2252  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_contentfilteredtopic( DDS_DomainParticipant dp,
2253  DDS_ContentFilteredTopic a_contentfilteredtopic);
2259  COREDX_C_API DDS_MultiTopic DDS_DomainParticipant_create_multitopic( DDS_DomainParticipant dp,
2260  const char * name,
2261  const char * type_name,
2262  const char * subscription_expression,
2263  const DDS_StringSeq * expression_parameters);
2269  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_multitopic( DDS_DomainParticipant dp,
2270  DDS_MultiTopic a_multitopic);
2271 
2281  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_contained_entities( DDS_DomainParticipant dp );
2286  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_qos( DDS_DomainParticipant dp,
2287  const DDS_DomainParticipantQos * qos);
2293  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_qos( DDS_DomainParticipant dp,
2294  DDS_DomainParticipantQos * qos);
2303  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_listener( DDS_DomainParticipant dp,
2304  DDS_DomainParticipantListener * a_listener,
2305  DDS_StatusMask mask);
2306 
2315  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_listener_cd( DDS_DomainParticipant dp,
2316  DDS_DomainParticipantListener_cd * a_listener,
2317  DDS_StatusMask mask,
2318  void * callback_data);
2328  COREDX_C_API DDS_DomainParticipantListener * DDS_DomainParticipant_get_listener( DDS_DomainParticipant dp );
2337  COREDX_C_API DDS_DomainParticipantListener_cd * DDS_DomainParticipant_get_listener_cd( DDS_DomainParticipant dp );
2346  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_participant ( DDS_DomainParticipant dp,
2347  const DDS_InstanceHandle_t handle);
2356  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_topic ( DDS_DomainParticipant dp,
2357  const DDS_InstanceHandle_t handle);
2365  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_publication ( DDS_DomainParticipant dp,
2366  const DDS_InstanceHandle_t handle);
2374  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_subscription ( DDS_DomainParticipant dp,
2375  const DDS_InstanceHandle_t handle);
2380  COREDX_C_API DDS_DomainId_t DDS_DomainParticipant_get_domain_id( DDS_DomainParticipant dp );
2381 
2393  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_assert_liveliness( DDS_DomainParticipant dp );
2394 
2402  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_publisher_qos( DDS_DomainParticipant d,
2403  const DDS_PublisherQos * qos);
2404 
2409  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_publisher_qos( DDS_DomainParticipant d,
2410  DDS_PublisherQos * qos);
2418  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_subscriber_qos( DDS_DomainParticipant d,
2419  const DDS_SubscriberQos * qos);
2424  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_subscriber_qos( DDS_DomainParticipant d,
2425  DDS_SubscriberQos * qos);
2433  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_topic_qos( DDS_DomainParticipant d,
2434  const DDS_TopicQos * qos);
2439  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_topic_qos( DDS_DomainParticipant d,
2440  DDS_TopicQos * qos);
2448  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_participants( DDS_DomainParticipant d,
2449  DDS_InstanceHandleSeq * participant_handles );
2457  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_participant_data( DDS_DomainParticipant d,
2458  DDS_ParticipantBuiltinTopicData * participant_data,
2459  const DDS_InstanceHandle_t participant_handle);
2467  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topics( DDS_DomainParticipant d,
2468  DDS_InstanceHandleSeq * topic_handles);
2476  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topic_data( DDS_DomainParticipant d,
2477  DDS_TopicBuiltinTopicData * topic_data,
2478  const DDS_InstanceHandle_t topic_handle);
2479 
2487  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_publication_data( DDS_DomainParticipant dp,
2488  DDS_PublicationBuiltinTopicData * publication_data,
2489  const DDS_InstanceHandle_t publication_handle);
2497  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_subscription_data( DDS_DomainParticipant dp,
2498  DDS_SubscriptionBuiltinTopicData * subscription_data,
2499  const DDS_InstanceHandle_t subscription_handle);
2500 
2508  COREDX_C_API unsigned char DDS_DomainParticipant_contains_entity( DDS_DomainParticipant d,
2509  const DDS_InstanceHandle_t a_handle);
2514  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_current_time( DDS_DomainParticipant d,
2515  DDS_Time_t * current_time);
2523  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_register_type( DDS_DomainParticipant dp,
2524  DDS_TypeSupport ts,
2525  const char * type_name );
2544  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_unregister_type( DDS_DomainParticipant dp,
2545  const char * type_name );
2555  COREDX_C_API int DDS_DomainParticipant_check_version( DDS_DomainParticipant dp,
2556  const char * major,
2557  const char * minor,
2558  const char * patch);
2565  COREDX_C_API int DDS_DomainParticipant_validate_version( DDS_DomainParticipant dp,
2566  const char * source,
2567  const char * major,
2568  const char * minor,
2569  const char * patch);
2581  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_do_work( DDS_DomainParticipant dp,
2582  const DDS_Duration_t *time_slice );
2587  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_builtin_wait_for_acknowledgments( DDS_DomainParticipant dp,
2588  const DDS_Duration_t *max_wait );
2594  COREDX_C_API void DDS_DomainParticipant_print_stats(DDS_DomainParticipant dp,
2595  const char * topic_name);
2596  /* debug: */
2597  COREDX_C_API void DDS_DomainParticipant_get_topic_stats_str( DDS_DomainParticipant dp,
2598  const char * topic_name,
2599  DDS_OctetSeq * oseq );
2600  COREDX_C_API void DDS_DomainParticipant_get_topic_stats( DDS_DomainParticipant dp,
2601  const char * topic_name,
2602  CoreDX_TopicStats_t * topic_stats );
2613  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_add_transport(DDS_DomainParticipant dp,
2614  struct CoreDX_Transport * transport);
2619  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_guid(DDS_DomainParticipant dp,
2620  DDS_GUID_t * guid);
2631  COREDX_C_DYNTYPE_API DDS_ReturnCode_t DDS_DomainParticipant_create_typesupport_from_typecode( DDS_DomainParticipant dp,
2632  DDS_TypecodeQosPolicy * tc_qos,
2633  DDS_TypeSupport * ts /* out */);
2644  COREDX_C_DYNTYPE_API DDS_ReturnCode_t DDS_DomainParticipant_create_typesupport_from_typeobj( DDS_DomainParticipant dp,
2645  DDS_TypecodeQosPolicy * tc_qos,
2646  DDS_TypeSupport * ts /* out */);
2647 
2648 
2649  /****************************************************
2650  ** **
2651  ** SUBSCRIBER **
2652  ** **
2653  ****************************************************/
2674  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_enable ( DDS_Subscriber s );
2675  COREDX_C_API unsigned char DDS_Subscriber_is_enabled ( DDS_Subscriber s );
2680  COREDX_C_API DDS_InstanceHandle_t DDS_Subscriber_get_instance_handle( DDS_Subscriber s );
2685  COREDX_C_API DDS_DomainParticipant DDS_Subscriber_get_participant ( DDS_Subscriber s );
2690  COREDX_C_API DDS_StatusCondition DDS_Subscriber_get_statuscondition( DDS_Subscriber s );
2699  COREDX_C_API DDS_StatusMask DDS_Subscriber_get_status_changes ( DDS_Subscriber s );
2713  COREDX_C_API DDS_DataReader DDS_Subscriber_create_datareader ( DDS_Subscriber s,
2714  DDS_TopicDescription a_topic,
2715  DDS_DataReaderQos * qos,
2716  DDS_DataReaderListener* a_listener,
2717  DDS_StatusMask mask);
2727  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_delete_datareader ( DDS_Subscriber s,
2728  DDS_DataReader a_datareader);
2739  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_delete_contained_entities( DDS_Subscriber s );
2747  COREDX_C_API DDS_DataReader DDS_Subscriber_lookup_datareader( DDS_Subscriber s,
2748  const char * topic_name);
2765  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_datareaders( DDS_Subscriber s,
2766  DDS_DataReaderSeq * readers,
2767  DDS_SampleStateMask sample_states,
2768  DDS_ViewStateMask view_states,
2769  DDS_InstanceStateMask instance_states) ;
2775  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_notify_datareaders( DDS_Subscriber s );
2780  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_qos( DDS_Subscriber s,
2781  DDS_SubscriberQos * qos);
2794  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_qos( DDS_Subscriber s,
2795  DDS_SubscriberQos * qos);
2804  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_listener( DDS_Subscriber s,
2805  DDS_SubscriberListener * a_listener,
2806  DDS_StatusMask mask);
2815  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_listener_cd( DDS_Subscriber s,
2816  DDS_SubscriberListener_cd * listener_cd,
2817  DDS_StatusMask mask,
2818  void * callback_data);
2828  COREDX_C_API DDS_SubscriberListener *DDS_Subscriber_get_listener( DDS_Subscriber s );
2837  COREDX_C_API DDS_SubscriberListener_cd *DDS_Subscriber_get_listener_cd( DDS_Subscriber s );
2845  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_begin_access( DDS_Subscriber s );
2850  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_end_access( DDS_Subscriber s );
2859  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_default_datareader_qos( DDS_Subscriber s,
2860  const DDS_DataReaderQos * qos);
2865  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_default_datareader_qos( DDS_Subscriber s,
2866  DDS_DataReaderQos * qos);
2873  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_copy_from_topic_qos( DDS_Subscriber s,
2874  DDS_DataReaderQos * a_datareader_qos,
2875  DDS_TopicQos * a_topic_qos);
2876 
2877 
2878  /****************************************************
2879  ** **
2880  ** PUBLISHER **
2881  ** **
2882  ****************************************************/
2903  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_enable ( DDS_Publisher p );
2904  COREDX_C_API unsigned char DDS_Publisher_is_enabled ( DDS_Publisher p );
2909  COREDX_C_API DDS_InstanceHandle_t DDS_Publisher_get_instance_handle( DDS_Publisher p );
2914  COREDX_C_API DDS_DomainParticipant DDS_Publisher_get_participant ( DDS_Publisher p );
2919  COREDX_C_API DDS_StatusCondition DDS_Publisher_get_statuscondition( DDS_Publisher p );
2928  COREDX_C_API DDS_StatusMask DDS_Publisher_get_status_changes ( DDS_Publisher p );
2942  COREDX_C_API DDS_DataWriter DDS_Publisher_create_datawriter ( DDS_Publisher p,
2943  DDS_Topic a_topic,
2944  const DDS_DataWriterQos * qos,
2945  DDS_DataWriterListener * a_listener,
2946  DDS_StatusMask mask);
2952  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_delete_datawriter (DDS_Publisher p,
2953  DDS_DataWriter a_datawriter);
2960  COREDX_C_API DDS_DataWriter DDS_Publisher_lookup_datawriter(DDS_Publisher p,
2961  const char * topic_name);
2971  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_delete_contained_entities(DDS_Publisher p );
2976  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_qos( DDS_Publisher p,
2977  const DDS_PublisherQos * qos);
2991  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_get_qos( DDS_Publisher p,
2992  DDS_PublisherQos * qos);
3001  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_listener( DDS_Publisher p,
3002  DDS_PublisherListener * a_listener,
3003  DDS_StatusMask mask);
3012  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_listener_cd( DDS_Publisher p,
3013  DDS_PublisherListener_cd * a_listener,
3014  DDS_StatusMask mask,
3015  void * callback_data);
3025  COREDX_C_API DDS_PublisherListener *DDS_Publisher_get_listener(DDS_Publisher p );
3034  COREDX_C_API DDS_PublisherListener_cd *DDS_Publisher_get_listener_cd(DDS_Publisher p );
3038  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_suspend_publications(DDS_Publisher p );
3042  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_resume_publications(DDS_Publisher p );
3046  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_begin_coherent_changes(DDS_Publisher p );
3050  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_end_coherent_changes(DDS_Publisher p );
3059  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_wait_for_acknowledgments(DDS_Publisher p,
3060  const DDS_Duration_t * max_wait);
3061 #define DDS_Publisher_wait_for_acknowledgements DDS_Publisher_wait_for_acknowledgments
3062 
3071  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_default_datawriter_qos(DDS_Publisher p,
3072  const DDS_DataWriterQos * qos);
3077  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_get_default_datawriter_qos(DDS_Publisher p,
3078  struct DDS_DataWriterQos * qos);
3085  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_copy_from_topic_qos(DDS_Publisher p,
3086  struct DDS_DataWriterQos * a_datawriter_qos,
3087  const DDS_TopicQos * a_topic_qos);
3088 
3089  /****************************************************
3090  ** **
3091  ** TOPIC DESCRIPTION **
3092  ** **
3093  ****************************************************/
3104  COREDX_C_API const char * DDS_TopicDescription_get_type_name( DDS_TopicDescription td );
3109  COREDX_C_API const char * DDS_TopicDescription_get_name ( DDS_TopicDescription td );
3113  COREDX_C_API DDS_DomainParticipant DDS_TopicDescription_get_participant( DDS_TopicDescription td );
3114 
3115  /****************************************************
3116  ** **
3117  ** TOPIC **
3118  ** **
3119  ****************************************************/
3134  COREDX_C_API DDS_TopicDescription DDS_Topic_TopicDescription(DDS_Topic t);
3138  COREDX_C_API const char * DDS_Topic_get_type_name( DDS_Topic t);
3142  COREDX_C_API const char * DDS_Topic_get_name( DDS_Topic t ) ;
3146  COREDX_C_API DDS_DomainParticipant DDS_Topic_get_participant( DDS_Topic t );
3161  COREDX_C_API DDS_ReturnCode_t DDS_Topic_enable( DDS_Topic t );
3162  COREDX_C_API unsigned char DDS_Topic_is_enabled( DDS_Topic t );
3167  COREDX_C_API DDS_InstanceHandle_t DDS_Topic_get_instance_handle(DDS_Topic t);
3172  COREDX_C_API DDS_StatusCondition DDS_Topic_get_statuscondition( DDS_Topic t );
3178  COREDX_C_API DDS_StatusMask DDS_Topic_get_status_changes( DDS_Topic t );
3183  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_qos( DDS_Topic t,
3184  const DDS_TopicQos * qos);
3196  COREDX_C_API DDS_ReturnCode_t DDS_Topic_get_qos( DDS_Topic t,
3197  DDS_TopicQos * qos);
3206  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_listener( DDS_Topic t,
3207  DDS_TopicListener * a_listener,
3208  DDS_StatusMask mask);
3217  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_listener_cd( DDS_Topic t,
3218  DDS_TopicListener_cd * a_listener,
3219  DDS_StatusMask mask,
3220  void * callback_data);
3230  COREDX_C_API DDS_TopicListener * DDS_Topic_get_listener( DDS_Topic t );
3239  COREDX_C_API DDS_TopicListener_cd * DDS_Topic_get_listener_cd( DDS_Topic t );
3244  COREDX_C_API DDS_ReturnCode_t DDS_Topic_get_inconsistent_topic_status ( DDS_Topic t,
3245  DDS_InconsistentTopicStatus * a_status);
3246 
3247  /****************************************************
3248  ** **
3249  ** CONTENT FILTERED TOPIC **
3250  ** **
3251  ****************************************************/
3287  COREDX_C_API DDS_TopicDescription DDS_ContentFilteredTopic_TopicDescription(DDS_ContentFilteredTopic t);
3288  COREDX_C_API const char * DDS_ContentFilteredTopic_get_type_name( DDS_ContentFilteredTopic t);
3289  COREDX_C_API const char * DDS_ContentFilteredTopic_get_name( DDS_ContentFilteredTopic t );
3290  COREDX_C_API DDS_DomainParticipant DDS_ContentFilteredTopic_get_participant( DDS_Topic t );
3295  COREDX_C_API DDS_Topic DDS_ContentFilteredTopic_get_related_topic( DDS_ContentFilteredTopic t);
3300  COREDX_C_API DDS_ReturnCode_t DDS_ContentFilteredTopic_get_expression_parameters(DDS_ContentFilteredTopic t,
3301  DDS_StringSeq *parameters);
3312  COREDX_C_API DDS_ReturnCode_t DDS_ContentFilteredTopic_set_expression_parameters(DDS_ContentFilteredTopic t,
3313  const DDS_StringSeq *parameters);
3314 
3315  /****************************************************
3316  ** **
3317  ** MULTI TOPIC **
3318  ** **
3319  ****************************************************/
3328  COREDX_C_API DDS_TopicDescription DDS_MultiTopic_TopicDescription(DDS_MultiTopic t);
3329  COREDX_C_API const char * DDS_MultiTopic_get_type_name( DDS_MultiTopic t);
3330  COREDX_C_API const char * DDS_MultiTopic_get_name( DDS_MultiTopic t );
3331  COREDX_C_API DDS_DomainParticipant DDS_MultiTopic_get_participant( DDS_Topic t );
3332  COREDX_C_API DDS_ReturnCode_t DDS_MultiTopic_get_expression_parameters(DDS_MultiTopic t,
3333  DDS_StringSeq *parameters);
3334  COREDX_C_API DDS_ReturnCode_t DDS_MultiTopic_set_expression_parameters(DDS_MultiTopic t,
3335  const DDS_StringSeq *parameters);
3336 
3337  /****************************************************
3338  ** **
3339  ** DATA WRITER **
3340  ** **
3341  ****************************************************/
3363  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_enable ( DDS_DataWriter dw );
3364  COREDX_C_API unsigned char DDS_DataWriter_is_enabled ( DDS_DataWriter dw );
3369  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_get_instance_handle( DDS_DataWriter dw );
3374  COREDX_C_API DDS_StatusCondition DDS_DataWriter_get_statuscondition( DDS_DataWriter dw );
3380  COREDX_C_API DDS_StatusMask DDS_DataWriter_get_status_changes ( DDS_DataWriter dw );
3385  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_qos(DDS_DataWriter dw,
3386  const DDS_DataWriterQos * qos);
3398  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_qos(DDS_DataWriter dw,
3399  DDS_DataWriterQos * qos);
3408  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_listener(DDS_DataWriter dw,
3409  DDS_DataWriterListener * a_listener,
3410  DDS_StatusMask mask);
3419  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_listener_cd(DDS_DataWriter dw,
3420  DDS_DataWriterListener_cd * a_listener,
3421  DDS_StatusMask mask,
3422  void * callback_data);
3432  COREDX_C_API DDS_DataWriterListener * DDS_DataWriter_get_listener(DDS_DataWriter dw);
3441  COREDX_C_API DDS_DataWriterListener_cd * DDS_DataWriter_get_listener_cd(DDS_DataWriter dw);
3451  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_wait_for_acknowledgments(DDS_DataWriter dw,
3452  const DDS_Duration_t * max_wait);
3453 #define DDS_DataWriter_wait_for_acknowledgements DDS_DataWriter_wait_for_acknowledgments
3454 
3459  COREDX_C_API DDS_Topic DDS_DataWriter_get_topic(DDS_DataWriter dw);
3464  COREDX_C_API DDS_Publisher DDS_DataWriter_get_publisher(DDS_DataWriter dw);
3474  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_assert_liveliness(DDS_DataWriter dw);
3482  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_matched_subscriptions(DDS_DataWriter dw,
3483  DDS_InstanceHandleSeq *subscription_handles);
3491  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_data(DDS_DataWriter dw,
3492  DDS_SubscriptionBuiltinTopicData * subscription_data,
3493  const DDS_InstanceHandle_t subscription_handle);
3498  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_liveliness_lost_status ( DDS_DataWriter dw,
3499  DDS_LivelinessLostStatus *status);
3504  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_offered_deadline_missed_status ( DDS_DataWriter dw,
3510  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_offered_incompatible_qos_status ( DDS_DataWriter dw,
3516  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_publication_matched_status ( DDS_DataWriter dw,
3522  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_cache_stats( DDS_DataWriter dw,
3523  DDS_CacheStatistics * stats );
3527  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_guid(DDS_DataWriter dw,
3528  DDS_GUID_t * guid);
3529 
3530  /***********************************************************************/
3531  /* */
3532  /* BASE read/take operations used by generated application DataWriters */
3533  /* */
3534  /* NOTE: */
3535  /* */
3536  /* DDS Users should not call these directly. Call the corresponding */
3537  /* type specific routines found in the DDL Generated code. */
3538  /* */
3539 
3547  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_key_value( DDS_DataWriter dw,
3548  void * key_holder,
3549  const DDS_InstanceHandle_t handle);
3554  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_lookup_instance(DDS_DataWriter dw,
3555  const void * instance_data);
3561  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_register_instance(DDS_DataWriter dw,
3562  const void * instance_data);
3563 
3569  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_register_instance_w_timestamp(DDS_DataWriter dw,
3570  const void * instance_data,
3571  const DDS_Time_t source_timestamp);
3572 
3579  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_unregister_instance(DDS_DataWriter dw,
3580  const void * instance_data,
3581  const DDS_InstanceHandle_t handle);
3582 
3589  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_unregister_instance_w_timestamp(DDS_DataWriter dw,
3590  const void * instance_data,
3591  DDS_InstanceHandle_t handle,
3592  const DDS_Time_t source_timestamp);
3605  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write(DDS_DataWriter dw,
3606  const void * instance_data,
3607  const DDS_InstanceHandle_t handle);
3608 
3621  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write_w_timestamp(DDS_DataWriter dw,
3622  const void * instance_data,
3623  const DDS_InstanceHandle_t handle,
3624  const DDS_Time_t source_timestamp);
3625 
3632  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_dispose(DDS_DataWriter dw,
3633  const void * instance_data,
3634  const DDS_InstanceHandle_t instance_handle);
3635 
3642  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_dispose_w_timestamp(DDS_DataWriter dw,
3643  const void * instance_data,
3644  const DDS_InstanceHandle_t instance_handle,
3645  const DDS_Time_t source_timestamp);
3646 
3647  /* these are still experimenal in support of RPC */
3648  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write_request(struct _DataWriter * dw,
3649  const void * instance_data,
3650  const DDS_InstanceHandle_t handle,
3651  /* inout */ DDS_SampleIdentity_t * sampleid );
3652  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write_reply(struct _DataWriter * dw,
3653  const void * instance_data,
3654  const DDS_InstanceHandle_t handle,
3655  DDS_SampleIdentity_t * related_id) ;
3656 
3657  /* END */
3658  /* BASE read/take operations used by generated application DataWriters */
3659  /***********************************************************************/
3660 
3661  /****************************************************
3662  ** **
3663  ** DATA READER **
3664  ** **
3665  ****************************************************/
3687  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_enable ( DDS_DataReader dr );
3688  COREDX_C_API unsigned char DDS_DataReader_is_enabled ( DDS_DataReader dr );
3693  COREDX_C_API DDS_InstanceHandle_t DDS_DataReader_get_instance_handle( DDS_DataReader dr );
3699  COREDX_C_API DDS_StatusMask DDS_DataReader_get_status_changes ( DDS_DataReader dr );
3708  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_delete_contained_entities(DDS_DataReader dr );
3713  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_qos (DDS_DataReader dr,
3714  const DDS_DataReaderQos * qos);
3726  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_qos(DDS_DataReader dr,
3727  DDS_DataReaderQos * qos);
3736  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_listener(DDS_DataReader dr,
3737  DDS_DataReaderListener * a_listener,
3738  DDS_StatusMask mask);
3747  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_listener_cd(DDS_DataReader dr,
3748  DDS_DataReaderListener_cd * a_listener,
3749  DDS_StatusMask mask,
3750  void * callback_data);
3760  COREDX_C_API DDS_DataReaderListener * DDS_DataReader_get_listener(DDS_DataReader dr);
3769  COREDX_C_API DDS_DataReaderListener_cd * DDS_DataReader_get_listener_cd(DDS_DataReader dr);
3775  COREDX_C_API DDS_TopicDescription DDS_DataReader_get_topicdescription( DDS_DataReader dr );
3780  COREDX_C_API DDS_Subscriber DDS_DataReader_get_subscriber( DDS_DataReader dr );
3781 
3786  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_wait_for_historical_data( DDS_DataReader dr,
3787  const DDS_Duration_t * max_wait);
3792  COREDX_C_API DDS_StatusCondition DDS_DataReader_get_statuscondition( DDS_DataReader dr );
3799  COREDX_C_API DDS_ReadCondition DDS_DataReader_create_readcondition( DDS_DataReader dr,
3800  DDS_SampleStateMask sample_states,
3801  DDS_ViewStateMask view_states,
3802  DDS_InstanceStateMask instance_states);
3813  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_delete_readcondition(DDS_DataReader dr,
3814  DDS_ReadCondition a_condition);
3847  COREDX_C_API DDS_QueryCondition DDS_DataReader_create_querycondition(DDS_DataReader dr,
3848  DDS_SampleStateMask sample_states,
3849  DDS_ViewStateMask view_states,
3850  DDS_InstanceStateMask instance_states,
3851  const char * query_expression,
3852  const DDS_StringSeq * query_parameters);
3853 
3861  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_matched_publications(DDS_DataReader dr,
3862  DDS_InstanceHandleSeq * publication_handles);
3870  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_matched_publication_data( DDS_DataReader dr,
3871  DDS_PublicationBuiltinTopicData * publication_data,
3872  const DDS_InstanceHandle_t publication_handle);
3887  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_return_loan(DDS_DataReader dr,
3888  DDS_PointerSeq * received_data,
3889  DDS_SampleInfoSeq * sample_infos);
3894  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_sample_rejected_status(DDS_DataReader dr,
3895  DDS_SampleRejectedStatus *status );
3900  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_liveliness_changed_status(DDS_DataReader dr,
3901  DDS_LivelinessChangedStatus *status);
3906  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_requested_deadline_missed_status(DDS_DataReader dr,
3912  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_requested_incompatible_qos_status(DDS_DataReader dr,
3918  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_subscription_matched_status(DDS_DataReader dr,
3924  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_sample_lost_status(DDS_DataReader dr,
3925  DDS_SampleLostStatus *status );
3929  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_guid(DDS_DataReader dr,
3930  DDS_GUID_t *guid);
3931 
3936  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_cache_stats( DDS_DataReader dr,
3937  DDS_CacheStatistics * stats );
3938 
3943  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_matched_publication_guid( struct _DataReader *dr,
3944  DDS_GUID_t * guid,
3945  const DDS_InstanceHandle_t publication_handle );
3946 
3947  /***********************************************************************/
3948  /* */
3949  /* BASE read/take operations used by generated application DataReaders */
3950  /* */
3951  /* NOTE: */
3952  /* */
3953  /* DDS Users should not call these directly. Call the corresponding */
3954  /* type specific routines found in the DDL Generated code. */
3955  /* */
3956 
3964  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_key_value(DDS_DataReader dr,
3965  void * key_holder,
3966  DDS_InstanceHandle_t handle);
3973  COREDX_C_API DDS_InstanceHandle_t DDS_DataReader_lookup_instance(DDS_DataReader dr,
3974  void * instance_data);
4015  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read(DDS_DataReader dr,
4016  DDS_PointerSeq * received_data,
4017  DDS_SampleInfoSeq * sample_infos,
4018  int32_t max_samples,
4019  DDS_SampleStateMask sample_states,
4020  DDS_ViewStateMask view_states,
4021  DDS_InstanceStateMask instance_states);
4022 
4023 
4064  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take(DDS_DataReader dr,
4065  DDS_PointerSeq * received_data,
4066  DDS_SampleInfoSeq * sample_infos,
4067  int32_t max_samples,
4068  DDS_SampleStateMask sample_states,
4069  DDS_ViewStateMask view_states,
4070  DDS_InstanceStateMask instance_states);
4071 
4080  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_w_condition(DDS_DataReader dr,
4081  DDS_PointerSeq * received_data,
4082  DDS_SampleInfoSeq * sample_infos,
4083  int32_t max_samples,
4084  DDS_ReadCondition a_condition);
4085 
4094  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_w_condition(DDS_DataReader dr,
4095  DDS_PointerSeq * received_data,
4096  DDS_SampleInfoSeq * sample_infos,
4097  int32_t max_samples,
4098  DDS_ReadCondition a_condition);
4099 
4107  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_sample(DDS_DataReader dr,
4108  void * received_data,
4109  DDS_SampleInfo * sample_info);
4110 
4118  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_sample(DDS_DataReader dr,
4119  void * received_data,
4120  DDS_SampleInfo * sample_info);
4121 
4130  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_instance(DDS_DataReader dr,
4131  DDS_PointerSeq * received_data,
4132  DDS_SampleInfoSeq * sample_infos,
4133  int32_t max_samples,
4134  DDS_InstanceHandle_t a_handle,
4135  DDS_SampleStateMask sample_states,
4136  DDS_ViewStateMask view_states,
4137  DDS_InstanceStateMask instance_states);
4138 
4139 
4148  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_instance(DDS_DataReader dr,
4149  DDS_PointerSeq * received_data,
4150  DDS_SampleInfoSeq * sample_infos,
4151  int32_t max_samples,
4152  DDS_InstanceHandle_t a_handle,
4153  DDS_SampleStateMask sample_states,
4154  DDS_ViewStateMask view_states,
4155  DDS_InstanceStateMask instance_states);
4156 
4165  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_instance(DDS_DataReader dr,
4166  DDS_PointerSeq * received_data,
4167  DDS_SampleInfoSeq * sample_infos,
4168  int32_t max_samples,
4169  DDS_InstanceHandle_t previous_handle,
4170  DDS_SampleStateMask sample_states,
4171  DDS_ViewStateMask view_states,
4172  DDS_InstanceStateMask instance_states);
4173 
4182  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_instance(DDS_DataReader dr,
4183  DDS_PointerSeq * received_data,
4184  DDS_SampleInfoSeq * sample_infos,
4185  int32_t max_samples,
4186  DDS_InstanceHandle_t previous_handle,
4187  DDS_SampleStateMask sample_states,
4188  DDS_ViewStateMask view_states,
4189  DDS_InstanceStateMask instance_states);
4190 
4199  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_instance_w_condition(DDS_DataReader dr,
4200  DDS_PointerSeq * received_data,
4201  DDS_SampleInfoSeq * sample_infos,
4202  int32_t max_samples,
4203  DDS_InstanceHandle_t previous_handle,
4204  DDS_ReadCondition a_condition);
4205 
4214  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_instance_w_condition(DDS_DataReader dr,
4215  DDS_PointerSeq * received_data,
4216  DDS_SampleInfoSeq * sample_infos,
4217  int32_t max_samples,
4218  DDS_InstanceHandle_t previous_handle,
4219  DDS_ReadCondition a_condition);
4220  /* END */
4221  /* BASE read/take operations used by generated application DataReaders */
4222  /***********************************************************************/
4223 
4224  COREDX_C_API void * DDS_InstanceHandle_get_key(DDS_InstanceHandle_t handle);
4225 
4226  /***********************************************************************/
4227  /* TWIN OAKS HELPER EXTENSIONS: */
4228  COREDX_C_API const char * DDS_qos_policy_str(DDS_QosPolicyId_t policy);
4229  COREDX_C_API const char * DDS_error( DDS_ReturnCode_t retcode );
4230  COREDX_C_API const char * DDS_sample_state( DDS_SampleStateMask sm );
4231  COREDX_C_API const char * DDS_view_state ( DDS_ViewStateMask vm );
4232  COREDX_C_API const char * DDS_instance_state (DDS_InstanceStateMask im );
4233 
4234 #include <dds/coredx_version.h>
4235 
4236 #ifdef __cplusplus
4237 }
4238 #endif /* __cplusplus */
4239 
4240 
4241 #endif
Specifies the lifecycle behavior of data instances managed by the DataWriter. If autodispose_unregist...
Definition: dds.h:1207
The DDS_DomainParticipant is used to configure, create and destroy Publisher, Subscriber and Topic ob...
A DDS_QueryCondition is a specialized DDS_ReadCondition which includes a filter.
A DDS_Condition can be added to a DDS_WaitSet to provide synchronous event notification.
void(* on_liveliness_lost)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:441
DDS_PartitionQosPolicy partition
Establishes a logical data partition.
Definition: dds.h:1540
unsigned char require_acks
Require ACKS from readers before flushing an otherwise required sample from writer cache...
Definition: dds.h:1329
DDS_Duration_t nack_suppress_delay
The nack_suppress_delay to configure for builtin writers.
Definition: dds.h:1372
CoreDX_RTPSReaderQosPolicy rtps_reader
rtps_reader configuration
Definition: dds.h:1598
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1596
Definition: dds_builtin.h:1225
Structure that holds DDS_Subscriber Quality of Service policies.
Definition: dds.h:1616
DDS_ReliabilityQosPolicy reliability
The transport reliability requested by the DataReader.
Definition: dds.h:1572
Controls the presentation of received data samples to the application. CoreDX DDS currently supports ...
Definition: dds_builtin.h:308
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1549
DDS_Duration_t autopurge_disposed_samples_delay
delay after which it is ok to purge samples from instances that are disposed
Definition: dds.h:1220
Structure that holds DDS_Topic Quality of Service policies.
Definition: dds.h:1448
Status related to the on_offered_incompatible_qos listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:345
unsigned char send_typecode
send &#39;typecode&#39; information for associated data type.
Definition: dds.h:1328
Encapsulates statistics available from a DataReader or DataWriter.
Definition: dds_types.h:420
uint32_t participant_id
participant id start
Definition: dds.h:1295
struct _GuardCondition * DDS_GuardCondition
A DDS_GuardCondition is a condition where the trigger_value is under application control.
Definition: dds.h:162
Typecode representing the datatype a DataReader reads or a DataWriter writes.
Definition: dds_builtin.h:1069
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1422
void(* on_liveliness_changed)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:750
DDS_PresentationQosPolicy presentation
Controls the presentation of groups of changes.
Definition: dds.h:1533
DDS_ResourceLimitsQosPolicy resource_limits
The resource limits set on the DataWriter.
Definition: dds.h:1494
unsigned char send_typecode
Definition: dds.h:1339
Defines a logical data partition.
Definition: dds_builtin.h:645
void(* on_requested_incompatible_qos)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:726
Status related to the on_liveliness_changed listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:297
The DDS_DomainParticipantFactory is used to configure, create and destroy DomainParticipant objects...
DDS_DurabilityServiceQosPolicy durability_service
Configures the service supporting the TRANSIENT and PERSITENT durability kinds.
Definition: dds.h:1451
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; offered by the DataWriter.
Definition: dds.h:1498
uint32_t min_buffer_size
min size in bytes of written data
Definition: dds.h:1324
DDS_DeadlineQosPolicy deadline
The requested update frequency for data instances.
Definition: dds.h:1569
Specifies the lifecycle behavior of data instances managed by the DataReader.
Definition: dds.h:1218
CoreDX_ParticipantLocatorSeq value
Definition: dds.h:1307
The DDS_PublisherListener provides asynchronous notification of DDS_Publisher events.
Definition: dds.h:352
void(* on_requested_incompatible_qos)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:551
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1512
DDS_OwnershipStrengthQosPolicy ownership_strength
The measure of &#39;ownership strength&#39; offered by the DataWriter.
Definition: dds.h:1499
DDS_RpcQosPolicy rpc
Configure RPC relevant settings: instance_name, related_entity, and topic_aliases.
Definition: dds.h:1590
uint32_t port
Definition: dds.h:1286
CoreDX_PeerParticipantQosPolicy peer_participants
Specifies a list of DomainParticipant peers to attempt communication with. If empty, default Discovery is used.
Definition: dds.h:1424
Definition: dds_builtin_basic.h:163
DDS_TypeConsistencyEnforcementQosPolicy type_consistency
Influences the algorithm that matches DataReaders and DataWriters based on their data type compatibil...
Definition: dds.h:1586
DDS_LatencyBudgetQosPolicy latency_budget
Identifies the &#39;urgency&#39; of the data on the Topic. The middleware uses this to batch data samples is ...
Definition: dds.h:1453
void(* on_sample_lost)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:1134
A DDS_ReadCondition is a specialized DDS_Condition associated with a DDS_DataReader.
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1597
Status related to the on_inconsistent_topic listener methods of the DDS_TopicListener structure...
Definition: dds_types.h:242
Definition: dds.h:1194
Definition: dds.h:1231
The DDS_DataReader entity allows the application to subscribe to and read data.
DDS_MultiTopic provides a topic that may include data from multiple Topics.
DDS_HistoryQosPolicy history
The data history requested by the DataReader.
Definition: dds.h:1574
DDS_Duration_t nack_response_delay
The nack_response_delay to configure for builtin writers.
Definition: dds.h:1371
Augment a DataWriter or DataReader with RPC specific information.
Definition: dds_builtin.h:1112
uint32_t max_buffer_size
max size in bytes of written data
Definition: dds.h:1325
uint32_t min_buffer_size
minimum tx buffer size in bytes for builtin writers
Definition: dds.h:1373
DDS_DOMAINID_TYPE_NATIVE DDS_DomainId_t
Definition: dds_types.h:51
DDS_Duration_t heartbeat_period
The heartbeat_period to configure for builtin writers.
Definition: dds.h:1370
The DDS_Publisher configures, creates, manages and destroys DDS_DataWriters.
unsigned char accept_batch_msg
Definition: dds.h:1338
Network address.
Definition: dds.h:1284
DDS_DataRepresentationQosPolicy representation
Informs DataReader(s) of the single data representation supported by this Writer. This must be consis...
Definition: dds.h:1501
void(* on_publication_matched)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:1040
Allows the application to attach arbitrary information to a DomainParticipant, DataWriter or DataRead...
Definition: dds_builtin.h:43
int DDS_ReturnCode_t
Definition: dds_types.h:56
void(* on_subscription_matched)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:773
The DDS_DataWriter entity provides an interface for the application to publish (write) data...
QoS Policy for configuring aspects of the RTPS Writer Protocol.
Definition: dds.h:1319
rules for determining type consistency
Definition: dds_builtin.h:1038
Structure that holds DDS_DataReader Quality of Service policies.
Definition: dds.h:1567
The DDS_DomainParticipantListener_cd provides asynchronous notification of DDS_DomainParticipant even...
Definition: dds.h:975
A DDS_StatusCondition is a condition associated with an Entity.
DDS_DiscoveryQosPolicyDiscoveryKind discovery_kind
Type of disocvery to use for this Entity.
Definition: dds.h:1362
void(* on_requested_deadline_missed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_RequestedDeadlineMissedStatus status, void *callback_data)
Definition: dds.h:1055
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the DomainParticipant create operations.
Definition: dds.h:1421
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1631
DDS_Duration_t autopurge_nowriter_samples_delay
delay after which it is ok to purge samples from instances with no writer(s)
Definition: dds.h:1219
DDS_TopicDescription is an abstract &#39;class&#39; that provides the foundation for DDS_Topic, DDS_ContentFilteredTopic, and DDS_MultiTopic.
Indicates the level of reliability offered/provided by the Entity. If kind is RELIABLE_RELIABILITY_QO...
Definition: dds_builtin.h:705
Status related to the on_liveliness_lost listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:286
void(* on_data_available)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:1109
void(* on_offered_incompatible_qos)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:1014
QoS Policy for configuring aspects of the Discovery and Builtin entities.
Definition: dds.h:1361
DDS_Duration_t dpd_lease_duration
How long peers should consider this Participant to be alive without hearing from it.
Definition: dds.h:1367
Definition: dds_types.h:72
QoS Policy for configuring the threading behavior of the DomainParticipant.
Definition: dds.h:1388
The DurabilityQosPolicy controls the durablity of data.
Definition: dds_builtin.h:262
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; offered by the DataReader.
Definition: dds.h:1578
DDS_PartitionQosPolicy partition
Establishes a logical data partition.
Definition: dds.h:1624
Controls the ammount of historical data maintained by a DataReader or DataWriter. ...
Definition: dds_builtin.h:819
DDS_ContentFilteredTopic provides a topic that may exclude data based on a specified filter...
void(* on_liveliness_changed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:1096
DDS_DurabilityQosPolicy durability
The durability policy of the Topic.
Definition: dds.h:1450
Specifies allowable latency.
Definition: dds_builtin.h:402
Controls the amount and kind of information that is logged.
Definition: dds.h:1249
DDS_DeadlineQosPolicy deadline
The deadline committed to by the DataWriter.
Definition: dds.h:1488
void(* on_data_available)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:578
DDS_WriterDataLifecycleQosPolicy writer_data_lifecycle
Indicates if unregistered instances should be automatically disposed by the DataWriter.
Definition: dds.h:1500
DDS_LivelinessQosPolicy liveliness
The liveliness mechanism offered by the DataWriter.
Definition: dds.h:1490
void(* on_sample_lost)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:785
void(* on_sample_lost)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:595
DDS_DataRepresentationQosPolicy representation
The data representation(s) supported by Writer(s) and Reader(s) of this topic. The first entry in the...
Definition: dds.h:1462
Status related to the on_offered_deadline_missed listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:311
DDS_LifespanQosPolicy lifespan
The &#39;expiration time&#39; for old data samples on the Topic.
Definition: dds.h:1460
DDS_DurabilityQosPolicy durability
The durability policy requested by the DataReader.
Definition: dds.h:1568
uint32_t max_buffer_size
maximum tx buffer size in bytes for builtin writers
Definition: dds.h:1374
This QoS policy establishes a minimum update period for data instances.
Definition: dds_builtin.h:360
Allows the application to attach arbitrary information to a Topic QoS.
Definition: dds_builtin.h:84
CoreDX_Locator participant_locator
locator identifying peer participant
Definition: dds.h:1297
DDS_DurabilityServiceQosPolicy durability_service
The durability service configuration offered by the DataWriter.
Definition: dds.h:1487
uint32_t precache_max_samples
Definition: dds.h:1341
void(* on_liveliness_lost)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:1027
void(* on_offered_incompatible_qos)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:429
void(* on_offered_incompatible_qos)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:316
DDS_TransportPriorityQosPolicy transport_priority
The transport priority supported by the DataWriter.
Definition: dds.h:1495
A DDS_WaitSet maintains a set of DDS_Condition objects and allows the application to wait until one o...
void(* on_subscription_matched)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:1121
DDS_TransportPriorityQosPolicy transport_priority
The priority to be used for messages on the Topic.
Definition: dds.h:1459
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the Publisher_create_datawriter() operation.
Definition: dds.h:1547
The SampleInfo structure contains information associated with each sample.
Definition: dds_types.h:160
unsigned char create_listener_thread
Definition: dds.h:1390
unsigned char apply_filters
apply ContentFilter(s) at the writer (writer side filtering)
Definition: dds.h:1326
DDS_DCPSSubscription DDS_SubscriptionBuiltinTopicData
Definition: dds.h:176
DDS_DestinationOrderQosPolicy destination_order
The ordering of received samples on the Topic will be either by SOURCE or RECEPTION timestamp...
Definition: dds.h:1456
Defines a filter based on time between samples. The DataReader indicates that it wants at most one sa...
Definition: dds_builtin.h:589
DDS_LivelinessQosPolicy liveliness
Identifies the mechanism used to detect and maintain livelines of DataWriters on the Topic...
Definition: dds.h:1454
DDS_GroupDataQosPolicy group_data
A sequence of octets associated with the Publisher.
Definition: dds.h:1629
uint32_t participant_id_max
participant id max
Definition: dds.h:1296
unsigned char use_threads
should the DomainParticipant use threads for internal work
Definition: dds.h:1389
DDS_DCPSParticipant DDS_ParticipantBuiltinTopicData
Definition: dds.h:170
Configures a list of DomainParticipant peers to attempt communication with.
Definition: dds.h:1306
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1513
void(* on_sample_rejected)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:738
DDS_Duration_t nack_suppress_delay
ammount of time to ignore NACKs after a repair
Definition: dds.h:1322
DDS_DurabilityQosPolicy durability
The durability policy offered by the DataWriter.
Definition: dds.h:1486
void(* on_publication_matched)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:453
CoreDX_EntityNameQosPolicy entity_name
entity_name
Definition: dds.h:1466
DDS_PresentationQosPolicy presentation
Controls the presentation of groups of changes.
Definition: dds.h:1617
Definition: dds_builtin_basic.h:97
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; expected for data instances on the Topic.
Definition: dds.h:1461
The DDS_DataReaderListener provides asynchronous notification of DDS_DataReader events.
Definition: dds.h:470
unsigned char autodispose_unregistered_instances
should the writer dispose instances that are unregistered
Definition: dds.h:1208
unsigned char send_initial_nack
send a ACKNACK immediately after matching with new Writer.
Definition: dds.h:1378
unsigned char send_msglen_submsg
include &#39;msglen&#39; submessage in RTPS header
Definition: dds.h:1381
DDS_Duration_t ack_deadline
after which a realiable reader will be considered unresponsive
Definition: dds.h:1323
void(* on_data_on_readers)(struct DDS_SubscriberListener_cd *self, DDS_Subscriber the_subscriber, void *callback_data)
Definition: dds.h:795
DDS_GroupDataQosPolicy group_data
A sequence of octets associated with the Publisher.
Definition: dds.h:1546
DDS_UserDataQosPolicy user_data
A sequence of octets associated with the DataReader.
Definition: dds.h:1577
DDS_ReliabilityQosPolicy reliability
Indicates the level of transport reliability on the Topic.
Definition: dds.h:1455
Specifies the resources that the Service can use to maintain data samples and instances.
Definition: dds_builtin.h:857
Definition: dds_builtin.h:1328
DDS_DataRepresentationQosPolicy representation
Informs DataWriter(s) of the data representation(s) supported by this Reader. This must be consistent...
Definition: dds.h:1582
Structure that holds DDS_DataWriter Quality of Service policies.
Definition: dds.h:1485
The DDS_TopicListener provides asynchronous notification of DDS_Topic events.
Definition: dds.h:206
void(* on_data_available)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:762
The DDS_DataWriterListener provides asynchronous notification of DDS_DataWriter events.
Definition: dds.h:252
void(* on_requested_incompatible_qos)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:1069
DDS_ResourceLimitsQosPolicy resource_limits
The resource limits set on the DataReader.
Definition: dds.h:1575
DDS_ReaderDataLifecycleQosPolicy reader_data_lifecycle
Controls the auto-purge behavior of the DataReader.
Definition: dds.h:1580
DDS_HistoryQosPolicy history
The data history maintained by the DataWriter.
Definition: dds.h:1493
CoreDX_ThreadModelQosPolicy thread_model
Configure DomainParticipant thread usage.
Definition: dds.h:1427
void(* on_liveliness_changed)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:569
DDS_LatencyBudgetQosPolicy latency_budget
The latency allowed by the DataWriter.
Definition: dds.h:1489
DDS_PropertyQosPolicy properties
Additional name:value pair properties (if propagate=true, included in discovery)
Definition: dds.h:1428
Specifies the maximum duration of validity of the data written by the DataWriter. ...
Definition: dds_builtin.h:193
This QoS policy controls how each Subscriber orders received data samples.
Definition: dds_builtin.h:756
The DDS_PublisherListener_cd provides asynchronous notification of DDS_Publisher events with addition...
Definition: dds.h:406
The DDS_SubscriberListener_cd provides asynchronous notification of DDS_Subscriber events with additi...
Definition: dds.h:703
DECLARE_SEQ(DDS_DynamicTypeMember, DDS_DynamicTypeMemberSeq)
A DDS_DynamicTypeMemberSeq instance is a sequence of DDS_DynamicTypeMember&#39;s.
DDS_DCPSPublication DDS_PublicationBuiltinTopicData
Definition: dds.h:174
uint32_t flags
flags to control logging output
Definition: dds.h:1250
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1632
Status related to the on_requested_deadline_missed listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:322
DDS_Topic is the basic description of data to be published or subscribed.
DDS_DestinationOrderQosPolicy destination_order
The destination order logic offered by the DataWriter.
Definition: dds.h:1492
Structure that holds DDS_Publisher Quality of Service policies.
Definition: dds.h:1532
The DDS_Subscriber configures, creates, manages and destroys DDS_DataReaders.
unsigned char strict_match
Definition: dds.h:1308
void(* on_sample_rejected)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:1082
DDS_Duration_t heartbeat_period
period to transmit heartbeat messages if required
Definition: dds.h:1320
DDS_DataTagQosPolicy data_tags
Security related data_tags (sequence of name,value pairs).
Definition: dds.h:1511
void(* on_offered_deadline_missed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_OfferedDeadlineMissedStatus status, void *callback_data)
Definition: dds.h:1000
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1548
DDS_LatencyBudgetQosPolicy latency_budget
The latency requested by the DataReader.
Definition: dds.h:1570
Status related to the on_publication_matched listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:371
Defines the strength, or priority, of a Writer. The strength is used to determine ownership in the ca...
Definition: dds_builtin.h:481
The DDS_DataReaderListener_cd provides asynchronous notification of DDS_DataReader events with additi...
Definition: dds.h:533
DDS_DiscoveryQosPolicyDiscoveryKind
This enumeration contains the kinds of Discovery.
Definition: dds.h:1354
void(* on_publication_matched)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:335
DDS_Duration_t dpd_push_period
Multicast DiscoveredParticipantData each period.
Definition: dds.h:1366
unsigned int DDS_StatusMask
Definition: dds_types.h:134
DDS_TimeBasedFilterQosPolicy time_based_filter
The maximum update frequency required/desired by the DataReader.
Definition: dds.h:1579
DDS_RpcQosPolicy rpc
Configure RPC relevant settings: instance_name, related_entity, and topic_aliases.
Definition: dds.h:1507
DDS_UserDataQosPolicy user_data
A sequence of octets associated with the DataWriter.
Definition: dds.h:1497
int kind
Definition: dds.h:1285
DDS_HANDLE_TYPE_NATIVE DDS_InstanceHandle_t
Definition: dds_types.h:53
QoS Policy for configuring aspects of the RTPS Reader Protocol.
Definition: dds.h:1336
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the Subsriber_create_datareader() operation.
Definition: dds.h:1630
struct DDS_DCPSTopic DDS_TopicBuiltinTopicData
Definition: dds.h:172
unsigned char send_initial_nack
Definition: dds.h:1340
The Duration_t structure contains data to define a time duration.
Definition: dds_builtin_basic.h:198
DDS_LivelinessQosPolicy liveliness
The liveliness mechanism requested by the DataReader.
Definition: dds.h:1571
The DDS_TopicListener_cd provides asynchronous notification of DDS_Topic events with additional callb...
Definition: dds.h:224
Status related to the on_subscription_matched listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:385
Structure that holds DDS_DomainParticipantFactory Quality of Service policies.
Definition: dds.h:1400
The DDS_DataWriterListener_cd provides asynchronous notification of DDS_DataWriter events with additi...
Definition: dds.h:297
Determines the mechanism and parameters used by the application to determine whether an Entity is ali...
Definition: dds_builtin.h:550
Describes the data representation used by a topic.
Definition: dds_builtin.h:993
Allows the application to attach arbitrary information to a Publisher or Subscriber.
Definition: dds_builtin.h:126
DDS_UserDataQosPolicy user_data
A sequence of octets associated with a DomainParticipant.
Definition: dds.h:1420
DDS_Duration_t nack_response_delay
ammount of time allowed for responding to NACKs
Definition: dds.h:1321
Status related to the on_requested_incompatible_qos listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:358
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1467
DDS_DeadlineQosPolicy deadline
Defines the expected update frequency for data instances within the Topic.
Definition: dds.h:1452
Definition: dds.h:1355
DDS_DataTagQosPolicy data_tags
Security related data_tags (sequence of name,value pairs).
Definition: dds.h:1594
Definition: dds.h:1356
The DDS_SubscriberListener provides asynchronous notification of DDS_Subscriber events.
Definition: dds.h:612
DDS_Duration_t heartbeat_response_delay
ammount of time allowed for responding to a heartbeat
Definition: dds.h:1337
void(* on_subscription_matched)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:586
void(* on_inconsistent_topic)(DDS_Topic the_topic, DDS_InconsistentTopicStatus status)
Definition: dds.h:213
void(* on_sample_rejected)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:560
CoreDX_DiscoveryQosPolicy discovery
Override QoS values for builtin discovery entities.
Definition: dds.h:1426
Definition: dds_builtin.h:1440
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the DomainParticipant create operations.
Definition: dds.h:1401
CoreDX_RTPSWriterQosPolicy rtps_writer
rtps_writer configuration
Definition: dds.h:1514
unsigned char enable_batch_msg
use the &#39;BATCH&#39; RTPS message to send data if all Readers accept BATCH
Definition: dds.h:1327
Status related to the on_sample_lost listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:254
DDS_HistoryQosPolicy history
The amount of historical data maintained for the Topic.
Definition: dds.h:1457
DDS_LifespanQosPolicy lifespan
The expiration time for old samples managed by the DataWriter.
Definition: dds.h:1496
Definition: dds_builtin.h:1365
Describes a the location and identity of a potential peer DomainParticipant.
Definition: dds.h:1294
DDS_ReliabilityQosPolicy reliability
The transport reliability offered by the DataWriter.
Definition: dds.h:1491
unsigned char autoenable_created_entities
should created entities be automatically enabled
Definition: dds.h:1195
Structure that holds DDS_DomainParticipant Quality of Service policies.
Definition: dds.h:1419
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1423
DDS_ResourceLimitsQosPolicy resource_limits
The resource limitations for the Topic.
Definition: dds.h:1458
Definition: dds_builtin.h:918
A hint to the middleware to help configure the transport priority mechanism.
Definition: dds_builtin.h:158
DDS_TopicDataQosPolicy topic_data
A sequence of octets associated with a Topic.
Definition: dds.h:1449
void(* on_liveliness_lost)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:325
Status related to the on_sample_rejected listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:273
DDS_Duration_t heartbeat_response_delay
The heartbeat_response_delay to configure for builtin readers.
Definition: dds.h:1377
void(* on_data_on_readers)(struct DDS_DomainParticipantListener_cd *self, DDS_Subscriber the_subscriber, void *callback_data)
Definition: dds.h:1147
DDS_Duration_t reliable_sample_hold_time
Time after which a sample may be flushed even if it hasn&#39;t been ACK&#39;d,.
Definition: dds.h:1330
Determines instance ownership in the case of multple writers. CoreDX DDS supports both SHARED_OWNERSH...
Definition: dds_builtin.h:445
The DDS_DomainParticipantListener provides asynchronous notification of DDS_DomainParticipant events...
Definition: dds.h:813
CoreDX_LocatorSeq locators
Definition: dds.h:1342
DDS_DestinationOrderQosPolicy destination_order
The destination order logic requested by the DataReader.
Definition: dds.h:1573

© 2009-2020 Twin Oaks Computing, Inc
Castle Rock, CO 80104
All rights reserved.