CoreDX DDS C Reference Manual
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-2016 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 
125 #ifdef __cplusplus
126 extern "C" {
127 #endif /* __cplusplus */
128 
136 #include <dds/dds_export.h>
137 #include <dds/dds_consts.h>
138 #include <dds/dds_types.h>
139 #include <dds/dds_builtin.h>
140 
141  /***********************************************************
142  * Fundamental DDS Object types (Opaque) *
143  ***********************************************************/
144  typedef struct _DomainParticipantFactory * DDS_DomainParticipantFactory;
145  typedef struct _Entity * DDS_Entity;
146  typedef struct _DomainParticipant * DDS_DomainParticipant;
147  typedef struct _Publisher * DDS_Publisher;
148  typedef struct _Subscriber * DDS_Subscriber;
149  typedef struct _DataReader * DDS_DataReader;
150  typedef struct _DataWriter * DDS_DataWriter;
151  typedef struct _TopicDescription * DDS_TopicDescription;
152  typedef struct _Topic * DDS_Topic;
153  typedef struct _ContentFilteredTopic * DDS_ContentFilteredTopic;
154  typedef struct _MultiTopic * DDS_MultiTopic;
155 
156  typedef struct _Condition * DDS_Condition;
157  typedef struct _StatusCondition * DDS_StatusCondition;
158  typedef struct _ReadCondition * DDS_ReadCondition;
160  typedef struct _GuardCondition * DDS_GuardCondition;
161  typedef struct _QueryCondition * DDS_QueryCondition;
162  typedef struct _WaitSet * DDS_WaitSet;
163  typedef struct _TypeSupport * DDS_TypeSupport;
164 
165 
166  /* Builtin Topic Data Types */
168  typedef DDS_DCPSParticipant DDS_ParticipantBuiltinTopicData;
170  typedef struct DDS_DCPSTopic DDS_TopicBuiltinTopicData;
172  typedef DDS_DCPSPublication DDS_PublicationBuiltinTopicData;
174  typedef DDS_DCPSSubscription DDS_SubscriptionBuiltinTopicData;
175 
176  struct CoreDX_Transport;
177 
178  /***********************************************************
179  * DDS Entity Sequence Types *
180  ***********************************************************/
181  DECLARE_SEQ( DDS_DataWriter, DDS_DataWriterSeq );
182  DECLARE_SEQ( DDS_DataReader, DDS_DataReaderSeq );
183  DECLARE_SEQ( DDS_InstanceHandle_t, DDS_InstanceHandleSeq);
184  DECLARE_SEQ( DDS_Condition, DDS_ConditionSeq );
185 
186  COREDX_C_API DDS_DataWriterSeq * DDS_DataWriterSeq__alloc(void);
187  COREDX_C_API DDS_DataReaderSeq * DDS_DataReaderSeq__alloc(void);
188  COREDX_C_API DDS_InstanceHandleSeq * DDS_InstanceHandleSeq__alloc(void);
189  COREDX_C_API DDS_ConditionSeq * DDS_ConditionSeq__alloc(void);
190 
191  /***********************************************************
192  * Listeners *
193  ***********************************************************/
204  typedef struct DDS_TopicListener
205  {
211  void (*on_inconsistent_topic)(DDS_Topic the_topic,
212  DDS_InconsistentTopicStatus status);
213 
214  } DDS_TopicListener;
222  typedef struct DDS_TopicListener_cd
223  {
232  void (*on_inconsistent_topic)(struct DDS_TopicListener_cd * self,
233  DDS_Topic the_topic,
234  DDS_InconsistentTopicStatus status,
235  void * callback_data);
236 
237  } DDS_TopicListener_cd;
238 
250  typedef struct DDS_DataWriterListener
251  {
259  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
260  DDS_OfferedDeadlineMissedStatus status);
267  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
268  DDS_OfferedIncompatibleQosStatus status);
274  void (*on_liveliness_lost)(DDS_DataWriter writer,
275  DDS_LivelinessLostStatus status);
282  void (*on_publication_matched)(DDS_DataWriter writer,
283  DDS_PublicationMatchedStatus status);
284  } DDS_DataWriterListener;
295  typedef struct DDS_DataWriterListener_cd
296  {
304  void (*on_offered_deadline_missed)(struct DDS_DataWriterListener_cd * self,
305  DDS_DataWriter writer,
306  DDS_OfferedDeadlineMissedStatus status,
307  void * callback_data);
314  void (*on_offered_incompatible_qos)(struct DDS_DataWriterListener_cd * self,
315  DDS_DataWriter writer,
316  DDS_OfferedIncompatibleQosStatus status,
317  void * callback_data);
323  void (*on_liveliness_lost)(struct DDS_DataWriterListener_cd * self,
324  DDS_DataWriter writer,
325  DDS_LivelinessLostStatus status,
326  void * callback_data);
333  void (*on_publication_matched)(struct DDS_DataWriterListener_cd * self,
334  DDS_DataWriter writer,
335  DDS_PublicationMatchedStatus status,
336  void * callback_data);
337  } DDS_DataWriterListener_cd;
338 
350  typedef struct DDS_PublisherListener
351  {
360  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
361  DDS_OfferedDeadlineMissedStatus status);
371  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
372  DDS_OfferedIncompatibleQosStatus status);
381  void (*on_liveliness_lost)(DDS_DataWriter writer,
382  DDS_LivelinessLostStatus status);
391  void (*on_publication_matched)(DDS_DataWriter writer,
392  DDS_PublicationMatchedStatus status);
393  } DDS_PublisherListener;
404  typedef struct DDS_PublisherListener_cd
405  {
414  void (*on_offered_deadline_missed)(struct DDS_PublisherListener_cd * self,
415  DDS_DataWriter writer,
416  DDS_OfferedDeadlineMissedStatus status,
417  void * callback_data);
427  void (*on_offered_incompatible_qos)(struct DDS_PublisherListener_cd * self,
428  DDS_DataWriter writer,
429  DDS_OfferedIncompatibleQosStatus status,
430  void * callback_data);
439  void (*on_liveliness_lost)(struct DDS_PublisherListener_cd * self,
440  DDS_DataWriter writer,
441  DDS_LivelinessLostStatus status,
442  void * callback_data);
451  void (*on_publication_matched)(struct DDS_PublisherListener_cd * self,
452  DDS_DataWriter writer,
453  DDS_PublicationMatchedStatus status,
454  void * callback_data);
455  } DDS_PublisherListener_cd;
456 
468  typedef struct DDS_DataReaderListener
469  {
476  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
477  DDS_RequestedDeadlineMissedStatus status);
484  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
485  DDS_RequestedIncompatibleQosStatus status);
491  void (*on_sample_rejected)(DDS_DataReader the_reader,
492  DDS_SampleRejectedStatus status);
498  void (*on_liveliness_changed)(DDS_DataReader the_reader,
499  DDS_LivelinessChangedStatus status);
505  void (*on_data_available)(DDS_DataReader the_reader);
511  void (*on_subscription_matched)(DDS_DataReader the_reader,
512  DDS_SubscriptionMatchedStatus status);
518  void (*on_sample_lost)(DDS_DataReader the_reader,
519  DDS_SampleLostStatus status);
520  } DDS_DataReaderListener;
531  typedef struct DDS_DataReaderListener_cd
532  {
539  void (*on_requested_deadline_missed)(struct DDS_DataReaderListener_cd * self,
540  DDS_DataReader the_reader,
541  DDS_RequestedDeadlineMissedStatus status,
542  void * callback_data);
549  void (*on_requested_incompatible_qos)(struct DDS_DataReaderListener_cd * self,
550  DDS_DataReader the_reader,
551  DDS_RequestedIncompatibleQosStatus status,
552  void * callback_data);
558  void (*on_sample_rejected)(struct DDS_DataReaderListener_cd * self,
559  DDS_DataReader the_reader,
560  DDS_SampleRejectedStatus status,
561  void * callback_data);
567  void (*on_liveliness_changed)(struct DDS_DataReaderListener_cd * self,
568  DDS_DataReader the_reader,
569  DDS_LivelinessChangedStatus status,
570  void * callback_data);
576  void (*on_data_available)(struct DDS_DataReaderListener_cd * self,
577  DDS_DataReader the_reader,
578  void * callback_data);
584  void (*on_subscription_matched)(struct DDS_DataReaderListener_cd * self,
585  DDS_DataReader the_reader,
586  DDS_SubscriptionMatchedStatus status,
587  void * callback_data);
593  void (*on_sample_lost)(struct DDS_DataReaderListener_cd * self,
594  DDS_DataReader the_reader,
595  DDS_SampleLostStatus status,
596  void * callback_data);
597  } DDS_DataReaderListener_cd;
598 
610  typedef struct DDS_SubscriberListener
611  {
620  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
621  DDS_RequestedDeadlineMissedStatus status);
631  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
632  DDS_RequestedIncompatibleQosStatus status);
641  void (*on_sample_rejected)(DDS_DataReader the_reader,
642  DDS_SampleRejectedStatus status);
651  void (*on_liveliness_changed)(DDS_DataReader the_reader,
652  DDS_LivelinessChangedStatus status);
661  void (*on_data_available)(DDS_DataReader the_reader);
670  void (*on_subscription_matched)(DDS_DataReader the_reader,
671  DDS_SubscriptionMatchedStatus status);
680  void (*on_sample_lost)(DDS_DataReader the_reader,
681  DDS_SampleLostStatus status);
688  void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
689  } DDS_SubscriberListener;
690 
701  typedef struct DDS_SubscriberListener_cd
702  {
711  void (*on_requested_deadline_missed)(struct DDS_SubscriberListener_cd * self,
712  DDS_DataReader the_reader,
713  DDS_RequestedDeadlineMissedStatus status,
714  void * callback_data);
724  void (*on_requested_incompatible_qos)(struct DDS_SubscriberListener_cd * self,
725  DDS_DataReader the_reader,
726  DDS_RequestedIncompatibleQosStatus status,
727  void * callback_data);
736  void (*on_sample_rejected)(struct DDS_SubscriberListener_cd * self,
737  DDS_DataReader the_reader,
738  DDS_SampleRejectedStatus status,
739  void * callback_data);
748  void (*on_liveliness_changed)(struct DDS_SubscriberListener_cd * self,
749  DDS_DataReader the_reader,
750  DDS_LivelinessChangedStatus status,
751  void * callback_data);
760  void (*on_data_available)(struct DDS_SubscriberListener_cd * self,
761  DDS_DataReader the_reader,
762  void * callback_data);
771  void (*on_subscription_matched)(struct DDS_SubscriberListener_cd * self,
772  DDS_DataReader the_reader,
773  DDS_SubscriptionMatchedStatus status,
774  void * callback_data);
783  void (*on_sample_lost)(struct DDS_SubscriberListener_cd * self,
784  DDS_DataReader the_reader,
785  DDS_SampleLostStatus status,
786  void * callback_data);
793  void (*on_data_on_readers)(struct DDS_SubscriberListener_cd * self,
794  DDS_Subscriber the_subscriber,
795  void * callback_data);
796  } DDS_SubscriberListener_cd;
797 
798 
799 
811  typedef struct DDS_DomainParticipantListener
812  {
822  void (*on_inconsistent_topic)(DDS_Topic the_topic,
823  DDS_InconsistentTopicStatus status);
834  void (*on_offered_deadline_missed)(DDS_DataWriter writer,
835  DDS_OfferedDeadlineMissedStatus status);
846  void (*on_offered_incompatible_qos)(DDS_DataWriter writer,
847  DDS_OfferedIncompatibleQosStatus status);
857  void (*on_liveliness_lost)(DDS_DataWriter writer,
858  DDS_LivelinessLostStatus status);
868  void (*on_publication_matched)(DDS_DataWriter writer,
869  DDS_PublicationMatchedStatus status);
870 
881  void (*on_requested_deadline_missed)(DDS_DataReader the_reader,
882  DDS_RequestedDeadlineMissedStatus status);
893  void (*on_requested_incompatible_qos)(DDS_DataReader the_reader,
894  DDS_RequestedIncompatibleQosStatus status);
904  void (*on_sample_rejected)(DDS_DataReader the_reader,
905  DDS_SampleRejectedStatus status);
916  void (*on_liveliness_changed)(DDS_DataReader the_reader,
917  DDS_LivelinessChangedStatus status);
927  void (*on_data_available)(DDS_DataReader the_reader);
937  void (*on_subscription_matched)(DDS_DataReader the_reader,
938  DDS_SubscriptionMatchedStatus status);
948  void (*on_sample_lost)(DDS_DataReader the_reader,
949  DDS_SampleLostStatus status);
959  void (*on_data_on_readers)(DDS_Subscriber the_subscriber);
960  } DDS_DomainParticipantListener;
961 
962 
973  typedef struct DDS_DomainParticipantListener_cd
974  {
984  void (*on_inconsistent_topic)(struct DDS_DomainParticipantListener_cd * self,
985  DDS_Topic the_topic,
986  DDS_InconsistentTopicStatus status,
987  void * callback_data);
998  void (*on_offered_deadline_missed)(struct DDS_DomainParticipantListener_cd * self,
999  DDS_DataWriter writer,
1000  DDS_OfferedDeadlineMissedStatus status,
1001  void * callback_data);
1012  void (*on_offered_incompatible_qos)(struct DDS_DomainParticipantListener_cd * self,
1013  DDS_DataWriter writer,
1014  DDS_OfferedIncompatibleQosStatus status,
1015  void * callback_data);
1025  void (*on_liveliness_lost)(struct DDS_DomainParticipantListener_cd * self,
1026  DDS_DataWriter writer,
1027  DDS_LivelinessLostStatus status,
1028  void * callback_data);
1038  void (*on_publication_matched)(struct DDS_DomainParticipantListener_cd * self,
1039  DDS_DataWriter writer,
1040  DDS_PublicationMatchedStatus status,
1041  void * callback_data);
1042 
1053  void (*on_requested_deadline_missed)(struct DDS_DomainParticipantListener_cd * self,
1054  DDS_DataReader the_reader,
1055  DDS_RequestedDeadlineMissedStatus status,
1056  void * callback_data);
1067  void (*on_requested_incompatible_qos)(struct DDS_DomainParticipantListener_cd * self,
1068  DDS_DataReader the_reader,
1069  DDS_RequestedIncompatibleQosStatus status,
1070  void * callback_data);
1080  void (*on_sample_rejected)(struct DDS_DomainParticipantListener_cd * self,
1081  DDS_DataReader the_reader,
1082  DDS_SampleRejectedStatus status,
1083  void * callback_data);
1094  void (*on_liveliness_changed)(struct DDS_DomainParticipantListener_cd * self,
1095  DDS_DataReader the_reader,
1096  DDS_LivelinessChangedStatus status,
1097  void * callback_data);
1107  void (*on_data_available)(struct DDS_DomainParticipantListener_cd * self,
1108  DDS_DataReader the_reader,
1109  void * callback_data);
1119  void (*on_subscription_matched)(struct DDS_DomainParticipantListener_cd * self,
1120  DDS_DataReader the_reader,
1121  DDS_SubscriptionMatchedStatus status,
1122  void * callback_data);
1132  void (*on_sample_lost)(struct DDS_DomainParticipantListener_cd * self,
1133  DDS_DataReader the_reader,
1134  DDS_SampleLostStatus status,
1135  void * callback_data);
1145  void (*on_data_on_readers)(struct DDS_DomainParticipantListener_cd * self,
1146  DDS_Subscriber the_subscriber,
1147  void * callback_data);
1148  } DDS_DomainParticipantListener_cd;
1149 
1150  /***********************************************************
1151  * QOS *
1152  ***********************************************************/
1153  COREDX_C_API const char * DDS_USERDATA_QOS_POLICY_NAME;
1154  COREDX_C_API const char * DDS_DURABILITY_QOS_POLICY_NAME;
1155  COREDX_C_API const char * DDS_PRESENTATION_QOS_POLICY_NAME;
1156  COREDX_C_API const char * DDS_DEADLINE_QOS_POLICY_NAME;
1157  COREDX_C_API const char * DDS_LATENCYBUDGET_QOS_POLICY_NAME;
1158  COREDX_C_API const char * DDS_OWNERSHIP_QOS_POLICY_NAME;
1159  COREDX_C_API const char * DDS_OWNERSHIPSTRENGTH_QOS_POLICY_NAME;
1160  COREDX_C_API const char * DDS_LIVELINESS_QOS_POLICY_NAME;
1161  COREDX_C_API const char * DDS_TIMEBASEDFILTER_QOS_POLICY_NAME;
1162  COREDX_C_API const char * DDS_PARTITION_QOS_POLICY_NAME;
1163  COREDX_C_API const char * DDS_RELIABILITY_QOS_POLICY_NAME;
1164  COREDX_C_API const char * DDS_DESTINATIONORDER_QOS_POLICY_NAME;
1165  COREDX_C_API const char * DDS_HISTORY_QOS_POLICY_NAME;
1166  COREDX_C_API const char * DDS_RESOURCELIMITS_QOS_POLICY_NAME;
1167  COREDX_C_API const char * DDS_ENTITYFACTORY_QOS_POLICY_NAME;
1168  COREDX_C_API const char * DDS_WRITERDATALIFECYCLE_QOS_POLICY_NAME;
1169  COREDX_C_API const char * DDS_READERDATALIFECYCLE_QOS_POLICY_NAME;
1170  COREDX_C_API const char * DDS_TOPICDATA_QOS_POLICY_NAME;
1171  COREDX_C_API const char * DDS_GROUPDATA_QOS_POLICY_NAME;
1172  COREDX_C_API const char * DDS_TRANSPORTPRIORITY_QOS_POLICY_NAME;
1173  COREDX_C_API const char * DDS_LIFESPAN_QOS_POLICY_NAME;
1174  COREDX_C_API const char * DDS_DURABILITYSERVICE_POLICY_NAME;
1175  COREDX_C_API const char * DDS_DATA_REPRESENTATION_POLICY_NAME;
1176  COREDX_C_API const char * DDS_TYPE_CONSISTENCY_ENFORCEMENT_POLICY_NAME;
1177 
1178  COREDX_C_API DDS_QosPolicyId_t DDS_USERDATA_QOS_POLICY_ID;
1179  COREDX_C_API DDS_QosPolicyId_t DDS_DURABILITY_QOS_POLICY_ID;
1180  COREDX_C_API DDS_QosPolicyId_t DDS_PRESENTATION_QOS_POLICY_ID;
1181  COREDX_C_API DDS_QosPolicyId_t DDS_DEADLINE_QOS_POLICY_ID;
1182  COREDX_C_API DDS_QosPolicyId_t DDS_LATENCYBUDGET_QOS_POLICY_ID;
1183  COREDX_C_API DDS_QosPolicyId_t DDS_OWNERSHIP_QOS_POLICY_ID;
1184  COREDX_C_API DDS_QosPolicyId_t DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID;
1185  COREDX_C_API DDS_QosPolicyId_t DDS_LIVELINESS_QOS_POLICY_ID;
1186  COREDX_C_API DDS_QosPolicyId_t DDS_TIMEBASEDFILTER_QOS_POLICY_ID;
1187  COREDX_C_API DDS_QosPolicyId_t DDS_PARTITION_QOS_POLICY_ID;
1188  COREDX_C_API DDS_QosPolicyId_t DDS_RELIABILITY_QOS_POLICY_ID;
1189  COREDX_C_API DDS_QosPolicyId_t DDS_DESTINATIONORDER_QOS_POLICY_ID;
1190  COREDX_C_API DDS_QosPolicyId_t DDS_HISTORY_QOS_POLICY_ID;
1191  COREDX_C_API DDS_QosPolicyId_t DDS_RESOURCELIMITS_QOS_POLICY_ID;
1192  COREDX_C_API DDS_QosPolicyId_t DDS_ENTITYFACTORY_QOS_POLICY_ID;
1193  COREDX_C_API DDS_QosPolicyId_t DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID;
1194  COREDX_C_API DDS_QosPolicyId_t DDS_READERDATALIFECYCLE_QOS_POLICY_ID;
1195  COREDX_C_API DDS_QosPolicyId_t DDS_TOPICDATA_QOS_POLICY_ID;
1196  COREDX_C_API DDS_QosPolicyId_t DDS_GROUPDATA_QOS_POLICY_ID;
1197  COREDX_C_API DDS_QosPolicyId_t DDS_TRANSPORTPRIORITY_QOS_POLICY_ID;
1198  COREDX_C_API DDS_QosPolicyId_t DDS_LIFESPAN_QOS_POLICY_ID;
1199  COREDX_C_API DDS_QosPolicyId_t DDS_DURABILITYSERVICE_QOS_POLICY_ID;
1200  COREDX_C_API DDS_QosPolicyId_t DDS_DATA_REPRESENTATION_QOS_POLICY_ID;
1201  COREDX_C_API DDS_QosPolicyId_t DDS_TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID;
1202 
1203 #define DDS_MAXIMUM_QOS_POLICY_ID 24
1204 
1219  typedef struct DDS_EntityFactoryQosPolicy {
1220  unsigned char autoenable_created_entities;
1221  } DDS_EntityFactoryQosPolicy;
1222 
1232  typedef struct DDS_WriterDataLifecycleQosPolicy {
1233  unsigned char autodispose_unregistered_instances;
1234  } DDS_WriterDataLifecycleQosPolicy;
1235 
1243  typedef struct DDS_ReaderDataLifecycleQosPolicy {
1244  DDS_Duration_t autopurge_nowriter_samples_delay;
1245  DDS_Duration_t autopurge_disposed_samples_delay;
1246  } DDS_ReaderDataLifecycleQosPolicy;
1247 
1248  /* CoreDX QoS Extensions:
1249  */
1256  typedef struct CoreDX_EntityNameQosPolicy {
1257  #define COREDX_ENTITY_NAME_MAX 32
1258  char value[COREDX_ENTITY_NAME_MAX];
1259  } CoreDX_EntityNameQosPolicy;
1260 #define DDS_EntityNameQosPolicy CoreDX_EntityNameQosPolicy
1261 
1274  typedef struct CoreDX_LoggingQosPolicy {
1275  uint32_t flags;
1276  /*
1277  logging uri examples:
1278  'file:///tmp/dds.log',
1279  'stdout',
1280  'stderr'
1281  */
1282 #define COREDX_LOGGING_URI_MAX 256
1283  char uri[COREDX_LOGGING_URI_MAX];
1284  } CoreDX_LoggingQosPolicy;
1285 #define DDS_LoggingQosPolicy CoreDX_LoggingQosPolicy
1286 
1287 #define COREDX_RESERVED_LOCATOR_KIND_QOS 0
1288 #define COREDX_UDPV4_LOCATOR_KIND_QOS 1
1289 #define COREDX_UDPV6_LOCATOR_KIND_QOS 2
1290 #define COREDX_UDS_LOCATOR_KIND_QOS 4
1291 #define COREDX_TCPV4_LOCATOR_KIND_QOS 0x8001
1292 #define COREDX_TCPV6_LOCATOR_KIND_QOS 0x8002
1293 #define COREDX_RESV2_LOCATOR_KIND_QOS 0x8003
1294 #define COREDX_LMT_LOCATOR_KIND_QOS 0x8004
1295 #define COREDX_SSLV4_LOCATOR_KIND_QOS 0x8005 /* SSL over IPv4 */
1296 #define COREDX_SSLV6_LOCATOR_KIND_QOS 0x8006 /* SSL over IPv6 */
1297 #define COREDX_SSLCLIENT_LOCATOR_KIND_QOS 0x8007 /* SSL CLIENT (GUID) */
1298 
1304  typedef struct CoreDX_Locator_t {
1305  int kind;
1306  uint32_t port;
1307  unsigned char addr[16];
1308  } CoreDX_Locator;
1309  DECLARE_SEQ(CoreDX_Locator, CoreDX_LocatorSeq);
1310 
1314  typedef struct CoreDX_ParticipantLocator_t {
1315  uint32_t participant_id;
1316  uint32_t participant_id_max;
1317  CoreDX_Locator participant_locator;
1318  } CoreDX_ParticipantLocator;
1319  DECLARE_SEQ(CoreDX_ParticipantLocator, CoreDX_ParticipantLocatorSeq);
1320 
1326  typedef struct CoreDX_PeerParticipantQosPolicy_t {
1327  CoreDX_ParticipantLocatorSeq value;
1328  unsigned char strict_match;
1329  } CoreDX_PeerParticipantQosPolicy;
1330 #define DDS_PeerParticipantQosPolicy CoreDX_PeerParticipantQosPolicy
1331 
1332  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_init( CoreDX_PeerParticipantQosPolicy * p );
1333  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_clear( CoreDX_PeerParticipantQosPolicy * p );
1334  COREDX_C_API void CoreDX_PeerParticipantQosPolicy_copy( CoreDX_PeerParticipantQosPolicy * to,
1335  const CoreDX_PeerParticipantQosPolicy * from );
1336 
1339  typedef struct CoreDX_RTPSWriterQosPolicy {
1340  DDS_Duration_t heartbeat_period;
1341  DDS_Duration_t nack_response_delay;
1342  DDS_Duration_t nack_suppress_delay;
1343  DDS_Duration_t ack_deadline;
1344  uint32_t min_buffer_size;
1345  uint32_t max_buffer_size;
1346  unsigned char apply_filters;
1347  unsigned char enable_batch_msg;
1348  unsigned char send_typecode;
1349  } CoreDX_RTPSWriterQosPolicy;
1350 #define DDS_RTPSWriterQosPolicy CoreDX_RTPSWriterQosPolicy
1351 
1354  typedef struct CoreDX_RTPSReaderQosPolicy {
1355  DDS_Duration_t heartbeat_response_delay;
1356  unsigned char accept_batch_msg;
1357  unsigned char send_typecode;
1358  unsigned char send_initial_nack;
1359  uint32_t precache_max_samples;
1360  } CoreDX_RTPSReaderQosPolicy;
1361 #define DDS_RTPSReaderQosPolicy CoreDX_RTPSReaderQosPolicy
1362 
1366  typedef enum DDS_DiscoveryQosPolicyDiscoveryKind {
1367  DDS_PEER_DISCOVERY_QOS,
1368  DDS_CENTRAL_DISCOVERY_QOS
1369  } DDS_DiscoveryQosPolicyDiscoveryKind;
1370 
1373  typedef struct CoreDX_DiscoveryQosPolicy {
1374  DDS_DiscoveryQosPolicyDiscoveryKind discovery_kind;
1375  DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE guid_pid;
1377  /* configure Participant Writer */
1378  DDS_Duration_t dpd_push_period;
1379  DDS_Duration_t dpd_lease_duration;
1381  /* configure Pub/Sub/Topic Builtin writers: */
1382  DDS_Duration_t heartbeat_period;
1383  DDS_Duration_t nack_response_delay;
1384  DDS_Duration_t nack_suppress_delay;
1385  uint32_t min_buffer_size;
1386  uint32_t max_buffer_size;
1388  /* configure Builtin readers: */
1389  DDS_Duration_t heartbeat_response_delay;
1390  unsigned char send_initial_nack;
1392  /* configure RTPS msglen submessage */
1393  unsigned char send_msglen_submsg;
1394  } CoreDX_DiscoveryQosPolicy;
1395 #define DDS_DiscoveryQosPolicy CoreDX_DiscoveryQosPolicy
1396 
1400  typedef struct CoreDX_ThreadModelQosPolicy {
1401  unsigned char use_threads;
1402  unsigned char create_listener_thread;
1403  } CoreDX_ThreadModelQosPolicy;
1404 #define DDS_ThreadModelQosPolicy CoreDX_ThreadModelQosPolicy
1405 
1412  typedef struct DDS_DomainParticipantFactoryQos {
1413  DDS_EntityFactoryQosPolicy entity_factory;
1414  } DDS_DomainParticipantFactoryQos;
1415 #define DDS_DomainParticipantFactoryQos__alloc DDS_DomainParticipantFactoryQos_alloc
1416  COREDX_C_API DDS_DomainParticipantFactoryQos * DDS_DomainParticipantFactoryQos_alloc(void);
1417  COREDX_C_API void DDS_DomainParticipantFactoryQos_destroy(DDS_DomainParticipantFactoryQos * qos);
1418  COREDX_C_API void DDS_DomainParticipantFactoryQos_init(DDS_DomainParticipantFactoryQos * qos);
1419  COREDX_C_API void DDS_DomainParticipantFactoryQos_clear(DDS_DomainParticipantFactoryQos * qos);
1420  COREDX_C_API void DDS_DomainParticipantFactoryQos_copy(DDS_DomainParticipantFactoryQos * to, const DDS_DomainParticipantFactoryQos * from);
1421 
1431  typedef struct DDS_DomainParticipantQos {
1432  DDS_UserDataQosPolicy user_data;
1433  DDS_EntityFactoryQosPolicy entity_factory;
1434  CoreDX_EntityNameQosPolicy entity_name;
1435  CoreDX_LoggingQosPolicy logging;
1436  CoreDX_PeerParticipantQosPolicy peer_participants;
1438  CoreDX_DiscoveryQosPolicy discovery;
1439  CoreDX_ThreadModelQosPolicy thread_model;
1440  DDS_PropertyQosPolicy properties;
1441  } DDS_DomainParticipantQos;
1442 #define DDS_DomainParticipantQos__alloc DDS_DomainParticipantQos_alloc
1443  COREDX_C_API DDS_DomainParticipantQos * DDS_DomainParticipantQos_alloc(void);
1444  COREDX_C_API void DDS_DomainParticipantQos_destroy(DDS_DomainParticipantQos * qos);
1445  COREDX_C_API void DDS_DomainParticipantQos_init(DDS_DomainParticipantQos * qos);
1446  COREDX_C_API void DDS_DomainParticipantQos_clear(DDS_DomainParticipantQos * qos);
1447  COREDX_C_API void DDS_DomainParticipantQos_copy(DDS_DomainParticipantQos * to, const DDS_DomainParticipantQos * from);
1448 
1449 #define DDS_DATAWRITER_QOS_USE_TOPIC_QOS (void*)(-1)
1450 #define DDS_DATAREADER_QOS_USE_TOPIC_QOS (void*)(-1)
1451 
1460  typedef struct DDS_TopicQos {
1461  DDS_TopicDataQosPolicy topic_data;
1462  DDS_DurabilityQosPolicy durability;
1463  DDS_DurabilityServiceQosPolicy durability_service;
1464  DDS_DeadlineQosPolicy deadline;
1465  DDS_LatencyBudgetQosPolicy latency_budget;
1466  DDS_LivelinessQosPolicy liveliness;
1467  DDS_ReliabilityQosPolicy reliability;
1468  DDS_DestinationOrderQosPolicy destination_order;
1469  DDS_HistoryQosPolicy history;
1470  DDS_ResourceLimitsQosPolicy resource_limits;
1471  DDS_TransportPriorityQosPolicy transport_priority;
1472  DDS_LifespanQosPolicy lifespan;
1473  DDS_OwnershipQosPolicy ownership;
1474  DDS_DataRepresentationQosPolicy representation;
1478  CoreDX_EntityNameQosPolicy entity_name;
1479  CoreDX_LoggingQosPolicy logging;
1480  } DDS_TopicQos;
1481 #define DDS_TopicQos__alloc DDS_TopicQos_alloc
1482  COREDX_C_API DDS_TopicQos * DDS_TopicQos__alloc(void);
1483  COREDX_C_API DDS_TopicQos * DDS_TopicQos_alloc(void);
1484  COREDX_C_API void DDS_TopicQos_destroy(DDS_TopicQos * qos);
1485  COREDX_C_API void DDS_TopicQos_init(DDS_TopicQos * qos);
1486  COREDX_C_API void DDS_TopicQos_clear(DDS_TopicQos * qos);
1487  COREDX_C_API void DDS_TopicQos_copy(DDS_TopicQos * to, const DDS_TopicQos * from);
1488 
1498  typedef struct DDS_DataWriterQos {
1499  DDS_DurabilityQosPolicy durability;
1500  DDS_DurabilityServiceQosPolicy durability_service;
1501  DDS_DeadlineQosPolicy deadline;
1502  DDS_LatencyBudgetQosPolicy latency_budget;
1503  DDS_LivelinessQosPolicy liveliness;
1504  DDS_ReliabilityQosPolicy reliability;
1505  DDS_DestinationOrderQosPolicy destination_order;
1506  DDS_HistoryQosPolicy history;
1507  DDS_ResourceLimitsQosPolicy resource_limits;
1508  DDS_TransportPriorityQosPolicy transport_priority;
1509  DDS_LifespanQosPolicy lifespan;
1510  DDS_UserDataQosPolicy user_data;
1511  DDS_OwnershipQosPolicy ownership;
1512  DDS_OwnershipStrengthQosPolicy ownership_strength;
1513  DDS_WriterDataLifecycleQosPolicy writer_data_lifecycle;
1514  DDS_DataRepresentationQosPolicy representation;
1519  DDS_RpcQosPolicy rpc;
1522  CoreDX_EntityNameQosPolicy entity_name;
1523  CoreDX_LoggingQosPolicy logging;
1524  CoreDX_RTPSWriterQosPolicy rtps_writer;
1525  } DDS_DataWriterQos;
1526 #define DDS_DataWriterQos__alloc DDS_DataWriterQos_alloc
1527  COREDX_C_API DDS_DataWriterQos * DDS_DataWriterQos__alloc(void);
1528  COREDX_C_API DDS_DataWriterQos * DDS_DataWriterQos_alloc(void);
1529  COREDX_C_API void DDS_DataWriterQos_destroy(DDS_DataWriterQos * qos);
1530  COREDX_C_API void DDS_DataWriterQos_init(DDS_DataWriterQos * qos);
1531  COREDX_C_API void DDS_DataWriterQos_clear(DDS_DataWriterQos * qos);
1532  COREDX_C_API void DDS_DataWriterQos_copy(DDS_DataWriterQos * to, const DDS_DataWriterQos * from);
1533 
1543  typedef struct DDS_PublisherQos {
1544  DDS_PresentationQosPolicy presentation;
1551  DDS_PartitionQosPolicy partition;
1557  DDS_GroupDataQosPolicy group_data;
1558  DDS_EntityFactoryQosPolicy entity_factory;
1559  CoreDX_EntityNameQosPolicy entity_name;
1560  CoreDX_LoggingQosPolicy logging;
1561  } DDS_PublisherQos;
1562 #define DDS_PublisherQos__alloc DDS_PublisherQos_alloc
1563  COREDX_C_API DDS_PublisherQos * DDS_PublisherQos__alloc(void);
1564  COREDX_C_API DDS_PublisherQos * DDS_PublisherQos_alloc(void);
1565  COREDX_C_API void DDS_PublisherQos_destroy(DDS_PublisherQos * qos);
1566  COREDX_C_API void DDS_PublisherQos_init(DDS_PublisherQos * qos);
1567  COREDX_C_API void DDS_PublisherQos_clear(DDS_PublisherQos * qos);
1568  COREDX_C_API void DDS_PublisherQos_copy(DDS_PublisherQos * to, const DDS_PublisherQos * from);
1569 
1579  typedef struct DDS_DataReaderQos {
1580  DDS_DurabilityQosPolicy durability;
1581  DDS_DeadlineQosPolicy deadline;
1582  DDS_LatencyBudgetQosPolicy latency_budget;
1583  DDS_LivelinessQosPolicy liveliness;
1584  DDS_ReliabilityQosPolicy reliability;
1585  DDS_DestinationOrderQosPolicy destination_order;
1586  DDS_HistoryQosPolicy history;
1587  DDS_ResourceLimitsQosPolicy resource_limits;
1589  DDS_UserDataQosPolicy user_data;
1590  DDS_OwnershipQosPolicy ownership;
1591  DDS_TimeBasedFilterQosPolicy time_based_filter;
1592  DDS_ReaderDataLifecycleQosPolicy reader_data_lifecycle;
1594  DDS_DataRepresentationQosPolicy representation;
1598  DDS_TypeConsistencyEnforcementQosPolicy type_consistency;
1601  /* RPC extensions: */
1602  DDS_RpcQosPolicy rpc;
1605  /* CoreDX DDS extensions: */
1606  CoreDX_EntityNameQosPolicy entity_name;
1607  CoreDX_LoggingQosPolicy logging;
1608  CoreDX_RTPSReaderQosPolicy rtps_reader;
1609  } DDS_DataReaderQos;
1610 #define DDS_DataReaderQos__alloc DDS_DataReaderQos_alloc
1611  COREDX_C_API DDS_DataReaderQos * DDS_DataReaderQos__alloc(void);
1612  COREDX_C_API DDS_DataReaderQos * DDS_DataReaderQos_alloc(void);
1613  COREDX_C_API void DDS_DataReaderQos_destroy(DDS_DataReaderQos * qos);
1614  COREDX_C_API void DDS_DataReaderQos_init(DDS_DataReaderQos * qos);
1615  COREDX_C_API void DDS_DataReaderQos_clear(DDS_DataReaderQos * qos);
1616  COREDX_C_API void DDS_DataReaderQos_copy(DDS_DataReaderQos * to, const DDS_DataReaderQos * from);
1617 
1627  typedef struct DDS_SubscriberQos {
1628  DDS_PresentationQosPolicy presentation;
1635  DDS_PartitionQosPolicy partition;
1640  DDS_GroupDataQosPolicy group_data;
1641  DDS_EntityFactoryQosPolicy entity_factory;
1642  CoreDX_EntityNameQosPolicy entity_name;
1643  CoreDX_LoggingQosPolicy logging;
1644  } DDS_SubscriberQos;
1645 #define DDS_SubscriberQos__alloc DDS_SubscriberQos_alloc
1646  COREDX_C_API DDS_SubscriberQos * DDS_SubscriberQos__alloc(void);
1647  COREDX_C_API DDS_SubscriberQos * DDS_SubscriberQos_alloc(void);
1648  COREDX_C_API void DDS_SubscriberQos_destroy(DDS_SubscriberQos * qos);
1649  COREDX_C_API void DDS_SubscriberQos_init(DDS_SubscriberQos * qos);
1650  COREDX_C_API void DDS_SubscriberQos_clear(DDS_SubscriberQos * qos);
1651  COREDX_C_API void DDS_SubscriberQos_copy(DDS_SubscriberQos * to, const DDS_SubscriberQos * from);
1652 
1653 #define DDS_PARTICIPANT_QOS_DEFAULT NULL
1654 #define DDS_TOPIC_QOS_DEFAULT NULL
1655 #define DDS_PUBLISHER_QOS_DEFAULT NULL
1656 #define DDS_SUBSCRIBER_QOS_DEFAULT NULL
1657 #define DDS_DATAWRITER_QOS_DEFAULT NULL
1658 #define DDS_DATAREADER_QOS_DEFAULT NULL
1659 
1660  /****************************************************
1661  ** **
1662  ** CONDITION **
1663  ** **
1664  ****************************************************/
1677  COREDX_C_API unsigned char DDS_Condition_get_trigger_value(DDS_Condition c);
1678 
1679  /****************************************************
1680  ** **
1681  ** GUARD CONDITION **
1682  ** **
1683  ****************************************************/
1693  COREDX_C_API DDS_GuardCondition DDS_GuardCondition__alloc( void );
1699  COREDX_C_API void DDS_GuardCondition__free(struct _GuardCondition * gc);
1705  COREDX_C_API unsigned char DDS_GuardCondition_get_trigger_value(DDS_GuardCondition gc);
1716  COREDX_C_API DDS_ReturnCode_t DDS_GuardCondition_set_trigger_value(DDS_GuardCondition gc,
1717  unsigned char v );
1718 
1719  /****************************************************
1720  ** **
1721  ** STATUS CONDITION **
1722  ** **
1723  ****************************************************/
1734  COREDX_C_API unsigned char DDS_StatusCondition_get_trigger_value ( DDS_StatusCondition sc);
1739  COREDX_C_API DDS_StatusMask DDS_StatusCondition_get_enabled_statuses( DDS_StatusCondition sc);
1744  COREDX_C_API DDS_ReturnCode_t DDS_StatusCondition_set_enabled_statuses( DDS_StatusCondition sc,
1745  DDS_StatusMask mask );
1749  COREDX_C_API DDS_Entity DDS_StatusCondition_get_entity( DDS_StatusCondition sc);
1750 
1751  /****************************************************
1752  ** **
1753  ** READ CONDITION **
1754  ** **
1755  ****************************************************/
1769  COREDX_C_API unsigned char DDS_ReadCondition_get_trigger_value ( DDS_ReadCondition rc);
1773  COREDX_C_API DDS_DataReader DDS_ReadCondition_get_datareader ( DDS_ReadCondition rc);
1777  COREDX_C_API DDS_SampleStateKind DDS_ReadCondition_get_sample_state_mask ( DDS_ReadCondition rc);
1781  COREDX_C_API DDS_ViewStateKind DDS_ReadCondition_get_view_state_mask ( DDS_ReadCondition rc);
1785  COREDX_C_API DDS_InstanceStateKind DDS_ReadCondition_get_instance_state_mask( DDS_ReadCondition rc);
1786 
1787  /****************************************************
1788  ** **
1789  ** QUERY CONDITION **
1790  ** **
1791  ****************************************************/
1804  COREDX_C_API unsigned char DDS_QueryCondition_get_trigger_value ( DDS_QueryCondition qc);
1808  COREDX_C_API DDS_DataReader DDS_QueryCondition_get_datareader ( DDS_QueryCondition qc);
1812  COREDX_C_API DDS_SampleStateKind DDS_QueryCondition_get_sample_state_mask ( DDS_QueryCondition qc);
1816  COREDX_C_API DDS_ViewStateKind DDS_QueryCondition_get_view_state_mask ( DDS_QueryCondition qc);
1820  COREDX_C_API DDS_InstanceStateKind DDS_QueryCondition_get_instance_state_mask( DDS_QueryCondition qc);
1827  COREDX_C_API const char * DDS_QueryCondition_get_query_expression ( DDS_QueryCondition qc);
1839  COREDX_C_API DDS_ReturnCode_t DDS_QueryCondition_get_query_parameters ( DDS_QueryCondition qc,
1840  DDS_StringSeq *seq);
1856  COREDX_C_API DDS_ReturnCode_t DDS_QueryCondition_set_query_parameters ( DDS_QueryCondition qc,
1857  DDS_StringSeq *parameters);
1858 
1859  /****************************************************
1860  ** **
1861  ** WAIT SET **
1862  ** **
1863  ****************************************************/
1876  COREDX_C_API DDS_WaitSet DDS_WaitSet__alloc( void );
1884  COREDX_C_API void DDS_WaitSet__free(DDS_WaitSet ws);
1885 
1900  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_wait(DDS_WaitSet ws,
1901  DDS_ConditionSeq * active_conditions,
1902  DDS_Duration_t * timeout );
1909  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_attach_condition( DDS_WaitSet ws,
1910  DDS_Condition c );
1916  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_detach_condition( DDS_WaitSet ws,
1917  DDS_Condition c );
1923  COREDX_C_API DDS_ReturnCode_t DDS_WaitSet_get_conditions ( DDS_WaitSet ws,
1924  DDS_ConditionSeq * attached_conditions);
1925 
1926  /****************************************************
1927  ** **
1928  ** ENTITY **
1929  ** **
1930  ****************************************************/
1931  /*DDS_ReturnCode_t DDS_Entity_enable ( DDS_Entity e ); */
1932  /*unsigned char DDS_Entity_is_enabled ( DDS_Entity e ); */
1933  COREDX_C_API DDS_StatusCondition DDS_Entity_get_statuscondition( DDS_Entity e );
1934  COREDX_C_API DDS_StatusMask DDS_Entity_get_status_changes ( DDS_Entity e );
1935  COREDX_C_API DDS_InstanceHandle_t DDS_Entity_get_instance_handle( DDS_Entity e );
1936 
1937  /****************************************************
1938  ** **
1939  ** DOMAIN PARTICIPANT FACTORY **
1940  ** **
1941  ****************************************************/
1950  COREDX_C_API DDS_DomainParticipantFactory DDS_DomainParticipantFactory_get_instance();
1951 
1952 
1964  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_create_participant_ex( DDS_DomainParticipantFactory dpf,
1965  DDS_DomainId_t domain_id,
1966  DDS_DomainParticipantQos * qos,
1967  DDS_DomainParticipantListener * a_listener,
1968  DDS_StatusMask mask);
1969 
1982  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_create_participant( DDS_DomainId_t domain_id,
1983  DDS_DomainParticipantQos * qos,
1984  DDS_DomainParticipantListener * a_listener,
1985  DDS_StatusMask mask);
1986 
1993  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_license ( const char * lic );
1994 
2001  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_license_debug ( unsigned char debug );
2002 
2003 
2010  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_delete_participant ( DDS_DomainParticipant a_participant );
2016  COREDX_C_API DDS_DomainParticipant DDS_DomainParticipantFactory_lookup_participant ( DDS_DomainId_t domain_id );
2024  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_default_participant_qos ( DDS_DomainParticipantQos * qos );
2029  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_get_default_participant_qos ( DDS_DomainParticipantQos * qos);
2036  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_set_qos ( const DDS_DomainParticipantFactoryQos * qos );
2041  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipantFactory_get_qos ( DDS_DomainParticipantFactoryQos * qos );
2042 
2049  COREDX_C_API char * CoreDX_DDS_get_lib_version(void);
2050 
2058  COREDX_C_API DDS_ReturnCode_t CoreDX_DDS_get_lib_version_string( char * vstring_buf,
2059  int buf_len );
2060 
2061  /****************************************************
2062  ** **
2063  ** DOMAIN PARTICIPANT **
2064  ** **
2065  ****************************************************/
2092  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_enable ( DDS_DomainParticipant dp );
2093  COREDX_C_API unsigned char DDS_DomainParticipant_is_enabled ( DDS_DomainParticipant dp );
2098  COREDX_C_API DDS_InstanceHandle_t DDS_DomainParticipant_get_instance_handle( DDS_DomainParticipant dp );
2103  COREDX_C_API DDS_StatusCondition DDS_DomainParticipant_get_statuscondition( DDS_DomainParticipant dp );
2112  COREDX_C_API DDS_StatusMask DDS_DomainParticipant_get_status_changes ( DDS_DomainParticipant dp );
2120  COREDX_C_API DDS_Publisher DDS_DomainParticipant_create_publisher ( DDS_DomainParticipant dp,
2121  DDS_PublisherQos * qos,
2122  DDS_PublisherListener * a_listener,
2123  DDS_StatusMask mask);
2131  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_publisher ( DDS_DomainParticipant dp,
2132  DDS_Publisher p);
2140  COREDX_C_API DDS_Subscriber DDS_DomainParticipant_create_subscriber( DDS_DomainParticipant dp,
2141  DDS_SubscriberQos * qos,
2142  DDS_SubscriberListener * a_listener,
2143  DDS_StatusMask mask);
2151  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_subscriber( DDS_DomainParticipant dp,
2152  DDS_Subscriber s);
2163  COREDX_C_API DDS_Subscriber DDS_DomainParticipant_get_builtin_subscriber( struct _DomainParticipant *d );
2164 
2176  COREDX_C_API DDS_Topic DDS_DomainParticipant_create_topic( DDS_DomainParticipant dp,
2177  const char * topic_name,
2178  const char * type_name,
2179  DDS_TopicQos * qos,
2180  DDS_TopicListener * a_listener,
2181  DDS_StatusMask mask);
2190  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_topic( DDS_DomainParticipant dp,
2191  DDS_Topic a_topic);
2204  COREDX_C_API DDS_Topic DDS_DomainParticipant_find_topic( DDS_DomainParticipant dp,
2205  const char * topic_name,
2206  DDS_Duration_t * timeout);
2212  COREDX_C_API DDS_TopicDescription DDS_DomainParticipant_lookup_topicdescription( DDS_DomainParticipant dp,
2213  const char * name);
2245  COREDX_C_API DDS_ContentFilteredTopic DDS_DomainParticipant_create_contentfilteredtopic( DDS_DomainParticipant dp,
2246  const char * name,
2247  const DDS_Topic related_topic,
2248  const char * filter_expression,
2249  const DDS_StringSeq * filter_parameters);
2259  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_contentfilteredtopic( DDS_DomainParticipant dp,
2260  DDS_ContentFilteredTopic a_contentfilteredtopic);
2266  COREDX_C_API DDS_MultiTopic DDS_DomainParticipant_create_multitopic( DDS_DomainParticipant dp,
2267  const char * name,
2268  const char * type_name,
2269  const char * subscription_expression,
2270  const DDS_StringSeq * expression_parameters);
2276  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_multitopic( DDS_DomainParticipant dp,
2277  DDS_MultiTopic a_multitopic);
2278 
2288  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_delete_contained_entities( DDS_DomainParticipant dp );
2293  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_qos( DDS_DomainParticipant dp,
2294  const DDS_DomainParticipantQos * qos);
2300  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_qos( DDS_DomainParticipant dp,
2301  DDS_DomainParticipantQos * qos);
2310  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_listener( DDS_DomainParticipant dp,
2311  DDS_DomainParticipantListener * a_listener,
2312  DDS_StatusMask mask);
2313 
2322  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_listener_cd( DDS_DomainParticipant dp,
2323  DDS_DomainParticipantListener_cd * a_listener,
2324  DDS_StatusMask mask,
2325  void * callback_data);
2335  COREDX_C_API DDS_DomainParticipantListener * DDS_DomainParticipant_get_listener( DDS_DomainParticipant dp );
2344  COREDX_C_API DDS_DomainParticipantListener_cd * DDS_DomainParticipant_get_listener_cd( DDS_DomainParticipant dp );
2353  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_participant ( DDS_DomainParticipant dp,
2354  const DDS_InstanceHandle_t handle);
2363  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_topic ( DDS_DomainParticipant dp,
2364  const DDS_InstanceHandle_t handle);
2372  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_publication ( DDS_DomainParticipant dp,
2373  const DDS_InstanceHandle_t handle);
2381  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_ignore_subscription ( DDS_DomainParticipant dp,
2382  const DDS_InstanceHandle_t handle);
2387  COREDX_C_API DDS_DomainId_t DDS_DomainParticipant_get_domain_id( DDS_DomainParticipant dp );
2388 
2400  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_assert_liveliness( DDS_DomainParticipant dp );
2401 
2409  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_publisher_qos( DDS_DomainParticipant d,
2410  DDS_PublisherQos * qos);
2411 
2416  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_publisher_qos( DDS_DomainParticipant d,
2417  DDS_PublisherQos * qos);
2425  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_subscriber_qos( DDS_DomainParticipant d,
2426  DDS_SubscriberQos * qos);
2431  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_subscriber_qos( DDS_DomainParticipant d,
2432  DDS_SubscriberQos * qos);
2440  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_set_default_topic_qos( DDS_DomainParticipant d,
2441  DDS_TopicQos * qos);
2446  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_default_topic_qos( DDS_DomainParticipant d,
2447  DDS_TopicQos * qos);
2455  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_participants( DDS_DomainParticipant d,
2456  DDS_InstanceHandleSeq * participant_handles );
2464  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_participant_data( DDS_DomainParticipant d,
2465  DDS_ParticipantBuiltinTopicData * participant_data,
2466  const DDS_InstanceHandle_t participant_handle);
2474  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topics( DDS_DomainParticipant d,
2475  DDS_InstanceHandleSeq * topic_handles);
2483  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topic_data( DDS_DomainParticipant d,
2484  DDS_TopicBuiltinTopicData * topic_data,
2485  const DDS_InstanceHandle_t topic_handle);
2486 
2494  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_publication_data( DDS_DomainParticipant dp,
2495  DDS_PublicationBuiltinTopicData * publication_data,
2496  const DDS_InstanceHandle_t publication_handle);
2504  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_subscription_data( DDS_DomainParticipant dp,
2505  DDS_SubscriptionBuiltinTopicData * subscription_data,
2506  const DDS_InstanceHandle_t subscription_handle);
2507 
2515  COREDX_C_API unsigned char DDS_DomainParticipant_contains_entity( DDS_DomainParticipant d,
2516  const DDS_InstanceHandle_t a_handle);
2521  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_current_time( DDS_DomainParticipant d,
2522  DDS_Time_t * current_time);
2530  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_register_type( DDS_DomainParticipant dp,
2531  DDS_TypeSupport ts,
2532  const char * type_name );
2542  COREDX_C_API int DDS_DomainParticipant_check_version( DDS_DomainParticipant dp,
2543  const char * major,
2544  const char * minor,
2545  const char * patch);
2552  COREDX_C_API int DDS_DomainParticipant_validate_version( DDS_DomainParticipant dp,
2553  const char * source,
2554  const char * major,
2555  const char * minor,
2556  const char * patch);
2568  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_do_work( DDS_DomainParticipant dp,
2569  const DDS_Duration_t *time_slice );
2574  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_builtin_wait_for_acknowledgments( DDS_DomainParticipant dp,
2575  const DDS_Duration_t *max_wait );
2580  COREDX_C_API void DDS_DomainParticipant_print_stats(DDS_DomainParticipant dp);
2591  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_add_transport(DDS_DomainParticipant dp,
2592  struct CoreDX_Transport * transport);
2597  COREDX_C_API DDS_ReturnCode_t DDS_DomainParticipant_get_guid(DDS_DomainParticipant dp,
2598  DDS_GUID_t * guid);
2609  COREDX_C_ADD_API DDS_ReturnCode_t DDS_DomainParticipant_create_typesupport_from_typecode( DDS_DomainParticipant dp,
2610  DDS_TypecodeQosPolicy * tc_qos,
2611  DDS_TypeSupport * ts /* out */);
2622  COREDX_C_ADD_API DDS_ReturnCode_t DDS_DomainParticipant_create_typesupport_from_typeobj( DDS_DomainParticipant dp,
2623  DDS_TypecodeQosPolicy * tc_qos,
2624  DDS_TypeSupport * ts /* out */);
2625 
2626 
2627  /****************************************************
2628  ** **
2629  ** SUBSCRIBER **
2630  ** **
2631  ****************************************************/
2652  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_enable ( DDS_Subscriber s );
2653  COREDX_C_API unsigned char DDS_Subscriber_is_enabled ( DDS_Subscriber s );
2658  COREDX_C_API DDS_InstanceHandle_t DDS_Subscriber_get_instance_handle( DDS_Subscriber s );
2663  COREDX_C_API DDS_DomainParticipant DDS_Subscriber_get_participant ( DDS_Subscriber s );
2668  COREDX_C_API DDS_StatusCondition DDS_Subscriber_get_statuscondition( DDS_Subscriber s );
2677  COREDX_C_API DDS_StatusMask DDS_Subscriber_get_status_changes ( DDS_Subscriber s );
2691  COREDX_C_API DDS_DataReader DDS_Subscriber_create_datareader ( DDS_Subscriber s,
2692  DDS_TopicDescription a_topic,
2693  DDS_DataReaderQos * qos,
2694  DDS_DataReaderListener* a_listener,
2695  DDS_StatusMask mask);
2705  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_delete_datareader ( DDS_Subscriber s,
2706  DDS_DataReader a_datareader);
2717  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_delete_contained_entities( DDS_Subscriber s );
2725  COREDX_C_API DDS_DataReader DDS_Subscriber_lookup_datareader( DDS_Subscriber s,
2726  const char * topic_name);
2743  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_datareaders( DDS_Subscriber s,
2744  DDS_DataReaderSeq * readers,
2745  DDS_SampleStateMask sample_states,
2746  DDS_ViewStateMask view_states,
2747  DDS_InstanceStateMask instance_states) ;
2753  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_notify_datareaders( DDS_Subscriber s );
2758  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_qos( DDS_Subscriber s,
2759  DDS_SubscriberQos * qos);
2772  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_qos( DDS_Subscriber s,
2773  DDS_SubscriberQos * qos);
2782  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_listener( DDS_Subscriber s,
2783  DDS_SubscriberListener * a_listener,
2784  DDS_StatusMask mask);
2793  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_listener_cd( DDS_Subscriber s,
2794  DDS_SubscriberListener_cd * listener_cd,
2795  DDS_StatusMask mask,
2796  void * callback_data);
2806  COREDX_C_API DDS_SubscriberListener *DDS_Subscriber_get_listener( DDS_Subscriber s );
2815  COREDX_C_API DDS_SubscriberListener_cd *DDS_Subscriber_get_listener_cd( DDS_Subscriber s );
2823  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_begin_access( DDS_Subscriber s );
2828  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_end_access( DDS_Subscriber s );
2837  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_set_default_datareader_qos( DDS_Subscriber s,
2838  const DDS_DataReaderQos * qos);
2843  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_get_default_datareader_qos( DDS_Subscriber s,
2844  DDS_DataReaderQos * qos);
2851  COREDX_C_API DDS_ReturnCode_t DDS_Subscriber_copy_from_topic_qos( DDS_Subscriber s,
2852  DDS_DataReaderQos * a_datareader_qos,
2853  DDS_TopicQos * a_topic_qos);
2854 
2855 
2856  /****************************************************
2857  ** **
2858  ** PUBLISHER **
2859  ** **
2860  ****************************************************/
2881  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_enable ( DDS_Publisher p );
2882  COREDX_C_API unsigned char DDS_Publisher_is_enabled ( DDS_Publisher p );
2887  COREDX_C_API DDS_InstanceHandle_t DDS_Publisher_get_instance_handle( DDS_Publisher p );
2892  COREDX_C_API DDS_DomainParticipant DDS_Publisher_get_participant ( DDS_Publisher p );
2897  COREDX_C_API DDS_StatusCondition DDS_Publisher_get_statuscondition( DDS_Publisher p );
2906  COREDX_C_API DDS_StatusMask DDS_Publisher_get_status_changes ( DDS_Publisher p );
2920  COREDX_C_API DDS_DataWriter DDS_Publisher_create_datawriter ( DDS_Publisher p,
2921  DDS_Topic a_topic,
2922  const DDS_DataWriterQos * qos,
2923  DDS_DataWriterListener * a_listener,
2924  DDS_StatusMask mask);
2930  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_delete_datawriter (DDS_Publisher p,
2931  DDS_DataWriter a_datawriter);
2938  COREDX_C_API DDS_DataWriter DDS_Publisher_lookup_datawriter(DDS_Publisher p,
2939  const char * topic_name);
2949  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_delete_contained_entities(DDS_Publisher p );
2954  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_qos( DDS_Publisher p,
2955  const DDS_PublisherQos * qos);
2969  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_get_qos( DDS_Publisher p,
2970  DDS_PublisherQos * qos);
2979  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_listener( DDS_Publisher p,
2980  DDS_PublisherListener * a_listener,
2981  DDS_StatusMask mask);
2990  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_listener_cd( DDS_Publisher p,
2991  DDS_PublisherListener_cd * a_listener,
2992  DDS_StatusMask mask,
2993  void * callback_data);
3003  COREDX_C_API DDS_PublisherListener *DDS_Publisher_get_listener(DDS_Publisher p );
3012  COREDX_C_API DDS_PublisherListener_cd *DDS_Publisher_get_listener_cd(DDS_Publisher p );
3016  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_suspend_publications(DDS_Publisher p );
3020  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_resume_publications(DDS_Publisher p );
3024  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_begin_coherent_changes(DDS_Publisher p );
3028  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_end_coherent_changes(DDS_Publisher p );
3037  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_wait_for_acknowledgments(DDS_Publisher p,
3038  const DDS_Duration_t * max_wait);
3039 #define DDS_Publisher_wait_for_acknowledgements DDS_Publisher_wait_for_acknowledgments
3040 
3049  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_set_default_datawriter_qos(DDS_Publisher p,
3050  const DDS_DataWriterQos * qos);
3055  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_get_default_datawriter_qos(DDS_Publisher p,
3056  struct DDS_DataWriterQos * qos);
3063  COREDX_C_API DDS_ReturnCode_t DDS_Publisher_copy_from_topic_qos(DDS_Publisher p,
3064  struct DDS_DataWriterQos * a_datawriter_qos,
3065  const DDS_TopicQos * a_topic_qos);
3066 
3067  /****************************************************
3068  ** **
3069  ** TOPIC DESCRIPTION **
3070  ** **
3071  ****************************************************/
3082  COREDX_C_API const char * DDS_TopicDescription_get_type_name( DDS_TopicDescription td );
3087  COREDX_C_API const char * DDS_TopicDescription_get_name ( DDS_TopicDescription td );
3091  COREDX_C_API DDS_DomainParticipant DDS_TopicDescription_get_participant( DDS_TopicDescription td );
3092 
3093  /****************************************************
3094  ** **
3095  ** TOPIC **
3096  ** **
3097  ****************************************************/
3112  COREDX_C_API DDS_TopicDescription DDS_Topic_TopicDescription(DDS_Topic t);
3116  COREDX_C_API const char * DDS_Topic_get_type_name( DDS_Topic t);
3120  COREDX_C_API const char * DDS_Topic_get_name( DDS_Topic t ) ;
3124  COREDX_C_API DDS_DomainParticipant DDS_Topic_get_participant( DDS_Topic t );
3139  COREDX_C_API DDS_ReturnCode_t DDS_Topic_enable( DDS_Topic t );
3140  COREDX_C_API unsigned char DDS_Topic_is_enabled( DDS_Topic t );
3145  COREDX_C_API DDS_InstanceHandle_t DDS_Topic_get_instance_handle(DDS_Topic t);
3150  COREDX_C_API DDS_StatusCondition DDS_Topic_get_statuscondition( DDS_Topic t );
3156  COREDX_C_API DDS_StatusMask DDS_Topic_get_status_changes( DDS_Topic t );
3161  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_qos( DDS_Topic t,
3162  const DDS_TopicQos * qos);
3174  COREDX_C_API DDS_ReturnCode_t DDS_Topic_get_qos( DDS_Topic t,
3175  DDS_TopicQos * qos);
3184  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_listener( DDS_Topic t,
3185  DDS_TopicListener * a_listener,
3186  DDS_StatusMask mask);
3195  COREDX_C_API DDS_ReturnCode_t DDS_Topic_set_listener_cd( DDS_Topic t,
3196  DDS_TopicListener_cd * a_listener,
3197  DDS_StatusMask mask,
3198  void * callback_data);
3208  COREDX_C_API DDS_TopicListener * DDS_Topic_get_listener( DDS_Topic t );
3217  COREDX_C_API DDS_TopicListener_cd * DDS_Topic_get_listener_cd( DDS_Topic t );
3222  COREDX_C_API DDS_ReturnCode_t DDS_Topic_get_inconsistent_topic_status ( DDS_Topic t,
3223  DDS_InconsistentTopicStatus * a_status);
3224 
3225  /****************************************************
3226  ** **
3227  ** CONTENT FILTERED TOPIC **
3228  ** **
3229  ****************************************************/
3265  COREDX_C_API DDS_TopicDescription DDS_ContentFilteredTopic_TopicDescription(DDS_ContentFilteredTopic t);
3266  COREDX_C_API const char * DDS_ContentFilteredTopic_get_type_name( DDS_ContentFilteredTopic t);
3267  COREDX_C_API const char * DDS_ContentFilteredTopic_get_name( DDS_ContentFilteredTopic t );
3268  COREDX_C_API DDS_DomainParticipant DDS_ContentFilteredTopic_get_participant( DDS_Topic t );
3273  COREDX_C_API DDS_Topic DDS_ContentFilteredTopic_get_related_topic( DDS_ContentFilteredTopic t);
3278  COREDX_C_API DDS_ReturnCode_t DDS_ContentFilteredTopic_get_expression_parameters(DDS_ContentFilteredTopic t,
3279  DDS_StringSeq *parameters);
3290  COREDX_C_API DDS_ReturnCode_t DDS_ContentFilteredTopic_set_expression_parameters(DDS_ContentFilteredTopic t,
3291  const DDS_StringSeq *parameters);
3292 
3293  /****************************************************
3294  ** **
3295  ** MULTI TOPIC **
3296  ** **
3297  ****************************************************/
3306  COREDX_C_API DDS_TopicDescription DDS_MultiTopic_TopicDescription(DDS_MultiTopic t);
3307  COREDX_C_API const char * DDS_MultiTopic_get_type_name( DDS_MultiTopic t);
3308  COREDX_C_API const char * DDS_MultiTopic_get_name( DDS_MultiTopic t );
3309  COREDX_C_API DDS_DomainParticipant DDS_MultiTopic_get_participant( DDS_Topic t );
3310  COREDX_C_API DDS_ReturnCode_t DDS_MultiTopic_get_expression_parameters(DDS_MultiTopic t,
3311  DDS_StringSeq *parameters);
3312  COREDX_C_API DDS_ReturnCode_t DDS_MultiTopic_set_expression_parameters(DDS_MultiTopic t,
3313  const DDS_StringSeq *parameters);
3314 
3315  /****************************************************
3316  ** **
3317  ** DATA WRITER **
3318  ** **
3319  ****************************************************/
3341  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_enable ( DDS_DataWriter dw );
3342  COREDX_C_API unsigned char DDS_DataWriter_is_enabled ( DDS_DataWriter dw );
3347  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_get_instance_handle( DDS_DataWriter dw );
3352  COREDX_C_API DDS_StatusCondition DDS_DataWriter_get_statuscondition( DDS_DataWriter dw );
3358  COREDX_C_API DDS_StatusMask DDS_DataWriter_get_status_changes ( DDS_DataWriter dw );
3363  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_qos(DDS_DataWriter dw,
3364  const DDS_DataWriterQos * qos);
3376  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_qos(DDS_DataWriter dw,
3377  DDS_DataWriterQos * qos);
3386  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_listener(DDS_DataWriter dw,
3387  DDS_DataWriterListener * a_listener,
3388  DDS_StatusMask mask);
3397  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_set_listener_cd(DDS_DataWriter dw,
3398  DDS_DataWriterListener_cd * a_listener,
3399  DDS_StatusMask mask,
3400  void * callback_data);
3410  COREDX_C_API DDS_DataWriterListener * DDS_DataWriter_get_listener(DDS_DataWriter dw);
3419  COREDX_C_API DDS_DataWriterListener_cd * DDS_DataWriter_get_listener_cd(DDS_DataWriter dw);
3428  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_wait_for_acknowledgments(DDS_DataWriter dw,
3429  const DDS_Duration_t * max_wait);
3430 #define DDS_DataWriter_wait_for_acknowledgements DDS_DataWriter_wait_for_acknowledgments
3431 
3436  COREDX_C_API DDS_Topic DDS_DataWriter_get_topic(DDS_DataWriter dw);
3441  COREDX_C_API DDS_Publisher DDS_DataWriter_get_publisher(DDS_DataWriter dw);
3451  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_assert_liveliness(DDS_DataWriter dw);
3459  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_matched_subscriptions(DDS_DataWriter dw,
3460  DDS_InstanceHandleSeq *subscription_handles);
3468  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_data(DDS_DataWriter dw,
3469  DDS_SubscriptionBuiltinTopicData * subscription_data,
3470  const DDS_InstanceHandle_t subscription_handle);
3475  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_liveliness_lost_status ( DDS_DataWriter dw,
3476  DDS_LivelinessLostStatus *status);
3481  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_offered_deadline_missed_status ( DDS_DataWriter dw,
3482  DDS_OfferedDeadlineMissedStatus *status);
3487  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_offered_incompatible_qos_status ( DDS_DataWriter dw,
3488  DDS_OfferedIncompatibleQosStatus *status);
3493  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_publication_matched_status ( DDS_DataWriter dw,
3494  DDS_PublicationMatchedStatus *status);
3499  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_cache_stats( DDS_DataWriter dw,
3500  DDS_CacheStatistics * stats );
3504  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_guid(DDS_DataWriter dw,
3505  DDS_GUID_t * guid);
3506 
3507  /***********************************************************************/
3508  /* */
3509  /* BASE read/take operations used by generated application DataWriters */
3510  /* */
3511  /* NOTE: */
3512  /* */
3513  /* DDS Users should not call these directly. Call the corresponding */
3514  /* type specific routines found in the DDL Generated code. */
3515  /* */
3516 
3524  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_get_key_value( DDS_DataWriter dw,
3525  void * key_holder,
3526  const DDS_InstanceHandle_t handle);
3531  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_lookup_instance(DDS_DataWriter dw,
3532  const void * instance_data);
3538  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_register_instance(DDS_DataWriter dw,
3539  const void * instance_data);
3540 
3546  COREDX_C_API DDS_InstanceHandle_t DDS_DataWriter_register_instance_w_timestamp(DDS_DataWriter dw,
3547  const void * instance_data,
3548  const DDS_Time_t source_timestamp);
3549 
3556  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_unregister_instance(DDS_DataWriter dw,
3557  const void * instance_data,
3558  const DDS_InstanceHandle_t handle);
3559 
3566  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_unregister_instance_w_timestamp(DDS_DataWriter dw,
3567  const void * instance_data,
3568  DDS_InstanceHandle_t handle,
3569  const DDS_Time_t source_timestamp);
3582  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write(DDS_DataWriter dw,
3583  const void * instance_data,
3584  const DDS_InstanceHandle_t handle);
3585 
3598  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write_w_timestamp(DDS_DataWriter dw,
3599  const void * instance_data,
3600  const DDS_InstanceHandle_t handle,
3601  const DDS_Time_t source_timestamp);
3602 
3609  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_dispose(DDS_DataWriter dw,
3610  const void * instance_data,
3611  const DDS_InstanceHandle_t instance_handle);
3612 
3619  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_dispose_w_timestamp(DDS_DataWriter dw,
3620  const void * instance_data,
3621  const DDS_InstanceHandle_t instance_handle,
3622  const DDS_Time_t source_timestamp);
3623 
3624  COREDX_C_API DDS_ReturnCode_t DDS_DataWriter_write_request(struct _DataWriter * dw,
3625  const void * instance_data,
3626  const DDS_InstanceHandle_t handle,
3627  /*inout*/ unsigned char * sampleid_cdr,
3628  /*in */ int32_t sampleid_cdr_len);
3629 
3630  /* END */
3631  /* BASE read/take operations used by generated application DataWriters */
3632  /***********************************************************************/
3633 
3634  /****************************************************
3635  ** **
3636  ** DATA READER **
3637  ** **
3638  ****************************************************/
3660  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_enable ( DDS_DataReader dr );
3661  COREDX_C_API unsigned char DDS_DataReader_is_enabled ( DDS_DataReader dr );
3666  COREDX_C_API DDS_InstanceHandle_t DDS_DataReader_get_instance_handle( DDS_DataReader dr );
3672  COREDX_C_API DDS_StatusMask DDS_DataReader_get_status_changes ( DDS_DataReader dr );
3681  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_delete_contained_entities(DDS_DataReader dr );
3686  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_qos (DDS_DataReader dr,
3687  const DDS_DataReaderQos * qos);
3699  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_qos(DDS_DataReader dr,
3700  DDS_DataReaderQos * qos);
3709  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_listener(DDS_DataReader dr,
3710  DDS_DataReaderListener * a_listener,
3711  DDS_StatusMask mask);
3720  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_set_listener_cd(DDS_DataReader dr,
3721  DDS_DataReaderListener_cd * a_listener,
3722  DDS_StatusMask mask,
3723  void * callback_data);
3733  COREDX_C_API DDS_DataReaderListener * DDS_DataReader_get_listener(DDS_DataReader dr);
3742  COREDX_C_API DDS_DataReaderListener_cd * DDS_DataReader_get_listener_cd(DDS_DataReader dr);
3748  COREDX_C_API DDS_TopicDescription DDS_DataReader_get_topicdescription( DDS_DataReader dr );
3753  COREDX_C_API DDS_Subscriber DDS_DataReader_get_subscriber( DDS_DataReader dr );
3754 
3759  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_wait_for_historical_data( DDS_DataReader dr,
3760  const DDS_Duration_t * max_wait);
3765  COREDX_C_API DDS_StatusCondition DDS_DataReader_get_statuscondition( DDS_DataReader dr );
3772  COREDX_C_API DDS_ReadCondition DDS_DataReader_create_readcondition( DDS_DataReader dr,
3773  DDS_SampleStateMask sample_states,
3774  DDS_ViewStateMask view_states,
3775  DDS_InstanceStateMask instance_states);
3786  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_delete_readcondition(DDS_DataReader dr,
3787  DDS_ReadCondition a_condition);
3820  COREDX_C_API DDS_QueryCondition DDS_DataReader_create_querycondition(DDS_DataReader dr,
3821  DDS_SampleStateMask sample_states,
3822  DDS_ViewStateMask view_states,
3823  DDS_InstanceStateMask instance_states,
3824  const char * query_expression,
3825  const DDS_StringSeq * query_parameters);
3826 
3834  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_matched_publications(DDS_DataReader dr,
3835  DDS_InstanceHandleSeq * publication_handles);
3843  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_matched_publication_data( DDS_DataReader dr,
3844  DDS_PublicationBuiltinTopicData * publication_data,
3845  const DDS_InstanceHandle_t publication_handle);
3860  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_return_loan(DDS_DataReader dr,
3861  DDS_PointerSeq * received_data,
3862  DDS_SampleInfoSeq * sample_infos);
3867  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_sample_rejected_status(DDS_DataReader dr,
3868  DDS_SampleRejectedStatus *status );
3873  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_liveliness_changed_status(DDS_DataReader dr,
3874  DDS_LivelinessChangedStatus *status);
3879  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_requested_deadline_missed_status(DDS_DataReader dr,
3880  DDS_RequestedDeadlineMissedStatus *status);
3885  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_requested_incompatible_qos_status(DDS_DataReader dr,
3886  DDS_RequestedIncompatibleQosStatus *status );
3891  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_subscription_matched_status(DDS_DataReader dr,
3892  DDS_SubscriptionMatchedStatus *status );
3897  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_sample_lost_status(DDS_DataReader dr,
3898  DDS_SampleLostStatus *status );
3902  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_guid(DDS_DataReader dr,
3903  DDS_GUID_t *guid);
3904 
3909  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_cache_stats( DDS_DataReader dr,
3910  DDS_CacheStatistics * stats );
3911 
3912  /***********************************************************************/
3913  /* */
3914  /* BASE read/take operations used by generated application DataReaders */
3915  /* */
3916  /* NOTE: */
3917  /* */
3918  /* DDS Users should not call these directly. Call the corresponding */
3919  /* type specific routines found in the DDL Generated code. */
3920  /* */
3921 
3929  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_get_key_value(DDS_DataReader dr,
3930  void * key_holder,
3931  DDS_InstanceHandle_t handle);
3938  COREDX_C_API DDS_InstanceHandle_t DDS_DataReader_lookup_instance(DDS_DataReader dr,
3939  void * instance_data);
3980  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read(DDS_DataReader dr,
3981  DDS_PointerSeq * received_data,
3982  DDS_SampleInfoSeq * sample_infos,
3983  int32_t max_samples,
3984  DDS_SampleStateMask sample_states,
3985  DDS_ViewStateMask view_states,
3986  DDS_InstanceStateMask instance_states);
3987 
3988 
4029  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take(DDS_DataReader dr,
4030  DDS_PointerSeq * received_data,
4031  DDS_SampleInfoSeq * sample_infos,
4032  int32_t max_samples,
4033  DDS_SampleStateMask sample_states,
4034  DDS_ViewStateMask view_states,
4035  DDS_InstanceStateMask instance_states);
4036 
4045  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_w_condition(DDS_DataReader dr,
4046  DDS_PointerSeq * received_data,
4047  DDS_SampleInfoSeq * sample_infos,
4048  int32_t max_samples,
4049  DDS_ReadCondition a_condition);
4050 
4059  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_w_condition(DDS_DataReader dr,
4060  DDS_PointerSeq * received_data,
4061  DDS_SampleInfoSeq * sample_infos,
4062  int32_t max_samples,
4063  DDS_ReadCondition a_condition);
4064 
4072  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_sample(DDS_DataReader dr,
4073  void * received_data,
4074  DDS_SampleInfo * sample_info);
4075 
4083  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_sample(DDS_DataReader dr,
4084  void * received_data,
4085  DDS_SampleInfo * sample_info);
4086 
4095  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_instance(DDS_DataReader dr,
4096  DDS_PointerSeq * received_data,
4097  DDS_SampleInfoSeq * sample_infos,
4098  int32_t max_samples,
4099  DDS_InstanceHandle_t a_handle,
4100  DDS_SampleStateMask sample_states,
4101  DDS_ViewStateMask view_states,
4102  DDS_InstanceStateMask instance_states);
4103 
4104 
4113  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_instance(DDS_DataReader dr,
4114  DDS_PointerSeq * received_data,
4115  DDS_SampleInfoSeq * sample_infos,
4116  int32_t max_samples,
4117  DDS_InstanceHandle_t a_handle,
4118  DDS_SampleStateMask sample_states,
4119  DDS_ViewStateMask view_states,
4120  DDS_InstanceStateMask instance_states);
4121 
4130  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_instance(DDS_DataReader dr,
4131  DDS_PointerSeq * received_data,
4132  DDS_SampleInfoSeq * sample_infos,
4133  int32_t max_samples,
4134  DDS_InstanceHandle_t previous_handle,
4135  DDS_SampleStateMask sample_states,
4136  DDS_ViewStateMask view_states,
4137  DDS_InstanceStateMask instance_states);
4138 
4147  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_instance(DDS_DataReader dr,
4148  DDS_PointerSeq * received_data,
4149  DDS_SampleInfoSeq * sample_infos,
4150  int32_t max_samples,
4151  DDS_InstanceHandle_t previous_handle,
4152  DDS_SampleStateMask sample_states,
4153  DDS_ViewStateMask view_states,
4154  DDS_InstanceStateMask instance_states);
4155 
4164  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_read_next_instance_w_condition(DDS_DataReader dr,
4165  DDS_PointerSeq * received_data,
4166  DDS_SampleInfoSeq * sample_infos,
4167  int32_t max_samples,
4168  DDS_InstanceHandle_t previous_handle,
4169  DDS_ReadCondition a_condition);
4170 
4179  COREDX_C_API DDS_ReturnCode_t DDS_DataReader_take_next_instance_w_condition(DDS_DataReader dr,
4180  DDS_PointerSeq * received_data,
4181  DDS_SampleInfoSeq * sample_infos,
4182  int32_t max_samples,
4183  DDS_InstanceHandle_t previous_handle,
4184  DDS_ReadCondition a_condition);
4185  /* END */
4186  /* BASE read/take operations used by generated application DataReaders */
4187  /***********************************************************************/
4188 
4189  COREDX_C_API void * DDS_InstanceHandle_get_key(DDS_InstanceHandle_t handle);
4190 
4191  /***********************************************************************/
4192  /* TWIN OAKS HELPER EXTENSIONS: */
4193  COREDX_C_API const char * DDS_qos_policy_str(DDS_QosPolicyId_t policy);
4194  COREDX_C_API const char * DDS_error( DDS_ReturnCode_t retcode );
4195  COREDX_C_API const char * DDS_sample_state( DDS_SampleStateMask sm );
4196  COREDX_C_API const char * DDS_view_state ( DDS_ViewStateMask vm );
4197  COREDX_C_API const char * DDS_instance_state (DDS_InstanceStateMask im );
4198 
4199 #include <dds/coredx_version.h>
4200 
4201 #ifdef __cplusplus
4202 }
4203 #endif /* __cplusplus */
4204 
4205 
4206 #endif
DDS_WriterDataLifecycleQosPolicy
Specifies the lifecycle behavior of data instances managed by the DataWriter. If autodispose_unregist...
Definition: dds.h:1232
DDS_DomainParticipant
The DDS_DomainParticipant is used to configure, create and destroy Publisher, Subscriber and Topic ob...
DDS_QueryCondition
A DDS_QueryCondition is a specialized DDS_ReadCondition which includes a filter.
DDS_Condition
A DDS_Condition can be added to a DDS_WaitSet to provide synchronous event notification.
DDS_PublisherListener_cd::on_liveliness_lost
void(* on_liveliness_lost)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:439
DDS_PublisherQos::partition
DDS_PartitionQosPolicy partition
Establishes a logical data partition.
Definition: dds.h:1551
CoreDX_DiscoveryQosPolicy::nack_suppress_delay
DDS_Duration_t nack_suppress_delay
The nack_suppress_delay to configure for builtin writers.
Definition: dds.h:1384
DDS_DataReaderQos::rtps_reader
CoreDX_RTPSReaderQosPolicy rtps_reader
rtps_reader configuration
Definition: dds.h:1608
DDS_DataReaderQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1606
DDS_PropertyQosPolicy
Definition: dds_builtin.h:1178
DDS_SubscriberQos
Structure that holds DDS_Subscriber Quality of Service policies.
Definition: dds.h:1627
DDS_DataReaderQos::reliability
DDS_ReliabilityQosPolicy reliability
The transport reliability requested by the DataReader.
Definition: dds.h:1584
DDS_PresentationQosPolicy
Controls the presentation of received data samples to the application. CoreDX DDS currently supports ...
Definition: dds_builtin.h:318
DDS_PublisherQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1560
DDS_ReaderDataLifecycleQosPolicy::autopurge_disposed_samples_delay
DDS_Duration_t autopurge_disposed_samples_delay
delay after which it is ok to purge samples from instances that are disposed
Definition: dds.h:1245
DDS_TopicQos
Structure that holds DDS_Topic Quality of Service policies.
Definition: dds.h:1460
DDS_OfferedIncompatibleQosStatus
Status related to the on_offered_incompatible_qos listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:344
CoreDX_RTPSWriterQosPolicy::send_typecode
unsigned char send_typecode
Definition: dds.h:1348
DDS_CacheStatistics
Encapsulates statistics available from a DataReader or DataWriter.
Definition: dds_types.h:419
CoreDX_ParticipantLocator::participant_id
uint32_t participant_id
participant id start
Definition: dds.h:1315
DDS_GuardCondition
struct _GuardCondition * DDS_GuardCondition
A DDS_GuardCondition is a condition where the trigger_value is under application control.
Definition: dds.h:160
DDS_TypecodeQosPolicy
Typecode representing the datatype a DataReader reads or a DataWriter writes.
Definition: dds_builtin.h:1034
DDS_DomainParticipantQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1434
DDS_SubscriberListener_cd::on_liveliness_changed
void(* on_liveliness_changed)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:748
DDS_PublisherQos::presentation
DDS_PresentationQosPolicy presentation
Controls the presentation of groups of changes.
Definition: dds.h:1544
DDS_DataWriterQos::resource_limits
DDS_ResourceLimitsQosPolicy resource_limits
The resource limits set on the DataWriter.
Definition: dds.h:1507
CoreDX_RTPSReaderQosPolicy::send_typecode
unsigned char send_typecode
Definition: dds.h:1357
DDS_PartitionQosPolicy
Defines a logical data partition.
Definition: dds_builtin.h:634
DDS_SubscriberListener_cd::on_requested_incompatible_qos
void(* on_requested_incompatible_qos)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:724
DDS_LivelinessChangedStatus
Status related to the on_liveliness_changed listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:296
DDS_DomainParticipantFactory
The DDS_DomainParticipantFactory is used to configure, create and destroy DomainParticipant objects...
DDS_TopicQos::durability_service
DDS_DurabilityServiceQosPolicy durability_service
Configures the service supporting the TRANSIENT and PERSITENT durability kinds.
Definition: dds.h:1463
DDS_DataWriterQos::ownership
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; offered by the DataWriter.
Definition: dds.h:1511
CoreDX_RTPSWriterQosPolicy::min_buffer_size
uint32_t min_buffer_size
Definition: dds.h:1344
DDS_DataReaderQos::deadline
DDS_DeadlineQosPolicy deadline
The requested update frequency for data instances.
Definition: dds.h:1581
DDS_ReaderDataLifecycleQosPolicy
Specifies the lifecycle behavior of data instances managed by the DataReader.
Definition: dds.h:1243
CoreDX_PeerParticipantQosPolicy::value
CoreDX_ParticipantLocatorSeq value
Definition: dds.h:1327
DDS_PublisherListener
The DDS_PublisherListener provides asynchronous notification of DDS_Publisher events.
Definition: dds.h:350
DDS_DataReaderListener_cd::on_requested_incompatible_qos
void(* on_requested_incompatible_qos)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:549
DDS_DataWriterQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1522
DDS_DataWriterQos::ownership_strength
DDS_OwnershipStrengthQosPolicy ownership_strength
The measure of &#39;ownership strength&#39; offered by the DataWriter.
Definition: dds.h:1512
DDS_DataReaderQos::rpc
DDS_RpcQosPolicy rpc
Configure RPC relevant settings: instance_name, related_entity, and topic_aliases.
Definition: dds.h:1602
CoreDX_Locator::port
uint32_t port
Definition: dds.h:1306
DDS_DomainParticipantQos::peer_participants
CoreDX_PeerParticipantQosPolicy peer_participants
Specifies a list of DomainParticipant peers to attempt communication with. If empty, default Discovery is used.
Definition: dds.h:1436
CoreDX_DiscoveryQosPolicy::guid_pid
DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE guid_pid
Override the default value of &#39;pid&#39; in Discovery GUID. [&#39;0&#39; means use default].
Definition: dds.h:1375
DDS_DataReaderQos::type_consistency
DDS_TypeConsistencyEnforcementQosPolicy type_consistency
Influences the algorithm that matches DataReaders and DataWriters based on their data type compatibil...
Definition: dds.h:1598
DDS_TopicQos::latency_budget
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:1465
DDS_DomainParticipantListener_cd::on_sample_lost
void(* on_sample_lost)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:1132
DDS_ReadCondition
A DDS_ReadCondition is a specialized DDS_Condition associated with a DDS_DataReader.
DDS_DataReaderQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1607
DDS_InconsistentTopicStatus
Status related to the on_inconsistent_topic listener methods of the DDS_TopicListener structure...
Definition: dds_types.h:241
DDS_EntityFactoryQosPolicy
Definition: dds.h:1219
CoreDX_EntityNameQosPolicy
Definition: dds.h:1256
DDS_DataReader
The DDS_DataReader entity allows the application to subscribe to and read data.
DDS_MultiTopic
DDS_MultiTopic provides a topic that may include data from multiple Topics.
DDS_DataReaderQos::history
DDS_HistoryQosPolicy history
The data history requested by the DataReader.
Definition: dds.h:1586
CoreDX_DiscoveryQosPolicy::nack_response_delay
DDS_Duration_t nack_response_delay
The nack_response_delay to configure for builtin writers.
Definition: dds.h:1383
DDS_RpcQosPolicy
Augment a DataWriter or DataReader with RPC specific information.
Definition: dds_builtin.h:1074
CoreDX_RTPSWriterQosPolicy::max_buffer_size
uint32_t max_buffer_size
Definition: dds.h:1345
CoreDX_DiscoveryQosPolicy::min_buffer_size
uint32_t min_buffer_size
minimum tx buffer size in bytes for builtin writers
Definition: dds.h:1385
DDS_DomainId_t
DDS_DOMAINID_TYPE_NATIVE DDS_DomainId_t
Definition: dds_types.h:51
CoreDX_DiscoveryQosPolicy::heartbeat_period
DDS_Duration_t heartbeat_period
The heartbeat_period to configure for builtin writers.
Definition: dds.h:1382
DDS_Publisher
The DDS_Publisher configures, creates, manages and destroys DDS_DataWriters.
CoreDX_RTPSReaderQosPolicy::accept_batch_msg
unsigned char accept_batch_msg
Definition: dds.h:1356
CoreDX_Locator
Network address.
Definition: dds.h:1304
DDS_DataWriterQos::representation
DDS_DataRepresentationQosPolicy representation
Informs DataReader(s) of the single data representation supported by this Writer. This must be consis...
Definition: dds.h:1514
DDS_DomainParticipantListener_cd::on_publication_matched
void(* on_publication_matched)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:1038
DDS_UserDataQosPolicy
Allows the application to attach arbitrary information to a DomainParticipant, DataWriter or DataRead...
Definition: dds_builtin.h:71
DDS_ReturnCode_t
int DDS_ReturnCode_t
Definition: dds_types.h:56
DDS_SubscriberListener_cd::on_subscription_matched
void(* on_subscription_matched)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:771
DDS_DataWriter
The DDS_DataWriter entity provides an interface for the application to publish (write) data...
CoreDX_RTPSWriterQosPolicy
QoS Policy for configuring aspects of the RTPS Writer Protocol.
Definition: dds.h:1339
DDS_TypeConsistencyEnforcementQosPolicy
rules for determining type consistency
Definition: dds_builtin.h:1006
DDS_DataReaderQos
Structure that holds DDS_DataReader Quality of Service policies.
Definition: dds.h:1579
DDS_DomainParticipantListener_cd
The DDS_DomainParticipantListener_cd provides asynchronous notification of DDS_DomainParticipant even...
Definition: dds.h:973
DDS_StatusCondition
A DDS_StatusCondition is a condition associated with an Entity.
CoreDX_DiscoveryQosPolicy::discovery_kind
DDS_DiscoveryQosPolicyDiscoveryKind discovery_kind
Type of disocvery to use for this Entity.
Definition: dds.h:1374
DDS_DomainParticipantListener_cd::on_requested_deadline_missed
void(* on_requested_deadline_missed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_RequestedDeadlineMissedStatus status, void *callback_data)
Definition: dds.h:1053
DDS_DomainParticipantQos::entity_factory
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the DomainParticipant create operations.
Definition: dds.h:1433
DDS_SubscriberQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1642
DDS_ReaderDataLifecycleQosPolicy::autopurge_nowriter_samples_delay
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:1244
DDS_TopicDescription
DDS_TopicDescription is an abstract &#39;class&#39; that provides the foundation for DDS_Topic, DDS_ContentFilteredTopic, and DDS_MultiTopic.
DDS_ReliabilityQosPolicy
Indicates the level of reliability offered/provided by the Entity. If kind is RELIABLE_RELIABILITY_QO...
Definition: dds_builtin.h:691
DDS_LivelinessLostStatus
Status related to the on_liveliness_lost listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:285
DDS_DomainParticipantListener_cd::on_data_available
void(* on_data_available)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:1107
DDS_DomainParticipantListener_cd::on_offered_incompatible_qos
void(* on_offered_incompatible_qos)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:1012
CoreDX_DiscoveryQosPolicy
QoS Policy for configuring aspects of the Discovery and Builtin entities.
Definition: dds.h:1373
CoreDX_DiscoveryQosPolicy::dpd_lease_duration
DDS_Duration_t dpd_lease_duration
How long we consider a discoverd Participant to be alive without hearing from them.
Definition: dds.h:1379
DDS_Time_t
Definition: dds_types.h:72
CoreDX_ThreadModelQosPolicy
QoS Policy for configuring the threading behavior of the DomainParticipant.
Definition: dds.h:1400
DDS_DurabilityQosPolicy
The DurabilityQosPolicy controls the durablity of data.
Definition: dds_builtin.h:275
DDS_DataReaderQos::ownership
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; offered by the DataReader.
Definition: dds.h:1590
DDS_SubscriberQos::partition
DDS_PartitionQosPolicy partition
Establishes a logical data partition.
Definition: dds.h:1635
DDS_HistoryQosPolicy
Controls the ammount of historical data maintained by a DataReader or DataWriter. ...
Definition: dds_builtin.h:799
DDS_ContentFilteredTopic
DDS_ContentFilteredTopic provides a topic that may exclude data based on a specified filter...
DDS_DomainParticipantListener_cd::on_liveliness_changed
void(* on_liveliness_changed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:1094
DDS_TopicQos::durability
DDS_DurabilityQosPolicy durability
The durability policy of the Topic.
Definition: dds.h:1462
DDS_LatencyBudgetQosPolicy
Specifies allowable latency.
Definition: dds_builtin.h:406
CoreDX_LoggingQosPolicy
Controls the amount and kind of information that is logged.
Definition: dds.h:1274
DDS_DataWriterQos::deadline
DDS_DeadlineQosPolicy deadline
The deadline committed to by the DataWriter.
Definition: dds.h:1501
DDS_DataReaderListener_cd::on_data_available
void(* on_data_available)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:576
DDS_DataWriterQos::writer_data_lifecycle
DDS_WriterDataLifecycleQosPolicy writer_data_lifecycle
Indicates if unregistered instances should be automatically disposed by the DataWriter.
Definition: dds.h:1513
DDS_DataWriterQos::liveliness
DDS_LivelinessQosPolicy liveliness
The liveliness mechanism offered by the DataWriter.
Definition: dds.h:1503
DDS_SubscriberListener_cd::on_sample_lost
void(* on_sample_lost)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:783
DDS_DataReaderListener_cd::on_sample_lost
void(* on_sample_lost)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SampleLostStatus status, void *callback_data)
Definition: dds.h:593
DDS_TopicQos::representation
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:1474
DDS_OfferedDeadlineMissedStatus
Status related to the on_offered_deadline_missed listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:310
DDS_TopicQos::lifespan
DDS_LifespanQosPolicy lifespan
The &#39;expiration time&#39; for old data samples on the Topic.
Definition: dds.h:1472
DDS_DataReaderQos::durability
DDS_DurabilityQosPolicy durability
The durability policy requested by the DataReader.
Definition: dds.h:1580
CoreDX_DiscoveryQosPolicy::max_buffer_size
uint32_t max_buffer_size
maximum tx buffer size in bytes for builtin writers
Definition: dds.h:1386
DDS_DeadlineQosPolicy
This QoS policy establishes a minimum update period for data instances.
Definition: dds_builtin.h:367
DDS_TopicDataQosPolicy
Allows the application to attach arbitrary information to a Topic QoS.
Definition: dds_builtin.h:109
CoreDX_ParticipantLocator::participant_locator
CoreDX_Locator participant_locator
locator identifying peer participant
Definition: dds.h:1317
DDS_DataWriterQos::durability_service
DDS_DurabilityServiceQosPolicy durability_service
The durability service configuration offered by the DataWriter.
Definition: dds.h:1500
CoreDX_RTPSReaderQosPolicy::precache_max_samples
uint32_t precache_max_samples
Definition: dds.h:1359
DDS_DomainParticipantListener_cd::on_liveliness_lost
void(* on_liveliness_lost)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:1025
DDS_PublisherListener_cd::on_offered_incompatible_qos
void(* on_offered_incompatible_qos)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:427
DDS_DataWriterListener_cd::on_offered_incompatible_qos
void(* on_offered_incompatible_qos)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_OfferedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:314
DDS_DataWriterQos::transport_priority
DDS_TransportPriorityQosPolicy transport_priority
The transport priority supported by the DataWriter.
Definition: dds.h:1508
DDS_WaitSet
A DDS_WaitSet maintains a set of DDS_Condition objects and allows the application to wait until one o...
DDS_DomainParticipantListener_cd::on_subscription_matched
void(* on_subscription_matched)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:1119
DDS_TopicQos::transport_priority
DDS_TransportPriorityQosPolicy transport_priority
The priority to be used for messages on the Topic.
Definition: dds.h:1471
DDS_PublisherQos::entity_factory
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the Publisher_create_datawriter() operation.
Definition: dds.h:1558
DDS_SampleInfo
The SampleInfo structure contains information associated with each sample.
Definition: dds_types.h:159
CoreDX_ThreadModelQosPolicy::create_listener_thread
unsigned char create_listener_thread
Definition: dds.h:1402
CoreDX_RTPSWriterQosPolicy::apply_filters
unsigned char apply_filters
Definition: dds.h:1346
DDS_SubscriptionBuiltinTopicData
DDS_DCPSSubscription DDS_SubscriptionBuiltinTopicData
Definition: dds.h:174
DDS_TopicQos::destination_order
DDS_DestinationOrderQosPolicy destination_order
The ordering of received samples on the Topic will be either by SOURCE or RECEPTION timestamp...
Definition: dds.h:1468
DDS_TimeBasedFilterQosPolicy
Defines a filter based on time between samples. The DataReader indicates that it wants at most one sa...
Definition: dds_builtin.h:581
DDS_TopicQos::liveliness
DDS_LivelinessQosPolicy liveliness
Identifies the mechanism used to detect and maintain livelines of DataWriters on the Topic...
Definition: dds.h:1466
DDS_SubscriberQos::group_data
DDS_GroupDataQosPolicy group_data
A sequence of octets associated with the Publisher.
Definition: dds.h:1640
CoreDX_ParticipantLocator::participant_id_max
uint32_t participant_id_max
participant id max
Definition: dds.h:1316
CoreDX_ThreadModelQosPolicy::use_threads
unsigned char use_threads
should the DomainParticipant use threads for internal work
Definition: dds.h:1401
DDS_ParticipantBuiltinTopicData
DDS_DCPSParticipant DDS_ParticipantBuiltinTopicData
Definition: dds.h:168
CoreDX_PeerParticipantQosPolicy
Configures a list of DomainParticipant peers to attempt communication with.
Definition: dds.h:1326
DDS_DataWriterQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1523
DDS_SubscriberListener_cd::on_sample_rejected
void(* on_sample_rejected)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:736
CoreDX_RTPSWriterQosPolicy::nack_suppress_delay
DDS_Duration_t nack_suppress_delay
ammount of time to ignore NACKs after a repair
Definition: dds.h:1342
DDS_DataWriterQos::durability
DDS_DurabilityQosPolicy durability
The durability policy offered by the DataWriter.
Definition: dds.h:1499
DDS_PublisherListener_cd::on_publication_matched
void(* on_publication_matched)(struct DDS_PublisherListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:451
DDS_TopicQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity_name
Definition: dds.h:1478
DDS_SubscriberQos::presentation
DDS_PresentationQosPolicy presentation
Controls the presentation of groups of changes.
Definition: dds.h:1628
DDS_GUID_t
Definition: dds_builtin_basic.h:91
DDS_TopicQos::ownership
DDS_OwnershipQosPolicy ownership
The type of &#39;ownership&#39; expected for data instances on the Topic.
Definition: dds.h:1473
DDS_DataReaderListener
The DDS_DataReaderListener provides asynchronous notification of DDS_DataReader events.
Definition: dds.h:468
DDS_WriterDataLifecycleQosPolicy::autodispose_unregistered_instances
unsigned char autodispose_unregistered_instances
should the writer dispose instances that are unregistered
Definition: dds.h:1233
CoreDX_DiscoveryQosPolicy::send_initial_nack
unsigned char send_initial_nack
send a ACKNACK immediately after matching with new Writer.
Definition: dds.h:1390
CoreDX_DiscoveryQosPolicy::send_msglen_submsg
unsigned char send_msglen_submsg
include &#39;msglen&#39; submessage in RTPS header
Definition: dds.h:1393
CoreDX_RTPSWriterQosPolicy::ack_deadline
DDS_Duration_t ack_deadline
Definition: dds.h:1343
DDS_SubscriberListener_cd::on_data_on_readers
void(* on_data_on_readers)(struct DDS_SubscriberListener_cd *self, DDS_Subscriber the_subscriber, void *callback_data)
Definition: dds.h:793
DDS_PublisherQos::group_data
DDS_GroupDataQosPolicy group_data
A sequence of octets associated with the Publisher.
Definition: dds.h:1557
DDS_DataReaderQos::user_data
DDS_UserDataQosPolicy user_data
A sequence of octets associated with the DataReader.
Definition: dds.h:1589
DDS_TopicQos::reliability
DDS_ReliabilityQosPolicy reliability
Indicates the level of transport reliability on the Topic.
Definition: dds.h:1467
DDS_ResourceLimitsQosPolicy
Specifies the resources that the Service can use to maintain data samples and instances.
Definition: dds_builtin.h:834
DDS_DCPSParticipant
Definition: dds_builtin.h:1206
DDS_DataReaderQos::representation
DDS_DataRepresentationQosPolicy representation
Informs DataWriter(s) of the data representation(s) supported by this Reader. This must be consistent...
Definition: dds.h:1594
DDS_DataWriterQos
Structure that holds DDS_DataWriter Quality of Service policies.
Definition: dds.h:1498
DDS_TopicListener
The DDS_TopicListener provides asynchronous notification of DDS_Topic events.
Definition: dds.h:204
DDS_SubscriberListener_cd::on_data_available
void(* on_data_available)(struct DDS_SubscriberListener_cd *self, DDS_DataReader the_reader, void *callback_data)
Definition: dds.h:760
DDS_DataWriterListener
The DDS_DataWriterListener provides asynchronous notification of DDS_DataWriter events.
Definition: dds.h:250
DDS_DomainParticipantListener_cd::on_requested_incompatible_qos
void(* on_requested_incompatible_qos)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_RequestedIncompatibleQosStatus status, void *callback_data)
Definition: dds.h:1067
DDS_DataReaderQos::resource_limits
DDS_ResourceLimitsQosPolicy resource_limits
The resource limits set on the DataReader.
Definition: dds.h:1587
DDS_DataReaderQos::reader_data_lifecycle
DDS_ReaderDataLifecycleQosPolicy reader_data_lifecycle
Controls the auto-purge behavior of the DataReader.
Definition: dds.h:1592
DDS_DataWriterQos::history
DDS_HistoryQosPolicy history
The data history maintained by the DataWriter.
Definition: dds.h:1506
DDS_DomainParticipantQos::thread_model
CoreDX_ThreadModelQosPolicy thread_model
Configure DomainParticipant thread usage.
Definition: dds.h:1439
DDS_DataReaderListener_cd::on_liveliness_changed
void(* on_liveliness_changed)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_LivelinessChangedStatus status, void *callback_data)
Definition: dds.h:567
DDS_DataWriterQos::latency_budget
DDS_LatencyBudgetQosPolicy latency_budget
The latency allowed by the DataWriter.
Definition: dds.h:1502
DDS_DomainParticipantQos::properties
DDS_PropertyQosPolicy properties
Additional name:value pair properties (if propagate=true, included in discovery)
Definition: dds.h:1440
DDS_LifespanQosPolicy
Specifies the maximum duration of validity of the data written by the DataWriter. ...
Definition: dds_builtin.h:209
DDS_DestinationOrderQosPolicy
This QoS policy controls how each Subscriber orders received data samples.
Definition: dds_builtin.h:739
DDS_PublisherListener_cd
The DDS_PublisherListener_cd provides asynchronous notification of DDS_Publisher events with addition...
Definition: dds.h:404
DDS_SubscriberListener_cd
The DDS_SubscriberListener_cd provides asynchronous notification of DDS_Subscriber events with additi...
Definition: dds.h:701
DECLARE_SEQ
DECLARE_SEQ(DDS_DynamicTypeMember, DDS_DynamicTypeMemberSeq)
A DDS_DynamicTypeMemberSeq instance is a sequence of DDS_DynamicTypeMember&#39;s.
DDS_PublicationBuiltinTopicData
DDS_DCPSPublication DDS_PublicationBuiltinTopicData
Definition: dds.h:172
CoreDX_LoggingQosPolicy::flags
uint32_t flags
flags to control logging output
Definition: dds.h:1275
DDS_SubscriberQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1643
DDS_RequestedDeadlineMissedStatus
Status related to the on_requested_deadline_missed listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:321
DDS_Topic
DDS_Topic is the basic description of data to be published or subscribed.
DDS_DataWriterQos::destination_order
DDS_DestinationOrderQosPolicy destination_order
The destination order logic offered by the DataWriter.
Definition: dds.h:1505
DDS_PublisherQos
Structure that holds DDS_Publisher Quality of Service policies.
Definition: dds.h:1543
DDS_Subscriber
The DDS_Subscriber configures, creates, manages and destroys DDS_DataReaders.
CoreDX_PeerParticipantQosPolicy::strict_match
unsigned char strict_match
Definition: dds.h:1328
DDS_DomainParticipantListener_cd::on_sample_rejected
void(* on_sample_rejected)(struct DDS_DomainParticipantListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:1080
CoreDX_RTPSWriterQosPolicy::heartbeat_period
DDS_Duration_t heartbeat_period
period to transmit heartbeat messages if required
Definition: dds.h:1340
DDS_DomainParticipantListener_cd::on_offered_deadline_missed
void(* on_offered_deadline_missed)(struct DDS_DomainParticipantListener_cd *self, DDS_DataWriter writer, DDS_OfferedDeadlineMissedStatus status, void *callback_data)
Definition: dds.h:998
DDS_PublisherQos::entity_name
CoreDX_EntityNameQosPolicy entity_name
entity name
Definition: dds.h:1559
DDS_DataReaderQos::latency_budget
DDS_LatencyBudgetQosPolicy latency_budget
The latency requested by the DataReader.
Definition: dds.h:1582
DDS_PublicationMatchedStatus
Status related to the on_publication_matched listener methods of the DDS_DataWriter, DDS_Publisher, and DDS_DomainParticipant structures.
Definition: dds_types.h:370
DDS_OwnershipStrengthQosPolicy
Defines the strength, or priority, of a Writer. The strength is used to determine ownership in the ca...
Definition: dds_builtin.h:479
DDS_DataReaderListener_cd
The DDS_DataReaderListener_cd provides asynchronous notification of DDS_DataReader events with additi...
Definition: dds.h:531
DDS_DiscoveryQosPolicyDiscoveryKind
DDS_DiscoveryQosPolicyDiscoveryKind
This enumeration contains the kinds of Discovery.
Definition: dds.h:1366
DDS_DataWriterListener_cd::on_publication_matched
void(* on_publication_matched)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_PublicationMatchedStatus status, void *callback_data)
Definition: dds.h:333
CoreDX_DiscoveryQosPolicy::dpd_push_period
DDS_Duration_t dpd_push_period
Multicast DiscoveredParticipantData each period.
Definition: dds.h:1378
DDS_StatusMask
unsigned int DDS_StatusMask
Definition: dds_types.h:134
DDS_DataReaderQos::time_based_filter
DDS_TimeBasedFilterQosPolicy time_based_filter
The maximum update frequency required/desired by the DataReader.
Definition: dds.h:1591
DDS_DataWriterQos::rpc
DDS_RpcQosPolicy rpc
Configure RPC relevant settings: instance_name, related_entity, and topic_aliases.
Definition: dds.h:1519
DDS_DataWriterQos::user_data
DDS_UserDataQosPolicy user_data
A sequence of octets associated with the DataWriter.
Definition: dds.h:1510
CoreDX_Locator::kind
int kind
Definition: dds.h:1305
DDS_InstanceHandle_t
DDS_HANDLE_TYPE_NATIVE DDS_InstanceHandle_t
Definition: dds_types.h:53
CoreDX_RTPSReaderQosPolicy
QoS Policy for configuring aspects of the RTPS Reader Protocol.
Definition: dds.h:1354
DDS_SubscriberQos::entity_factory
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the Subsriber_create_datareader() operation.
Definition: dds.h:1641
DDS_TopicBuiltinTopicData
struct DDS_DCPSTopic DDS_TopicBuiltinTopicData
Definition: dds.h:170
CoreDX_RTPSReaderQosPolicy::send_initial_nack
unsigned char send_initial_nack
Definition: dds.h:1358
DDS_Duration_t
The Duration_t structure contains data to define a time duration.
Definition: dds_builtin.h:33
DDS_DataReaderQos::liveliness
DDS_LivelinessQosPolicy liveliness
The liveliness mechanism requested by the DataReader.
Definition: dds.h:1583
DDS_TopicListener_cd
The DDS_TopicListener_cd provides asynchronous notification of DDS_Topic events with additional callb...
Definition: dds.h:222
DDS_SubscriptionMatchedStatus
Status related to the on_subscription_matched listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:384
DDS_DomainParticipantFactoryQos
Structure that holds DDS_DomainParticipantFactory Quality of Service policies.
Definition: dds.h:1412
DDS_DataWriterListener_cd
The DDS_DataWriterListener_cd provides asynchronous notification of DDS_DataWriter events with additi...
Definition: dds.h:295
DDS_LivelinessQosPolicy
Determines the mechanism and parameters used by the application to determine whether an Entity is ali...
Definition: dds_builtin.h:545
DDS_DataRepresentationQosPolicy
Describes the data representation used by a topic.
Definition: dds_builtin.h:964
DDS_GroupDataQosPolicy
Allows the application to attach arbitrary information to a Publisher or Subscriber.
Definition: dds_builtin.h:148
DDS_DomainParticipantQos::user_data
DDS_UserDataQosPolicy user_data
A sequence of octets associated with a DomainParticipant.
Definition: dds.h:1432
CoreDX_RTPSWriterQosPolicy::nack_response_delay
DDS_Duration_t nack_response_delay
ammount of time allowed for responding to NACKs
Definition: dds.h:1341
DDS_RequestedIncompatibleQosStatus
Status related to the on_requested_incompatible_qos listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:357
DDS_TopicQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1479
DDS_TopicQos::deadline
DDS_DeadlineQosPolicy deadline
Defines the expected update frequency for data instances within the Topic.
Definition: dds.h:1464
DDS_PEER_DISCOVERY_QOS
Definition: dds.h:1367
DDS_CENTRAL_DISCOVERY_QOS
Definition: dds.h:1368
DDS_SubscriberListener
The DDS_SubscriberListener provides asynchronous notification of DDS_Subscriber events.
Definition: dds.h:610
CoreDX_RTPSReaderQosPolicy::heartbeat_response_delay
DDS_Duration_t heartbeat_response_delay
ammount of time allowed for responding to a heartbeat
Definition: dds.h:1355
DDS_DataReaderListener_cd::on_subscription_matched
void(* on_subscription_matched)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SubscriptionMatchedStatus status, void *callback_data)
Definition: dds.h:584
DDS_TopicListener::on_inconsistent_topic
void(* on_inconsistent_topic)(DDS_Topic the_topic, DDS_InconsistentTopicStatus status)
Definition: dds.h:211
DDS_DataReaderListener_cd::on_sample_rejected
void(* on_sample_rejected)(struct DDS_DataReaderListener_cd *self, DDS_DataReader the_reader, DDS_SampleRejectedStatus status, void *callback_data)
Definition: dds.h:558
DDS_DomainParticipantQos::discovery
CoreDX_DiscoveryQosPolicy discovery
Override QoS values for builtin discovery entities.
Definition: dds.h:1438
DDS_DCPSSubscription
Definition: dds_builtin.h:1311
DDS_DomainParticipantFactoryQos::entity_factory
DDS_EntityFactoryQosPolicy entity_factory
Controls the behavior of the DomainParticipant create operations.
Definition: dds.h:1413
DDS_DataWriterQos::rtps_writer
CoreDX_RTPSWriterQosPolicy rtps_writer
rtps_writer configuration
Definition: dds.h:1524
CoreDX_RTPSWriterQosPolicy::enable_batch_msg
unsigned char enable_batch_msg
Definition: dds.h:1347
DDS_SampleLostStatus
Status related to the on_sample_lost listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:253
DDS_TopicQos::history
DDS_HistoryQosPolicy history
The amount of historical data maintained for the Topic.
Definition: dds.h:1469
DDS_DataWriterQos::lifespan
DDS_LifespanQosPolicy lifespan
The expiration time for old samples managed by the DataWriter.
Definition: dds.h:1509
DDS_DCPSPublication
Definition: dds_builtin.h:1240
CoreDX_ParticipantLocator
Describes a the location and identity of a potential peer DomainParticipant.
Definition: dds.h:1314
DDS_DataWriterQos::reliability
DDS_ReliabilityQosPolicy reliability
The transport reliability offered by the DataWriter.
Definition: dds.h:1504
DDS_EntityFactoryQosPolicy::autoenable_created_entities
unsigned char autoenable_created_entities
should created entities be automatically enabled
Definition: dds.h:1220
DDS_DomainParticipantQos
Structure that holds DDS_DomainParticipant Quality of Service policies.
Definition: dds.h:1431
DDS_DomainParticipantQos::logging
CoreDX_LoggingQosPolicy logging
logging
Definition: dds.h:1435
DDS_TopicQos::resource_limits
DDS_ResourceLimitsQosPolicy resource_limits
The resource limitations for the Topic.
Definition: dds.h:1470
DDS_DurabilityServiceQosPolicy
Definition: dds_builtin.h:892
DDS_TransportPriorityQosPolicy
A hint to the middleware to help configure the transport priority mechanism.
Definition: dds_builtin.h:177
DDS_TopicQos::topic_data
DDS_TopicDataQosPolicy topic_data
A sequence of octets associated with a Topic.
Definition: dds.h:1461
DDS_DataWriterListener_cd::on_liveliness_lost
void(* on_liveliness_lost)(struct DDS_DataWriterListener_cd *self, DDS_DataWriter writer, DDS_LivelinessLostStatus status, void *callback_data)
Definition: dds.h:323
DDS_SampleRejectedStatus
Status related to the on_sample_rejected listener methods of the DDS_DataReader, DDS_Subscriber, and DDS_DomainParticipant structures.
Definition: dds_types.h:272
CoreDX_DiscoveryQosPolicy::heartbeat_response_delay
DDS_Duration_t heartbeat_response_delay
The heartbeat_response_delay to configure for builtin readers.
Definition: dds.h:1389
DDS_DomainParticipantListener_cd::on_data_on_readers
void(* on_data_on_readers)(struct DDS_DomainParticipantListener_cd *self, DDS_Subscriber the_subscriber, void *callback_data)
Definition: dds.h:1145
DDS_OwnershipQosPolicy
Determines instance ownership in the case of multple writers. CoreDX DDS supports both SHARED_OWNERSH...
Definition: dds_builtin.h:446
DDS_DomainParticipantListener
The DDS_DomainParticipantListener provides asynchronous notification of DDS_DomainParticipant events...
Definition: dds.h:811
DDS_DataReaderQos::destination_order
DDS_DestinationOrderQosPolicy destination_order
The destination order logic requested by the DataReader.
Definition: dds.h:1585
© 2009-2017 Twin Oaks Computing, Inc
Castle Rock, CO 80108
All rights reserved.