RTI Connext DDS Micro  Version 2.4.10
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dds_c_infrastructure.h
Go to the documentation of this file.
1 /*
2  * FILE: dds_c_infrastructure.h - DDS infrastructure module definitions
3  *
4  * (c) Copyright, Real-Time Innovations, 2012-2016.
5  *
6  * All rights reserved.
7  *
8  * No duplications, whole or partial, manual or electronic, may be made
9  * without express written permission. Any such copies, or
10  * revisions thereof, must display this notice unaltered.
11  * This code contains trade secrets of Real-Time Innovations, Inc.
12  *
13  * Modification History
14  * --------------------
15  * 07apr2016,tk MICRO-1541 Fixed assignment operator issues for C++
16  * 10feb2016,tk MICRO-1525 Added assignment operator to DDS_EntityNameQosPolicy
17  * 04nov2015,tk MICRO-1505 - Reduce memory footprint
18  * 15jul2015,tk MICRO-1426/PR#15358 Added Added DDS_Duration_delta_gt
19  * 30jun2015,tk MICRO-1323/PR#15020 Refactored definition of DDS_DURATION_INFINITE
20  * 19may2015,as MICRO-1193 Refactoring of Sequence API levels
21  * 02apr2014,eh MICRO-964/PR#12378 Remove from Cert unused locator defines
22  * 16mar2015,tk MICRO-1129/PR#14274 Increased size of entity_name to
23  * DDS_ENTITYNAME_QOS_NAME_MAX + 1
24  * 25feb2015,eh MICRO-1040/PR#13555 Remove unused DDS_Guid_equals/copy/compare
25  * 09feb2015,tk MICRO-1061/PR#13633 DDS_AUTOMATIC_LIVELINESS_QOS is now default
26  * 08oct2014,tk MICRO-919 Added SampleLostReason to SampleLost status
27  * MICRO-918 Removed TimeBasedFilter qos policy (unsupported)
28  * 20sep2014,as Make support functions for QosPolicy types private; remove macros DDSC_CPP_VALUE_TYPE_SUPPORT_FUNCTIONS
29  * and DDSC_CPP_SUPPORT_TYPE_SUPPORT_FUNCTIONS; update DDSC_CPP_VALUE_TYPE_SUPPORT_METHODS and
30  * DDSC_CPP_STATUS_TYPE_SUPPORT_METHODS to only define method signatures (no inline implementation)
31  * 04aug2014,tk MICRO-846/PR#10203 - Limit exposure of PropertySeq API
32  * MICRO-848/PR#10206 - Limit exposure of PropertySeq API
33  * 29jul2014,tk MICRO-864/PR#10245 Fixed C++ DDS_DataReaderResourceLimitsQosPolicy
34  * 19jul2013,as Added support for C++
35  * 06feb2013,eh MICRO-262: add max_remote_readers
36  * 29jun2012,tk Written
37  */
38 /*ce
39  * \file
40  * \brief DDS Domain Module definitions
41  */
42 /*e @addtogroup DDSInfrastructureModule Infrastructure Module
43  @ingroup DDSCModule
44 
45  @brief Defines the \dds infrastructure package
46 */
47 #ifndef dds_c_infrastructure_h
48 #define dds_c_infrastructure_h
49 
50 #ifndef dds_c_dll_h
51 #include "dds_c/dds_c_dll.h"
52 #endif
53 #ifndef osapi_thread_h
54 #include "osapi/osapi_thread.h"
55 #endif
56 #ifndef netio_rtps_h
57 #include "netio/netio_rtps.h"
58 #endif
59 #ifndef rtps_rtps_h
60 #include "rtps/rtps_rtps.h"
61 #endif
62 #ifndef dds_c_common_h
63 #include "dds_c/dds_c_common.h"
64 #endif
65 #ifndef dds_c_string_h
66 #include "dds_c/dds_c_string.h"
67 #endif
68 #ifndef dds_c_sequence_h
69 #include "dds_c/dds_c_sequence.h"
70 #endif
71 
72 #ifdef __cplusplus
73 extern "C"
74 {
75 #endif
76 
77 #ifndef NULL
78 #define NULL 0
79 #endif
80 
81 /* ================================================================= */
82 /* Micro DDS */
83 /* ================================================================= */
84 #define RTI_MICRODDS
85 #define RTI_MICRODDS_MAJOR 2
86 #define RTI_MICRODDS_MINOR 0
87 
88 /* ================================================================= */
89 /* CPP VALUE-TYPE SUPPORT */
90 /* ================================================================= */
91 
92 #ifdef RTI_CERT
93 #define DDSC_CPP_CERT_PRIVATE_OPERATORS(T) \
94  private:\
95  T(const T& from);\
96  T& operator=(const T& from);\
97  bool operator==(const T& other);\
98  bool operator!=(const T& other);
99 
100 #define DDSC_CPP_QOS_OPERATORS(T) \
101  DDSC_CPP_CERT_PRIVATE_OPERATORS(T)
102 
103 #define DDSC_CPP_QOS_POLICY_OPERATORS(T) \
104  DDSC_CPP_CERT_PRIVATE_OPERATORS(T)
105 
106 #define DDSC_CPP_STATUS_OPERATORS(T) \
107  DDSC_CPP_CERT_PRIVATE_OPERATORS(T)
108 #else
109 #define DDSC_CPP_QOS_OPERATORS(T) \
110  public:\
111  bool operator==(const T& other);\
112  bool operator!=(const T& other);
113 
114 #define DDSC_CPP_QOS_POLICY_OPERATORS(T)
115 
116 #define DDSC_CPP_STATUS_OPERATORS(T)
117 #endif
118 
119 #ifdef RTI_CPP
120 #define DDSC_CPP_QOS_METHODS(T) \
121  public:\
122  T(); \
123  DDS_ReturnCode_t copy(const T& from); \
124  DDSC_CPP_QOS_OPERATORS(T)
125 
126 #define DDSC_CPP_QOS_POLICY_METHODS(T) \
127 
128 #define DDSC_CPP_STATUS_METHODS(T)
129 
130 #else
131 #define DDSC_CPP_QOS_METHODS(T)
132 #define DDSC_CPP_QOS_POLICY_METHODS(T)
133 #define DDSC_CPP_STATUS_METHODS(T)
134 #endif
135 
136 #define DDSC_QOS_POLICY_METHODS_DECL(T)
137 
138 #if 0
139 DDSCDllExport void T##_initialize(struct T *policy);
140 #endif
141 /* ================================================================= */
142 /* Time Support */
143 /* ================================================================= */
144 
145 /*e
146  * \dref_TimeSupportGroupDocs
147  */
148 
149 /*e
150  * \dref_Time_t
151  */
152 struct DDSCPPDllExport DDS_Time_t
153 {
154  /*e
155  * \dref_TimeStamp_sec
156  */
157  DDS_Long sec;
158 
159  /*e
160  * \dref_TimeStamp_nanosec
161  */
162  DDS_UnsignedLong nanosec;
163 
164  DDSC_CPP_QOS_POLICY_METHODS(DDS_Time_t)
165 
166 #ifdef RTI_CPP
167 public:
168  bool greater_than(const DDS_Time_t& other);
169  bool is_zero();
170 #endif
171 
172 };
173 
174 /* This is only used by tests, keep as macro */
175 #define DDS_Time_t_greater_than(l, r) \
176  (((l).sec > (r).sec) || \
177  (((l).sec == (r).sec) && \
178  ((l).nanosec > (r).nanosec)))
179 
180 #ifdef DOXYGEN_DOCUMENTATION_ONLY
181 /*e
182  * \dref_Time_t_greater_than
183  */
184 DDS_Boolean DDS_Time_greater_than(
185  const struct DDS_Time_t *l, const struct DDS_Time_t *r);
186 
187 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
188 
189 /*e
190  * \dref_Time_t_ZERO
191  */
192 #define DDS_TIME_ZERO { 0L, 0UL }
193 
194 /* This is only used by tests, keep as macro */
195 #define DDS_Time_is_zero(timePtr) \
196  ((timePtr)->sec == 0L || (timePtr)->nanosec == 0UL)
197 
198 #ifdef DOXYGEN_DOCUMENTATION_ONLY
199 
200 /*e
201  * \dref_Time_t_is_zero
202  */
203  DDS_Boolean DDS_Time_is_zero(const struct DDS_Time_t *time);
204 
205 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
206 
207 /*e
208  * \dref_Time_t_INVALID_SEC
209  */
210 extern DDSCDllVariable const DDS_Long DDS_TIME_INVALID_SEC;
211 
212 /*e
213  * \dref_Time_t_INVALID_NSEC
214  */
215 extern DDSCDllVariable const DDS_UnsignedLong DDS_TIME_INVALID_NSEC;
216 
217 /*e
218  * \dref_Time_t_INVALID
219  */
220 extern DDSCDllVariable const struct DDS_Time_t DDS_TIME_INVALID;
221 
222 /* ================================================================= */
223 /* Duration */
224 /* ================================================================= */
225 
226 /*i \brief Internal constant for infinite seconds
227  */
228 #define DDS_DURATION_INFINITE_SEC_INITIALIZER 0x7fffffff
229 
230 /*i \brief Internal constant for infinite nanoseconds
231  */
232 #define DDS_DURATION_INFINITE_NSEC_INITIALIZER 0xffffffffUL
233 
234 /*e \dref_Duration_t
235  */
236 struct DDSCPPDllExport DDS_Duration_t
237 {
238  /*e \dref_TimeStamp_sec
239  */
240  DDS_Long sec;
241 
242  /*e \dref_TimeStamp_nanosec
243  */
244  DDS_UnsignedLong nanosec;
245 
246  DDSC_CPP_QOS_POLICY_METHODS(DDS_Duration_t)
247 
248 #ifdef RTI_CPP
249 public:
250  DDS_Boolean is_infinite();
251  int compare(const DDS_Duration_t *other);
252  void to_ntp_time(OSAPI_NtpTime *dst);
253  void from_ntp_time(const OSAPI_NtpTime *src);
254  DDS_Boolean equal(const DDS_Duration_t *other);
255  DDS_Boolean is_zero();
256 #endif
257 };
258 
259 /*i \brief A infinite duration initializer
260  */
261 #define DDS_DURATION_INFINITE_INITIALIZER \
262 { \
263  DDS_DURATION_INFINITE_SEC_INITIALIZER, \
264  DDS_DURATION_INFINITE_NSEC_INITIALIZER \
265 }
266 
267 /*e \dref_Duration_t_INFINITE_SEC
268  */
269 extern DDSCDllVariable const DDS_Long DDS_DURATION_INFINITE_SEC;
270 
271 /*e \dref_Duration_t_INFINITE_NSEC
272  */
273 extern DDSCDllVariable const DDS_UnsignedLong DDS_DURATION_INFINITE_NSEC;
274 
275 /*e \dref_Duration_t_INFINITE
276  */
277 extern DDSCDllVariable const struct DDS_Duration_t DDS_DURATION_INFINITE;
278 
279 /*ci \brief Approximate duration of a year.
280  *
281  * \details
282  * This value is an the number of seconds in a nominal non-leap
283  * year with 365 days, each day has 24 hours, and each day has 3600 seconds.
284  * It is only used as a chosen upper limit for certain Qos policies.
285  * Specifically, this value does not represent the exact number of seconds
286  * in any specific year.
287  */
288 extern DDSCDllVariable const struct DDS_Duration_t DDS_DURATION_YEAR;
289 
290 /*ci \brief 1 nanosecond represented as a duration structure
291  */
292 extern DDSCDllVariable const struct DDS_Duration_t DDS_DURATION_NANOSEC;
293 
294 /*e \dref_Duration_t_is_infinite
295  */
296 DDSCDllExport DDS_Boolean
297 DDS_Duration_is_infinite(const struct DDS_Duration_t *duration);
298 
299 /*ce \dref_Duration_t_compare
300  */
301 DDSCDllExport int
302 DDS_Duration_compare(const struct DDS_Duration_t *left,
303  const struct DDS_Duration_t *right);
304 
305 /*ce \dref_Duration_t_to_ntp_time
306  */
307 DDSCDllExport void
308 DDS_Duration_to_ntp_time(const struct DDS_Duration_t *self,
309  struct OSAPI_NtpTime *dst);
310 
311 /*ce \dref_Duration_t_from_ntp_time
312  */
313 DDSCDllExport void
314 DDS_Duration_from_ntp_time(struct DDS_Duration_t *self,
315  const struct OSAPI_NtpTime *src);
316 
317 /*e
318  * \dref_Duration_t_equal
319  */
320 DDSCDllExport DDS_Boolean
321 DDS_Duration_equal(const struct DDS_Duration_t *self,
322  const struct DDS_Duration_t *other);
323 /*i
324  *\brief Set a duration structure's seconds and nanoseconds
325  *
326  * \param[inout] self The duration structure
327  * \param[in] sec The seconds part
328  * \param[in] nanosec The nanoseconds part
329  */
330 DDSCDllExport void
331 DDS_Duration_set(struct DDS_Duration_t *self,
332  DDS_Long sec,DDS_UnsignedLong nanosec);
333 
334 /*e \dref_Duration_t_ZERO_SEC
335  */
336 extern DDSCDllVariable const DDS_Long DDS_DURATION_ZERO_SEC;
337 
338 /*e \dref_Duration_t_ZERO_NSEC
339  */
340 extern DDSCDllVariable const DDS_UnsignedLong DDS_DURATION_ZERO_NSEC;
341 
342 /*e \dref_Duration_t_ZERO
343  */
344 extern DDSCDllVariable const struct DDS_Duration_t DDS_DURATION_ZERO;
345 
346 /*e \dref_Duration_t_is_zero
347  */
348 DDSCDllExport DDS_Boolean
349 DDS_Duration_is_zero(const struct DDS_Duration_t *duration);
350 
351 /*ci \brief Check if the delta between two durations exceed the specified limit
352  *
353  * \details
354  * This function checks if the time between two durations exceed the
355  * specified delta. Note that the concept of time is not
356  * relevant. The function only checks if (end - begin) > delta.
357  *
358  * This function does not perform any robustness checks and assumes that
359  * end >= begin.
360  *
361  * NOTE: This function assumes the delta is normalized as defined by
362  * \ref DDS_Duration_is_normalized.
363  *
364  * \param[in] delta The maximum allowed delta between the two durations
365  * \param[in] end The duration to be subtracted from
366  * \param[in] begin The duration to subtract
367  *
368  * \return RTI_TRUE if (end - begin) > delta, RTI_FALSE otherwise
369  */
370 DDSCDllExport DDS_Boolean
371 DDS_Duration_delta_gt(const struct DDS_Duration_t *const delta,
372  const struct DDS_Duration_t *const end,
373  const struct DDS_Duration_t *const begin);
374 
375 
376 /*ci
377  * \brief Check that a duration is normalized
378  *
379  * \details
380  * A normalized duration is defined as an INFINITE duration, or a duration
381  * were sec >= 0 and nanosec < 1000000000
382  *
383  * \param[in] self Duration to verify
384  *
385  * \return RTI_TRUE if the duration is normalized, RTI_FALSE if not
386  */
387 DDSCDllExport RTI_BOOL
388 DDS_Duration_is_normalized(const struct DDS_Duration_t *const self);
389 
390 /* ================================================================= */
391 /* Instance Handle */
392 /* ================================================================= */
393 
394 /*e \dref_InstanceHandle_t
395  */
396 typedef DDS_HANDLE_TYPE_NATIVE DDS_InstanceHandle_t;
397 
398 #define T DDS_InstanceHandle_t
399 #define TSeq DDS_InstanceHandleSeq
400 #include <reda/reda_sequence_decl.h>
401 
402 #ifdef DOXYGEN_DOCUMENTATION_ONLY
403 /*i \dref_InstanceHandleSeq
404  */
405 struct DDS_InstanceHandleSeq {};
406 #endif
407 
408 /*e \dref_InstanceHandle_t_NIL
409 */
410 extern DDSCDllVariable const DDS_InstanceHandle_t DDS_HANDLE_NIL;
411 
412 /*ce
413  * \brief Check two DDS_InstanceHandle_t structures for equality
414  *
415  * \param[in] self Left side of comparison
416  * \param[in] other Right side of comparison
417  *
418  * \return DDS_BOOLEAN_TRUE if the two structures are equal,
419  * DDS_BOOLEAN_FALSE otherwise
420  */
421 DDSCDllExport DDS_Boolean
422 DDS_InstanceHandle_equals(const DDS_InstanceHandle_t *self,
423  const DDS_InstanceHandle_t *other);
424 
425 #define DDS_InstanceHandle_is_nil(handlePtr) \
426  DDS_InstanceHandle_equals(handlePtr, &DDS_HANDLE_NIL)
427 
428 #ifdef DOXYGEN_DOCUMENTATION_ONLY
429 /*e \dref_InstanceHandle_t_is_nil
430  */
431 DDS_Boolean DDS_InstanceHandle_is_nil(const DDS_InstanceHandle_t * self);
432 #endif
433 
434 /*ci
435  * \brief Convert to a DDS_InstanceHandle_t from a RTPS_Guid
436  *
437  * \details
438  * Convert a host endian RTPS_Guid to a big-endian DDS_InstanceHandle_t.
439  *
440  * \param[out] self DDS_InstanceHandle_t to convert to
441  * \param[in] other Converted RTPS_Guid
442  *
443  * \sa \ref DDS_InstanceHandle_to_rtps
444  */
445 DDSCDllExport void
446 DDS_InstanceHandle_from_rtps(DDS_InstanceHandle_t *self,
447  const struct RTPS_Guid *other);
448 
449 /*ci
450  * \brief Convert from a DDS_InstanceHandle_t to a RTPS_Guid
451  *
452  * \details
453  * Convert a big-endian DDS_InstanceHandle_t to a host endian RTPS_Guid.
454  *
455  * \param[out] other RTPS_Guid to convert to
456  * \param[in] self Converted DDS_InstanceHandle_t
457  *
458  * \sa \ref DDS_InstanceHandle_from_rtps
459  */
460 DDSCDllExport void
461 DDS_InstanceHandle_to_rtps(struct RTPS_Guid *other,
462  const DDS_InstanceHandle_t *self);
463 
464 /*ci
465  * \brief Convert from an NETIO_Address to a DDS DDS_InstanceHandle_t
466  *
467  * \details
468  * Convert to a big-endian DDS_InstanceHandle_t from a host-endian
469  * NETIO_Address.
470  *
471  * \param[out] self DDS_InstanceHandle_t to convert to
472  * \param[in] other Converted NETIO_Address
473  *
474  * \sa \ref DDS_InstanceHandle_from_rtps
475  */
476 DDSCDllExport void
477 DDS_InstanceHandle_from_netio_address(DDS_InstanceHandle_t *self,
478  const struct NETIO_Address *other);
479 
480 /*ci
481  * \brief Compare two DDS_InstanceHandle_t structures for ordering
482  *
483  * \param[in] self Left side of comparison
484  * \param[in] other Right side of comparison
485  *
486  * \return positive integer if self is greater than other,
487  * negative integer if self is less than other
488  * zero if left is self to other
489  */
490 DDSCDllExport DDS_Long
491 DDS_InstanceHandle_compare(const DDS_InstanceHandle_t *self,
492  const DDS_InstanceHandle_t *other);
493 
494 /* ================================================================= */
495 /* GUID */
496 /* ================================================================= */
497 
498 /*e
499  * \dref_GUIDSupportGroupDocs
500  */
501 
502 /*e \dref_GUID_t
503  */
504 struct DDS_GUID_t
505 {
506  /*e \dref_GUID_t_value
507  */
508  DDS_Octet value[16];
509 };
510 
511 /*i \dref_GUID_t_INITIALIZER
512  */
513 #define DDS_GUID_INITIALIZER {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}
514 
515 /*i \dref_GUID_t_AUTO
516 */
517 extern DDSCDllVariable const struct DDS_GUID_t DDS_GUID_AUTO;
518 
519 /*e \dref_GUID_t_UNKNOWN
520 */
521 extern DDSCDllVariable const struct DDS_GUID_t DDS_GUID_UNKNOWN;
522 
523 /*i \dref_GUID_t_PREFIX_UNKNOWN
524 */
525 extern DDSCDllVariable const struct DDS_GUID_t DDS_GUID_PREFIX_UNKNOWN;
526 
527 /*i \dref_GUID_t_PREFIX_UNKNOWN
528  */
529 extern DDSCDllVariable const struct DDS_GUID_t DDS_GUID_PREFIX_AUTO;
530 
531 /*i \dref_GUID_t_to_rtps
532  * \brief Convert from a DDS_GUID_t to a RTPS_Guid
533  *
534  * \details
535  * This function converts a DDS_GUID_t type in big-endian order to a
536  * RTPS_Guid on host order.
537  *
538  * \param[out] other Output value
539  * \param[in] self Value to convert from
540  */
541 DDSCDllExport void
542 DDS_GUID_to_rtps(struct RTPS_Guid *other,
543  const struct DDS_GUID_t *self);
544 
545 /*i \dref_GUID_t_from_rtps
546  * \brief Convert from a RTPS GUID to a DDS_GUID_t
547  *
548  * \details
549  * This function converts from a RTPS_Guid in host order to a DDS_GUID_t in
550  * big-endian order.
551  *
552  * \param[out] self Output value
553  * \param[in] other Value to convert from
554  */
555 DDSCDllExport void
556 DDS_GUID_from_rtps(struct DDS_GUID_t *self,
557  const struct RTPS_Guid *other);
558 
559 /*i \dref_GUID_t_set_suffix
560  *
561  * \brief Set the suffix, the last 4 bytes, in a DDS_GUID_t in big-endian
562  * order
563  *
564  * \param[inout] self GUID to set suffix in
565  * \param[in] suffix Suffix to set
566  */
567 DDSCDllExport void
568 DDS_GUID_set_suffix(struct DDS_GUID_t *self,DDS_Long suffix);
569 
570 /* ================================================================= */
571 /* Sequence Number Support */
572 /* ================================================================= */
573 
574 /*e
575  * \dref_SequenceNumberSupportGroupDocs
576  */
577 
578 /*e \dref_SequenceNumber_t
579  */
580 struct DDSCPPDllExport DDS_SequenceNumber_t
581 {
582  /*e \dref_SequenceNumber_t_high
583  */
584  DDS_Long high;
585 
586  /*e \dref_SequenceNumber_t_low
587  */
588  DDS_UnsignedLong low;
589 
590  DDSC_CPP_QOS_POLICY_METHODS(DDS_SequenceNumber_t)
591 
592 #ifdef RTI_CPP
593 public:
594  int compare(const DDS_SequenceNumber_t *other);
595 #endif
596 };
597 
598 /*i \dref_SequenceNumber_NUMBER_UNKNOWN
599  */
600 #define DDS_SEQUENCE_NUMBER_UNKNOWN REDA_SEQUENCE_NUMBER_UNKNOWN
601 
602 /*i \dref_SequenceNumber_NUMBER_ZERO
603  */
604 #define DDS_SEQUENCE_NUMBER_ZERO REDA_SEQUENCE_NUMBER_ZERO
605 
606 /*i \dref_SequenceNumber_NUMBER_MAX
607  */
608 #define DDS_SEQUENCE_NUMBER_MAX REDA_SEQUENCE_NUMBER_MAX
609 
610 /*e \dref_SequenceNumber_t_compare
611  */
612 DDSCDllExport int
613 DDS_SequenceNumber_compare(const struct DDS_SequenceNumber_t *sn1,
614  const struct DDS_SequenceNumber_t *sn2);
615 
616 
617 /* ================================================================= */
618 /* Return Types */
619 /* ================================================================= */
620 /*e \dref_ReturnCodeGroupDocs
621  */
622 
623 /* ----------------------------------------------------------------- */
624 /*e \dref_ReturnCode_t
625 */
626 typedef enum
627 {
628  /*e \dref_ReturnCode_t_RETCODE_OK
629  */
630  DDS_RETCODE_OK = 0,
631 
632  /*e \dref_ReturnCode_t_RETCODE_ERROR
633  */
634  DDS_RETCODE_ERROR = 1,
635 
636  /*e \dref_ReturnCode_t_RETCODE_UNSUPPORTED
637  */
638  DDS_RETCODE_UNSUPPORTED = 2,
639 
640  /*e \dref_ReturnCode_t_RETCODE_BAD_PARAMETER
641  */
642  DDS_RETCODE_BAD_PARAMETER = 3,
643 
644  /*e \dref_ReturnCode_t_RETCODE_PRECONDITION_NOT_MET
645  */
646  DDS_RETCODE_PRECONDITION_NOT_MET = 4,
647 
648  /*e \dref_ReturnCode_t_RETCODE_OUT_OF_RESOURCES
649  */
650  DDS_RETCODE_OUT_OF_RESOURCES = 5,
651 
652  /*e \dref_ReturnCode_t_RETCODE_NOT_ENABLED
653  */
654  DDS_RETCODE_NOT_ENABLED = 6,
655 
656  /*e \dref_ReturnCode_t_RETCODE_IMMUTABLE_POLICY
657  */
658  DDS_RETCODE_IMMUTABLE_POLICY = 7,
659 
660  /*e \dref_ReturnCode_t_RETCODE_INCONSISTENT_POLICY
661  */
662  DDS_RETCODE_INCONSISTENT_POLICY = 8,
663 
664  /*e \dref_ReturnCode_t_RETCODE_ALREADY_DELETED
665  */
666  DDS_RETCODE_ALREADY_DELETED = 9,
667 
668  /*e \dref_ReturnCode_t_RETCODE_TIMEOUT
669  */
670  DDS_RETCODE_TIMEOUT = 10,
671 
672  /*e \dref_ReturnCode_t_RETCODE_NO_DATA
673  */
674  DDS_RETCODE_NO_DATA = 11,
675 
676  /*e \dref_ReturnCode_t_RETCODE_ILLEGAL_OPERATION
677  */
678  DDS_RETCODE_ILLEGAL_OPERATION = 12
679 } DDS_ReturnCode_t;
680 
681 
682 /* ================================================================= */
683 /* VARIABLE LENGTH TYPES SUPPORT */
684 /* ================================================================= */
685 /*i @defgroup DDSVarLenType Full Variable Length Type Support
686  @ingroup DDSCommonModule
687  */
688 #define DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_FULL(T) \
689  struct T; \
690  DDSCDllExport DDS_Boolean T ## _initialize(struct T* self); \
691  DDSCDllExport DDS_Boolean T ## _finalize(struct T* self); \
692  DDSCDllExport DDS_Boolean T ## _copy(struct T* self, const struct T* from);\
693  MUST_CHECK_RETURN DDSCDllExport DDS_Boolean T ## _is_equal(const struct T* self, const struct T* from)
694 
695 /*i @defgroup DDSVarLenType Basic Variable Length Type Support
696  @ingroup DDSCommonModule
697  */
698 #define DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(T) \
699  struct T; \
700  DDSCDllExport DDS_Boolean T ## _is_equal(const struct T* self, const struct T* from)
701 
702 /* DDSCDllExport DDS_ReturnCode_t T ## _copy(struct T* self, const struct T* from); */
703 
704 /* ================================================================= */
705 /* Status Types */
706 /* ================================================================= */
707 
708 /*e \dref_StatusKindGroupDocs
709  */
710 
711 /*e \dref_StatusMask
712  */
713 typedef DDS_UnsignedLong DDS_StatusMask;
714 
715 /*e \dref_STATUS_MASK_NONE
716  */
717 #define DDS_STATUS_MASK_NONE ((DDS_StatusMask) 0)
718 
719 /*e \dref_STATUS_MASK_ALL
720  */
721 #define DDS_STATUS_MASK_ALL (~DDS_STATUS_MASK_NONE)
722 
723 /* ----------------------------------------------------------------- */
724 /*e \dref_StatusKind
725  */
726 typedef enum
727 {
728  /*e \dref_StatusKind_INCONSISTENT_TOPIC_STATUS
729  */
730  DDS_INCONSISTENT_TOPIC_STATUS = 0x0001 << 0,
731 
732  /*e \dref_StatusKind_OFFERED_DEADLINE_MISSED_STATUS
733  */
734  DDS_OFFERED_DEADLINE_MISSED_STATUS = 0x0001 << 1,
735 
736  /*e \dref_StatusKind_REQUESTED_DEADLINE_MISSED_STATUS
737  */
738  DDS_REQUESTED_DEADLINE_MISSED_STATUS = 0x0001 << 2,
739 
740  /*e \dref_StatusKind_OFFERED_INCOMPATIBLE_QOS_STATUS
741  */
742  DDS_OFFERED_INCOMPATIBLE_QOS_STATUS = 0x0001 << 5,
743 
744  /*e \dref_StatusKind_REQUESTED_INCOMPATIBLE_QOS_STATUS
745  */
746  DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS = 0x0001 << 6,
747 
748  /*e \dref_StatusKind_SAMPLE_LOST_STATUS
749  */
750  DDS_SAMPLE_LOST_STATUS = 0x0001 << 7,
751 
752  /*e \dref_StatusKind_SAMPLE_REJECTED_STATUS
753  */
754  DDS_SAMPLE_REJECTED_STATUS = 0x0001 << 8,
755 
756  /*e \dref_StatusKind_DATA_ON_READERS_STATUS
757  */
758  DDS_DATA_ON_READERS_STATUS = 0x0001 << 9,
759 
760  /*e \dref_StatusKind_DATA_AVAILABLE_STATUS
761  */
762  DDS_DATA_AVAILABLE_STATUS = 0x0001 << 10,
763 
764  /*e \dref_StatusKind_LIVELINESS_LOST_STATUS
765  */
766  DDS_LIVELINESS_LOST_STATUS = 0x0001 << 11,
767 
768  /*e \dref_StatusKind_LIVELINESS_CHANGED_STATUS
769  */
770  DDS_LIVELINESS_CHANGED_STATUS = 0x0001 << 12,
771 
772  /*e \dref_StatusKind_PUBLICATION_MATCHED_STATUS
773  */
774  DDS_PUBLICATION_MATCHED_STATUS = 0x0001 << 13,
775 
776  /*e \dref_StatusKind_SUBSCRIPTION_MATCHED_STATUS
777  */
778  DDS_SUBSCRIPTION_MATCHED_STATUS = 0x0001 << 14,
779 
780  /* --- Begin extended statuses --- */
781  /* The "right"-most 24 bits of the StatusMask are reserved
782  * for standard statuses. The remaining 8 bits are for extended statuses.
783  */
784 
785  /*e \dref_StatusKind_INSTANCE_REPLACED_STATUS
786  */
787  DDS_INSTANCE_REPLACED_STATUS = 0x0001 << 25,
788 
789  /*e \dref_StatusKind_RELIABLE_READER_ACTIVITY_CHANGED_STATUS
790  */
791  DDS_RELIABLE_READER_ACTIVITY_CHANGED_STATUS = 0x0001 << 26
792 
793 } DDS_StatusKind;
794 
795 /* ================================================================= */
796 /* QoS Types */
797 /* ================================================================= */
798 /*e \dref_QosPoliciesGroupDocs
799  */
800 
801 /*e \dref_QosPolicyId_t
802  *
803  * Note that the value of these constants disagree with the values of
804  * the corresponding parameter IDs in the RTPS protocol. This conflict
805  * is unavoidable since these values are given in the DDS specification,
806  * which is not tied to RTPS.
807  */
808 typedef enum
809 {
810  /*e \dref_QosPolicyId_t_INVALID_QOS_POLICY_ID
811  */
812  DDS_INVALID_QOS_POLICY_ID = 0,
813 
814  /*i \dref_QosPolicyId_t_USERDATA_QOS_POLICY_ID
815  */
816  DDS_USERDATA_QOS_POLICY_ID = 1,
817 
818  /*i \dref_QosPolicyId_t_DURABILITY_QOS_POLICY_ID
819  */
820  DDS_DURABILITY_QOS_POLICY_ID = 2,
821 
822  /*i \dref_QosPolicyId_t_PRESENTATION_QOS_POLICY_ID
823  */
824  DDS_PRESENTATION_QOS_POLICY_ID = 3,
825 
826  /*e \dref_QosPolicyId_t_DEADLINE_QOS_POLICY_ID
827  */
828  DDS_DEADLINE_QOS_POLICY_ID = 4,
829 
830  /*i \dref_QosPolicyId_t_LATENCYBUDGET_QOS_POLICY_ID
831  */
832  DDS_LATENCYBUDGET_QOS_POLICY_ID = 5,
833 
834  /*e \dref_QosPolicyId_t_OWNERSHIP_QOS_POLICY_ID
835  */
836  DDS_OWNERSHIP_QOS_POLICY_ID = 6,
837 
838  /*e \dref_QosPolicyId_t_OWNERSHIPSTRENGTH_QOS_POLICY_ID
839  */
840  DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID = 7,
841 
842  /*e \dref_QosPolicyId_t_LIVELINESS_QOS_POLICY_ID
843  */
844  DDS_LIVELINESS_QOS_POLICY_ID = 8,
845 
846  /*i \dref_QosPolicyId_t_TIMEBASEDFILTER_QOS_POLICY_ID
847  */
848  DDS_TIMEBASEDFILTER_QOS_POLICY_ID = 9,
849 
850  /*i \dref_QosPolicyId_t_PARTITION_QOS_POLICY_ID
851  */
852  DDS_PARTITION_QOS_POLICY_ID = 10,
853 
854  /*e \dref_QosPolicyId_t_RELIABILITY_QOS_POLICY_ID
855  */
856  DDS_RELIABILITY_QOS_POLICY_ID = 11,
857 
858  /*i \dref_QosPolicyId_t_DESTINATIONORDER_QOS_POLICY_ID
859  */
860  DDS_DESTINATIONORDER_QOS_POLICY_ID = 12,
861 
862  /*e \dref_QosPolicyId_t_HISTORY_QOS_POLICY_ID
863  */
864  DDS_HISTORY_QOS_POLICY_ID = 13,
865 
866  /*i \dref_QosPolicyId_t_RESOURCELIMITS_QOS_POLICY_ID
867  */
868  DDS_RESOURCELIMITS_QOS_POLICY_ID = 14,
869 
870  /*e \dref_QosPolicyId_t_ENTITYFACTORY_QOS_POLICY_ID
871  */
872  DDS_ENTITYFACTORY_QOS_POLICY_ID = 15,
873 
874  /*i \dref_QosPolicyId_t_WRITERDATALIFECYCLE_QOS_POLICY_ID
875  */
876  DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID = 16,
877 
878  /*i \dref_QosPolicyId_t_READERDATALIFECYCLE_QOS_POLICY_ID
879  */
880  DDS_READERDATALIFECYCLE_QOS_POLICY_ID = 17,
881 
882  /*i \dref_QosPolicyId_t_TOPICDATA_QOS_POLICY_ID
883  */
884  DDS_TOPICDATA_QOS_POLICY_ID = 18,
885 
886  /*i \dref_QosPolicyId_t_GROUPDATA_QOS_POLICY_ID
887  */
888  DDS_GROUPDATA_QOS_POLICY_ID = 19,
889 
890  /*i \dref_QosPolicyId_t_TRANSPORTPRIORITY_QOS_POLICY_ID
891  */
892  DDS_TRANSPORTPRIORITY_QOS_POLICY_ID = 20,
893 
894  /*i \dref_QosPolicyId_t_LIFESPAN_QOS_POLICY_ID
895  */
896  DDS_LIFESPAN_QOS_POLICY_ID = 21,
897 
898  /*i \dref_QosPolicyId_t_DURABILITYSERVICE_QOS_POLICY_ID
899  */
900  DDS_DURABILITYSERVICE_QOS_POLICY_ID = 22,
901 
902 } DDS_QosPolicyId_t;
903 
904 /* ----------------------------------------------------------------- */
905 /*i \dref_QosPolicyCount
906  */
907 struct DDS_QosPolicyCount
908 {
909  /*e \dref_QosPolicyCount_policy_id
910  */
911  DDS_QosPolicyId_t policy_id;
912 
913  /*e \dref_QosPolicyCount_count
914  */
915  DDS_Long count;
916 };
917 
918 #define T struct DDS_QosPolicyCount
919 #define TSeq DDS_QosPolicyCountSeq
920 #include <reda/reda_sequence_decl.h>
921 
922 #ifdef DOXYGEN_DOCUMENTATION_ONLY
923 /*i \dref_QosPolicyCountSeq
924  */
925 struct DDS_QosPolicyCountSeq
926 {
927 };
928 #endif
929 
930 /* ================================================================= */
931 /* Entity Types */
932 /* ================================================================= */
933 
934 /*e \dref_EntityKind_t
935 */
936 typedef enum
937 {
938  /*e \dref_EntityKind_t_UNKNOWN_ENTITY_KIND
939  */
940  DDS_UNKNOWN_ENTITY_KIND = 0,
941  /*e \dref_EntityKind_t_PARTICIPANT_ENTITY_KIND
942  */
943  DDS_PARTICIPANT_ENTITY_KIND = 1,
944  /*e \dref_EntityKind_t_PUBLISHER_ENTITY_KIND
945  */
946  DDS_PUBLISHER_ENTITY_KIND = 2,
947  /*e \dref_EntityKind_t_SUBSCRIBER_ENTITY_KIND
948  */
949  DDS_SUBSCRIBER_ENTITY_KIND = 3,
950  /*e \dref_EntityKind_t_TOPIC_ENTITY_KIND
951  */
952  DDS_TOPIC_ENTITY_KIND = 4,
953  /*e \dref_EntityKind_t_DATAREADER_ENTITY_KIND
954  */
955  DDS_DATAREADER_ENTITY_KIND = 5,
956  /*e \dref_EntityKind_t_DATAWRITER_ENTITY_KIND
957  */
958  DDS_DATAWRITER_ENTITY_KIND = 6
959 } DDS_EntityKind_t;
960 
961 /* ----------------------------------------------------------------- */
962 /* DEADLINE */
963 /* ----------------------------------------------------------------- */
964 /*e \dref_DeadlineQosGroupDocs
965  */
966 
967 /*e \dref_DEADLINE_QOS_POLICY_NAME
968  */
969 extern DDSCDllVariable const char *const DDS_DEADLINE_QOS_POLICY_NAME;
970 
971 /* ----------------------------------------------------------------- */
972 /*e \dref_DeadlineQosPolicy
973  */
974 struct DDSCPPDllExport DDS_DeadlineQosPolicy
975 {
976  /*e \dref_DeadlineQosPolicy_period
977  */
978  struct DDS_Duration_t period;
979 
980  DDSC_CPP_QOS_POLICY_METHODS(DDS_DeadlineQosPolicy)
981 };
982 
983 DDSC_QOS_POLICY_METHODS_DECL(DDS_DeadlineQosPolicy)
984 
985 /*ci
986  * \brief Calculate the sampling frequency for the deadline Qos policy
987  *
988  * \details
989  *
990  * A deadline is measured between two sent or received samples. However,
991  * when no more samples are received there is nothing to compare against. To
992  * solve this problem a periodic check can be performed. Every period a check
993  * is performed to check if a sample should have been received. If the time
994  * since the last check exceeds the deadline period the deadline has been
995  * missed. This function calculates a reasonable sampling frequency for
996  * different deadlines. The sampling frequency is based on a reasonable effort
997  * to detect a stale instance without overloading the CPU. The constants used
998  * in this function are not used elsewhere and the method to calculate the
999  * sampling frequency is considered a formula. Thus, the constants are not
1000  * considered magic.
1001  *
1002  * NOTE: This function assumes valid deadline and sample_freq inputs.
1003  * Invalid arguments have undefined behavior.
1004  *
1005  * \param[in] deadline The deadline to calculate a sampling frequency for
1006  * \param[out] sample_freq A suitable sampling frequency for deadline
1007  */
1008 DDSCDllExport void
1009 DDS_DeadlineQosPolicy_get_sample_freq(
1010  const struct DDS_DeadlineQosPolicy *const deadline,
1011  struct DDS_Duration_t *const sample_freq);
1012 
1013 /*i
1014  * \brief Convert a duration to ms
1015  *
1016  * \details
1017  * This function converts from sec,nanosec to milliseconds. Note that
1018  * no check is performed for overflow.
1019  *
1020  * \param[in] self Duration structure to convert to ms
1021  */
1022 DDSCDllExport DDS_Long
1023 DDS_Duration_to_ms(const struct DDS_Duration_t *const self);
1024 
1025 /*i \dref_DeadlineQosPolicy_DEFAULT
1026  * Default is infinite
1027  */
1028 #define DDS_DEADLINE_QOS_POLICY_DEFAULT \
1029 {DDS_DURATION_INFINITE_INITIALIZER}
1030 
1031 /* ----------------------------------------------------------------- */
1032 /* OWNERSHIP */
1033 /* ----------------------------------------------------------------- */
1034 /*e \dref_OwnershipQosGroupDocs
1035  */
1036 
1037 /*e \dref_OWNERSHIP_QOS_POLICY_NAME
1038  */
1039 extern DDSCDllVariable const char *const DDS_OWNERSHIP_QOS_POLICY_NAME;
1040 
1041 /* ----------------------------------------------------------------- */
1042 /*e \dref_OwnershipQosPolicyKind
1043  */
1044 typedef enum
1045 {
1046  /*e \dref_OwnershipQosPolicyKind_SHARED_OWNERSHIP_QOS
1047  */
1048  DDS_SHARED_OWNERSHIP_QOS,
1049 
1050  /*e \dref_OwnershipQosPolicyKind_EXCLUSIVE_OWNERSHIP_QOS
1051  */
1052  DDS_EXCLUSIVE_OWNERSHIP_QOS
1053 } DDS_OwnershipQosPolicyKind;
1054 
1055 /* ----------------------------------------------------------------- */
1056 /*e \dref_OwnershipQosPolicy
1057  */
1058 struct DDSCPPDllExport DDS_OwnershipQosPolicy
1059 {
1060  /*e \dref_OwnershipQosPolicy_kind
1061  */
1062  DDS_OwnershipQosPolicyKind kind;
1063 
1064  DDSC_CPP_QOS_POLICY_METHODS(DDS_OwnershipQosPolicy)
1065 };
1066 
1067 /*i \dref_OwnershipQosPolicy_DEFAULT
1068  */
1069 #define DDS_OWNERSHIP_QOS_POLICY_DEFAULT { DDS_SHARED_OWNERSHIP_QOS }
1070 
1071 DDSC_QOS_POLICY_METHODS_DECL(DDS_OwnershipQosPolicy)
1072 
1073 /* ----------------------------------------------------------------- */
1074 /* OWNERSHIP_STRENGTH */
1075 /* ----------------------------------------------------------------- */
1076 /*e \dref_OwnershipStrengthQosGroupDocs
1077  */
1078 
1079 /*e \dref_OWNERSHIPSTRENGTH_QOS_POLICY_NAME
1080  */
1081 extern DDSCDllVariable const char *const DDS_OWNERSHIPSTRENGTH_QOS_POLICY_NAME;
1082 
1083 /* ----------------------------------------------------------------- */
1084 /*e \dref_OwnershipStrengthQosPolicy
1085  */
1086 struct DDSCPPDllExport DDS_OwnershipStrengthQosPolicy
1087 {
1088  /*e \dref_OwnershipStrengthQosPolicy_value
1089  */
1090  DDS_Long value;
1091 
1092  DDSC_CPP_QOS_POLICY_METHODS(DDS_OwnershipStrengthQosPolicy)
1093 };
1094 
1095 /*i \dref_OwnershipStrengthQosPolicy_DEFAULT
1096  */
1097 #define DDS_OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT { 0L }
1098 
1099 DDSC_QOS_POLICY_METHODS_DECL(DDS_OwnershipStrengthQosPolicy)
1100 
1101 /* ----------------------------------------------------------------- */
1102 /* LIVELINESS */
1103 /* ----------------------------------------------------------------- */
1104 /*e \dref_LivelinessQosGroupDocs
1105  */
1106 
1107 /*e \dref_LIVELINESS_QOS_POLICY_NAME
1108  */
1109 extern DDSCDllVariable const char *const DDS_LIVELINESS_QOS_POLICY_NAME;
1110 
1111 /* ----------------------------------------------------------------- */
1112 /*e \dref_LivelinessQosPolicyKind
1113  */
1114 typedef enum
1115 {
1116  /*i \dref_LivelinessQosPolicyKind_AUTOMATIC_LIVELINESS_QOS
1117  */
1118  DDS_AUTOMATIC_LIVELINESS_QOS,
1119 
1120  /*i \dref_LivelinessQosPolicyKind_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
1121  */
1122  DDS_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
1123 
1124  /*e \dref_LivelinessQosPolicyKind_MANUAL_BY_TOPIC_LIVELINESS_QOS
1125  */
1126  DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS
1127 } DDS_LivelinessQosPolicyKind;
1128 
1129 /* ----------------------------------------------------------------- */
1130 /*e \dref_LivelinessQosPolicy
1131  */
1132 struct DDSCPPDllExport DDS_LivelinessQosPolicy
1133 {
1134  /*e \dref_LivelinessQosPolicy_kind
1135  */
1136  DDS_LivelinessQosPolicyKind kind;
1137 
1138  /*e \dref_LivelinessQosPolicy_lease_duration
1139  */
1140  struct DDS_Duration_t lease_duration;
1141 
1142  DDSC_CPP_QOS_POLICY_METHODS(DDS_LivelinessQosPolicy)
1143 };
1144 
1145 /*i \dref_LivelinessQosPolicy_DEFAULT
1146  * Default least duration is infinite
1147  */
1148 #define DDS_LIVELINESS_QOS_POLICY_DEFAULT \
1149 {\
1150  DDS_AUTOMATIC_LIVELINESS_QOS,\
1151  DDS_DURATION_INFINITE_INITIALIZER \
1152 }
1153 
1154 DDSC_QOS_POLICY_METHODS_DECL(DDS_LivelinessQosPolicy)
1155 
1156 /* ----------------------------------------------------------------- */
1157 /* RELIABILITY */
1158 /* ----------------------------------------------------------------- */
1159 /*e \dref_ReliabilityQosGroupDocs
1160  */
1161 
1162 /*e \dref_RELIABILITY_QOS_POLICY_NAME
1163  */
1164 extern DDSCDllVariable const char *const DDS_RELIABILITY_QOS_POLICY_NAME;
1165 
1166 /* ----------------------------------------------------------------- */
1167 /*e \dref_ReliabilityQosPolicyKind
1168  */
1169 typedef enum
1170 {
1171  /*e \dref_ReliabilityQosPolicyKind_BEST_EFFORT_RELIABILITY_QOS
1172  */
1173  DDS_BEST_EFFORT_RELIABILITY_QOS = 0x01,
1174 
1175  /*e \dref_ReliabilityQosPolicyKind_RELIABLE_RELIABILITY_QOS
1176  * NOTE: The RTPS spec defines reliability as 0x03 to comply with RTPS spec.
1177  * However, RTI Connext Core uses 0x3, as well as others.
1178  */
1179  DDS_RELIABLE_RELIABILITY_QOS = 0x02
1180 } DDS_ReliabilityQosPolicyKind;
1181 
1182 /* ----------------------------------------------------------------- */
1183 /*e \dref_ReliabilityQosPolicy
1184  */
1185 struct DDSCPPDllExport DDS_ReliabilityQosPolicy
1186 {
1187  /*e \dref_ReliabilityQosPolicy_kind
1188  */
1189  DDS_ReliabilityQosPolicyKind kind;
1190 
1191  /*e \dref_ReliabilityQosPolicy_max_blocking_time
1192  */
1193  struct DDS_Duration_t max_blocking_time;
1194 
1195  DDSC_CPP_QOS_POLICY_METHODS(DDS_ReliabilityQosPolicy)
1196 };
1197 
1198 /*i \dref_ReliabilityQosPolicy_DEFAULT
1199  */
1200 #define DDS_RELIABILITY_QOS_POLICY_DEFAULT \
1201  { DDS_BEST_EFFORT_RELIABILITY_QOS, \
1202  {0L, 0UL} }
1203 
1204 DDSC_QOS_POLICY_METHODS_DECL(DDS_ReliabilityQosPolicy)
1205 
1206 /* ----------------------------------------------------------------- */
1207 /* HISTORY */
1208 /* ----------------------------------------------------------------- */
1209 /*e \dref_HistoryQosGroupDocs
1210  */
1211 
1212 /*e \dref_HISTORY_QOS_POLICY_NAME
1213  */
1214 extern DDSCDllVariable const char *const DDS_HISTORY_QOS_POLICY_NAME;
1215 
1216 /* ----------------------------------------------------------------- */
1217 /*e \dref_HistoryQosPolicyKind
1218  */
1219 typedef enum
1220 {
1221  /*e \dref_HistoryQosPolicyKind_KEEP_LAST_HISTORY_QOS
1222  */
1223  DDS_KEEP_LAST_HISTORY_QOS,
1224 
1225  /*i \dref_HistoryQosPolicyKind_KEEP_ALL_HISTORY_QOS
1226  */
1227  DDS_KEEP_ALL_HISTORY_QOS
1228 } DDS_HistoryQosPolicyKind;
1229 
1230 /*ci \brief The maximum allowed history depth.
1231  *
1232  * \details
1233  * The maximum depth is the maximum positive integer which can be
1234  * represented by a 32 bit signed integer.
1235  */
1236 #define DDS_MAX_DEPTH_HISTORY_QOS (2147483647)
1237 
1238 /* ----------------------------------------------------------------- */
1239 /*e \dref_HistoryQosPolicy
1240  */
1241 struct DDSCPPDllExport DDS_HistoryQosPolicy
1242 {
1243  /*e \dref_HistoryQosPolicy_kind
1244  */
1245  DDS_HistoryQosPolicyKind kind;
1246 
1247  /*e \dref_HistoryQosPolicy_depth
1248  */
1249  DDS_Long depth;
1250 
1251  DDSC_CPP_QOS_POLICY_METHODS(DDS_HistoryQosPolicy)
1252 };
1253 
1254 /*i \dref_HistoryQosPolicy_DEFAULT
1255  */
1256 #define DDS_HISTORY_QOS_POLICY_DEFAULT { DDS_KEEP_LAST_HISTORY_QOS, \
1257  1L /* depth */ }
1258 
1259 DDSC_QOS_POLICY_METHODS_DECL(DDS_HistoryQosPolicy)
1260 
1261 /* ----------------------------------------------------------------- */
1262 /* DURABILITY */
1263 /* ----------------------------------------------------------------- */
1264 /*e \dref_DurabilityQosGroupDocs
1265 */
1266 
1267 /*e \dref_DURABILITY_QOS_POLICY_NAME
1268  */
1269 extern DDSCDllVariable const char *const DDS_DURABILITY_QOS_POLICY_NAME;
1270 
1271 /* ----------------------------------------------------------------- */
1272 /*e \dref_DurabilityQosPolicyKind
1273 */
1274 typedef enum
1275 {
1276  /*e \dref_DurabilityQosPolicyKind_VOLATILE_DURABILITY_QOS
1277  */
1278  DDS_VOLATILE_DURABILITY_QOS,
1279 
1280  /*e \dref_DurabilityQosPolicyKind_TRANSIENT_LOCAL_DURABILITY_QOS
1281  */
1282  DDS_TRANSIENT_LOCAL_DURABILITY_QOS,
1283 
1284  /*i \dref_DurabilityQosPolicyKind_TRANSIENT_DURABILITY_QOS
1285  */
1286  DDS_TRANSIENT_DURABILITY_QOS,
1287 
1288  /*i \dref_DurabilityQosPolicyKind_PERSISTENT_DURABILITY_QOS
1289  */
1290  DDS_PERSISTENT_DURABILITY_QOS
1291 } DDS_DurabilityQosPolicyKind;
1292 
1293 /* ----------------------------------------------------------------- */
1294 /*e \dref_DurabilityQosPolicy
1295  */
1296 struct DDSCPPDllExport DDS_DurabilityQosPolicy
1297 {
1298  /*e \dref_DurabilityQosPolicy_kind
1299  */
1300  DDS_DurabilityQosPolicyKind kind;
1301 
1302  DDSC_CPP_QOS_POLICY_METHODS(DDS_DurabilityQosPolicy)
1303 };
1304 
1305 /*i \dref_DurabilityQosPolicy_DEFAULT
1306  */
1307 #define DDS_DURABILITY_QOS_POLICY_DEFAULT \
1308 { DDS_VOLATILE_DURABILITY_QOS }
1309 
1310 DDSC_QOS_POLICY_METHODS_DECL(DDS_DurabilityQosPolicy)
1311 
1312 /* ----------------------------------------------------------------- */
1313 /* RESOURCE_LIMITS */
1314 /* ----------------------------------------------------------------- */
1315 /*e \dref_ResourceLimitsQosGroupDocs
1316  */
1317 
1318 /*e \dref_RESOURCELIMITS_QOS_POLICY_NAME
1319  */
1320 extern DDSCDllVariable const char *const DDS_RESOURCELIMITS_QOS_POLICY_NAME;
1321 
1322 /*e \dref_LENGTH_UNLIMITED
1323  */
1324 extern DDSCDllVariable const DDS_Long DDS_LENGTH_UNLIMITED;
1325 
1326 /*e \dref_LENGTH_AUTO
1327  */
1328 extern DDSCDllVariable const DDS_Long DDS_LENGTH_AUTO;
1329 
1330 /* ----------------------------------------------------------------- */
1331 /*e \dref_ResourceLimitsQosPolicy
1332  */
1333 struct DDSCPPDllExport DDS_ResourceLimitsQosPolicy
1334 {
1335  /*e \dref_ResourceLimitsQosPolicy_max_samples
1336  */
1337  DDS_Long max_samples;
1338 
1339  /*e \dref_ResourceLimitsQosPolicy_max_instances
1340  */
1341  DDS_Long max_instances;
1342 
1343  /*e \dref_ResourceLimitsQosPolicy_max_samples_per_instance
1344  */
1345  DDS_Long max_samples_per_instance;
1346 
1347  DDSC_CPP_QOS_POLICY_METHODS(DDS_ResourceLimitsQosPolicy)
1348 };
1349 
1350 /*i \dref_ResourceLimitsQosPolicy_DEFAULT
1351  */
1352 #define DDS_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1353  1L, /* max_samples */ \
1354  1L, /* max_instances */ \
1355  1L, /* max_samples_per_instance */ \
1356 }
1357 
1358 DDSC_QOS_POLICY_METHODS_DECL(DDS_ResourceLimitsQosPolicy)
1359 
1360 /* ----------------------------------------------------------------- */
1361 /* DESTINATION_ORDER */
1362 /* ----------------------------------------------------------------- */
1363 /*e \dref_DestinationOrderQosGroupDocs
1364  */
1365 /*e \dref_DestinationOrderPolicyKind
1366 */
1367 typedef enum
1368 {
1369  /*e \dref_DestinationOrderPolicyKind_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS
1370  */
1371  DDS_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,
1372 
1373  /*e \dref_DestinationOrderPolicyKind_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
1374  */
1375  DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
1376 } DDS_DestinationOrderQosPolicyKind;
1377 
1378 /*e \dref_DestinationOrderQosPolicy
1379  */
1380 struct DDSCPPDllExport DDS_DestinationOrderQosPolicy
1381 {
1382  /*e \dref_DestinationOrderQosPolicy_kind
1383  */
1384  DDS_DestinationOrderQosPolicyKind kind;
1385 
1386  /*e \dref_DestinationOrderQosPolicy_source_timestamp_tolerance
1387  */
1388  struct DDS_Duration_t source_timestamp_tolerance;
1389 
1390  DDSC_CPP_QOS_POLICY_METHODS(DDS_DestinationOrderQosPolicy)
1391 };
1392 
1393 /*i \dref_DestinationOrderQosPolicy_DEFAULT
1394  */
1395 #define DDS_DESTINATION_ORDER_QOS_POLICY_DEFAULT \
1396 { \
1397  DDS_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS, \
1398  {0,100000000} \
1399 }
1400 
1401 DDSC_QOS_POLICY_METHODS_DECL(DDS_DestinationOrderQosPolicy)
1402 
1403 /* ----------------------------------------------------------------- */
1404 /*e \dref_DataReaderResourceLimitsInstanceReplacementKind
1405 */
1406 typedef enum
1407 {
1408  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_NO_INSTANCE_REPLACEMENT_QOS
1409  */
1410  DDS_NO_INSTANCE_REPLACEMENT_QOS,
1411 
1412  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1413  */
1414  DDS_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1415 } DDS_DataReaderResourceLimitsInstanceReplacementKind;
1416 
1417 /* ----------------------------------------------------------------- */
1418 /* DATAREADER_RESOURCE_LIMITS */
1419 /* ----------------------------------------------------------------- */
1420 /*e \dref_DataReaderResourceLimitsQosGroupDocs
1421  */
1422 
1423 /*e \dref_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME
1424  */
1425 extern DDSCDllVariable const char *const
1426  DDS_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME;
1427 
1428 /* ----------------------------------------------------------------- */
1429 /*e \dref_DataReaderResourceLimitsQosPolicy
1430  */
1431 struct DDSCPPDllExport DDS_DataReaderResourceLimitsQosPolicy
1432 {
1433  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers
1434  */
1435  DDS_Long max_remote_writers;
1436 
1437  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers_per_instance
1438  */
1439  DDS_Long max_remote_writers_per_instance;
1440 
1441  /*e \dref_DataReaderResourceLimitsQosPolicy_max_samples_per_remote_writer
1442  */
1443  DDS_Long max_samples_per_remote_writer;
1444 
1445  /*e \dref_DataReaderResourceLimitsQosPolicy_max_outstanding_reads
1446  */
1447  DDS_Long max_outstanding_reads;
1448 
1449  /*e \dref_DataReaderResourceLimitsQosPolicy_instance_replacement
1450  */
1451  DDS_DataReaderResourceLimitsInstanceReplacementKind instance_replacement;
1452 
1453  /*e \dref_DataReaderResourceLimitsQosPolicy_max_routes_per_writer
1454  */
1455  DDS_Long max_routes_per_writer;
1456 
1457  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataReaderResourceLimitsQosPolicy)
1458 };
1459 
1460 /*i \dref_DataReaderResourceLimitsQosPolicy_DEFAULT
1461  */
1462 #define DDS_DATAREADERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1463  1L, /* max_remote_writers */ \
1464  1L, /* max_remote_writers_per_instance */ \
1465  1L, /* max_samples_per_remote_writer */ \
1466  1L, /* max_outstanding_reads */ \
1467  DDS_NO_INSTANCE_REPLACEMENT_QOS, /* Default */ \
1468  4\
1469 }
1470 
1471 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataReaderResourceLimitsQosPolicy)
1472 
1473 /* ----------------------------------------------------------------- */
1474 /* DATAWRITER_RESOURCE_LIMITS */
1475 /* ----------------------------------------------------------------- */
1476 /*e \dref_DataWriterResourceLimitsQosGroupDocs
1477  */
1478 
1479 /*e \dref_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME
1480  */
1481 extern DDSCDllVariable const char *const
1482  DDS_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME;
1483 
1484 /* ----------------------------------------------------------------- */
1485 /*e \dref_DataWriterResourceLimitsQosPolicy
1486  */
1487 struct DDSCPPDllExport DDS_DataWriterResourceLimitsQosPolicy
1488 {
1489  /*e \dref_DataWriterResourceLimitsQosPolicy_max_remote_readers
1490  */
1491  DDS_Long max_remote_readers;
1492 
1493  /*e \dref_DataWriterResourceLimitsQosPolicy_max_routes_per_reader
1494  */
1495  DDS_Long max_routes_per_reader;
1496 
1497  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataWriterResourceLimitsQosPolicy)
1498 };
1499 
1500 /*i \dref_DataWriterResourceLimitsQosPolicy_DEFAULT
1501  */
1502 #define DDS_DATAWRITERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1503  16L, /* max_remote_readers */ \
1504  4\
1505 }
1506 
1507 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataWriterResourceLimitsQosPolicy)
1508 
1509 /* ----------------------------------------------------------------- */
1510 /* ENTITY_FACTORY */
1511 /* ----------------------------------------------------------------- */
1512 /*e \dref_EntityFactoryQosGroupDocs
1513  */
1514 
1515 /*e \dref_ENTITYFACTORY_QOS_POLICY_NAME
1516  */
1517 extern DDSCDllVariable const char *const DDS_ENTITYFACTORY_QOS_POLICY_NAME;
1518 
1519 /* ----------------------------------------------------------------- */
1520 /*e \dref_EntityFactoryQosPolicy
1521  */
1522 struct DDSCPPDllExport DDS_EntityFactoryQosPolicy
1523 {
1524  /*e \dref_EntityFactoryQosPolicy_autoenable_created_entities
1525  */
1526  DDS_Boolean autoenable_created_entities;
1527 
1528  DDSC_CPP_QOS_POLICY_METHODS(DDS_EntityFactoryQosPolicy)
1529 };
1530 
1531 /*i \dref_EntityFactoryQosPolicy_DEFAULT
1532  */
1533 #define DDS_ENTITY_FACTORY_QOS_POLICY_DEFAULT { DDS_BOOLEAN_TRUE }
1534 
1535 DDSC_QOS_POLICY_METHODS_DECL(DDS_EntityFactoryQosPolicy);
1536 
1537 /* ----------------------------------------------------------------- */
1538 /* EXTENDED QOS SUPPORT */
1539 /* ----------------------------------------------------------------- */
1540 
1541 /* ----------------------------------------------------------------- */
1542 /*e
1543  * \dref_ExtendedQosSupportGroupDocs
1544  */
1545 #define DDS_LENGTH_UNLIMITED (-1)
1546 
1547 #define DDS_LENGTH_AUTO (-2)
1548 
1549 /* ----------------------------------------------------------------- */
1550 
1551 /* ----------------------------------------------------------------- */
1552 /* TYPESUPPORT */
1553 /* ----------------------------------------------------------------- */
1554 /*i \dref_TypeSupportQosGroupDocs
1555 */
1556 
1557 /*i \dref_TYPESUPPORT_QOS_POLICY_NAME
1558  */
1559 extern DDSCDllVariable const char *const DDS_TYPESUPPORT_QOS_POLICY_NAME;
1560 
1561 /* ----------------------------------------------------------------- */
1562 /*i \dref_TypeSupportQosPolicy
1563  */
1564 struct DDSCPPDllExport DDS_TypeSupportQosPolicy
1565 {
1566  /*e \dref_TypeSupportQosPolicy_plugin_data
1567  */
1568  void *plugin_data;
1569 
1570  DDSC_CPP_QOS_POLICY_METHODS(DDS_TypeSupportQosPolicy)
1571 };
1572 
1573 /*i \dref_TypeSupportQosPolicy_DEFAULT
1574  */
1575 #define DDS_TYPESUPPORT_QOS_POLICY_DEFAULT \
1576 { NULL }
1577 
1578 DDSC_QOS_POLICY_METHODS_DECL(DDS_TypeSupportQosPolicy)
1579 
1580 /* ----------------------------------------------------------------- */
1581 /* SYSTEM_RESOURCE_LIMITS_X (eXtension QoS) */
1582 /* ----------------------------------------------------------------- */
1583 /*e \dref_SystemResourceLimitsQosGroupDocs
1584  */
1585 
1586 /*e \dref_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME
1587  */
1588 extern DDSCDllVariable const char *const DDS_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME;
1589 
1590 /* ----------------------------------------------------------------- */
1591 
1592 /*e \dref_SystemResourceLimitsQosPolicy
1593  */
1594 struct DDSCPPDllExport DDS_SystemResourceLimitsQosPolicy
1595 {
1596  /*e \dref_SystemResourceLimitsQosPolicy_max_participants
1597  */
1598  DDS_Long max_participants;
1599 
1600  /*e \dref_SystemResourceLimitsQosPolicy_max_components
1601  */
1602  DDS_Long max_components;
1603 
1604  DDSC_CPP_QOS_POLICY_METHODS(DDS_SystemResourceLimitsQosPolicy)
1605 };
1606 
1607 /*i \dref_SystemResourceLimitsQosPolicy_DEFAULT
1608  */
1609 #define DDS_SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { 1L,16L }
1610 
1611 DDSC_QOS_POLICY_METHODS_DECL(DDS_SystemResourceLimitsQosPolicy)
1612 
1613 /* ----------------------------------------------------------------- */
1614 /* WIRE_PROTOCOL_X (eXtension QoS) */
1615 /* ----------------------------------------------------------------- */
1616 /*e \dref_WireProtocolQosGroupDocs
1617  */
1618 
1619 #define DDS_RtpsWellKnownPorts NETIO_RtpsPortParam
1620 
1621 /*e \dref_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS
1622  */
1623 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1624  DDS_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS;
1625 
1626 /*e \dref_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS
1627  */
1628 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1629  DDS_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS;
1630 
1631 /*i @ingroup DDSWireProtocolQosModule
1632  these defaults are compatible with >= 4.2d
1633  */
1634 
1635 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1636 /*e \dref_RtpsWellKnownPorts_t
1637  */
1638 struct DDS_RtpsWellKnownPorts_t
1639 {
1640  /*e \dref_RtpsWellKnownPorts_t_port_base
1641  */
1642  DDS_Long port_base;
1643 
1644  /*e \dref_RtpsWellKnownPorts_t_domain_id_gain
1645  */
1646  DDS_Long domain_id_gain;
1647 
1648  /*e \dref_RtpsWellKnownPorts_t_participant_id_gain
1649  */
1650  DDS_Long participant_id_gain;
1651 
1652  /*e \dref_RtpsWellKnownPorts_t_builtin_multicast_port_offset
1653  */
1654  DDS_Long builtin_multicast_port_offset;
1655 
1656  /*e \dref_RtpsWellKnownPorts_t_builtin_unicast_port_offset
1657  */
1658  DDS_Long builtin_unicast_port_offset;
1659 
1660  /*e \dref_RtpsWellKnownPorts_t_user_multicast_port_offset
1661  */
1662  DDS_Long user_multicast_port_offset;
1663 
1664  /*e \dref_RtpsWellKnownPorts_t_user_unicast_port_offset
1665  */
1666  DDS_Long user_unicast_port_offset;
1667 };
1668 
1669 #endif /* DOXYGEN_DOCUMENTATION_ONLY */
1670 
1671 #define DDS_RtpsWellKnownPorts_t DDS_RtpsWellKnownPorts
1672 
1673 /*i \dref_RtpsWellKnownPorts_DEFAULT
1674  */
1675 #define DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT \
1676 { \
1677  7400, /* port_base */ \
1678  250, /* domain_id_gain */ \
1679  2, /* participant_id_gain */ \
1680  0, /* builtin_multicast_port_offset */ \
1681  10, /* builtin_unicast_port_offset */ \
1682  1, /* user_multicast_port_offset */ \
1683  11 /* user_unicast_port_offset */ \
1684 }
1685 
1686 /*e \dref_WIREPROTOCOL_QOS_POLICY_NAME
1687  */
1688 extern DDSCDllVariable const char *const DDS_WIREPROTOCOL_QOS_POLICY_NAME;
1689 
1690 /* ----------------------------------------------------------------- */
1691 /*e \dref_WireProtocolQosPolicy
1692  */
1693 struct DDSCPPDllExport DDS_WireProtocolQosPolicy
1694 {
1695  /*e \dref_WireProtocolQosPolicy_participant_id
1696  */
1697  DDS_Long participant_id;
1698 
1699  /*e \dref_WireProtocolQosPolicy_rtps_host_id
1700  */
1701  DDS_UnsignedLong rtps_host_id;
1702 
1703  /*e \dref_WireProtocolQosPolicy_rtps_app_id
1704  */
1705  DDS_UnsignedLong rtps_app_id;
1706 
1707  /*e \dref_WireProtocolQosPolicy_rtps_instance_id
1708  */
1709  DDS_UnsignedLong rtps_instance_id;
1710 
1711  /*e \dref_WireProtocolQosPolicy_rtps_well_known_ports
1712  */
1713  struct DDS_RtpsWellKnownPorts_t rtps_well_known_ports;
1714 
1715  DDSC_CPP_QOS_POLICY_METHODS(DDS_WireProtocolQosPolicy)
1716 };
1717 
1718 /*e
1719  */
1720 enum
1721 {
1722  /*e \dref_WireProtocolQosPolicy_RTPS_AUTO_ID
1723  */
1724  DDS_RTPS_AUTO_ID = 0
1725 };
1726 
1727 /*i \dref_WireProtocolQosPolicy_DEFAULT
1728  */
1729 #define DDS_WIRE_PROTOCOL_QOS_POLICY_DEFAULT { \
1730 -1 /* auto participant_id */, \
1731 DDS_RTPS_AUTO_ID /* rtps_host_id */, \
1732 DDS_RTPS_AUTO_ID /* rtps_app_id */, \
1733 DDS_RTPS_AUTO_ID /* rtps_instance_id */, \
1734 DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT /* rtps_well_known_ports */\
1735 }
1736 
1737 DDSC_QOS_POLICY_METHODS_DECL(DDS_WireProtocolQosPolicy)
1738 
1739 /* ----------------------------------------------------------------- */
1740 
1741 /*i
1742  * Alias for DDS_Locator
1743  */
1744 #define DDS_Locator RTPS_Locator
1745 
1746 /*i
1747  * Alias for DDS_Locator_t
1748  */
1749 #define DDS_Locator_t RTPS_Locator_t
1750 
1751 /*i
1752  * Alias for DDS_LocatorUdpv4_t
1753  */
1754 #define DDS_LocatorUdpv4_t RTPS_LocatorUdpv4_t
1755 
1756 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1757 
1758 /*e \dref_Locator_t
1759  */
1760 struct DDS_Locator_t
1761 {
1762  /*e \dref_Locator_t_kind
1763  */
1764  DDS_Long kind;
1765 
1766  /*e \dref_Locator_t_port
1767  */
1768  DDS_UnsignedLong port;
1769 
1770  /*e \dref_Locator_t_address
1771  */
1772  DDS_Octet address[RTPS_LOCATOR_ADDRESS_LENGTH_MAX];
1773 };
1774 
1775 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1776 
1777 #define T struct RTPS_Locator
1778 #define TSeq DDS_LocatorSeq
1779 #define REDA_SEQUENCE_USER_API
1780 #define TSeq_is_equal
1781 #include <reda/reda_sequence_decl.h>
1782 
1783 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1784 /*e \dref_LocatorSeq
1785  */
1786 struct DDS_LocatorSeq {};
1787 #endif
1788 
1789 /*e
1790  * \dref_Locator_t_INVALID
1791  */
1792 #define DDS_LOCATOR_INVALID RTPS_LOCATOR_INVALID
1793 
1794 #ifndef RTI_CERT
1795 /*e
1796  * \dref_Locator_t_DEFAULT
1797  */
1798 #define DDS_LOCATOR_DEFAULT RTPS_LOCATOR_DEFAULT
1799 
1800 /*e
1801  * \dref_Locator_t_KIND_INVALID
1802  */
1803 #define DDS_LOCATOR_KIND_INVALID RTPS_LOCATOR_KIND_INVALID
1804 
1805 /*e
1806  * \dref_Locator_t_PORT_INVALID
1807  */
1808 #define DDS_LOCATOR_PORT_INVALID RTPS_LOCATOR_PORT_INVALID
1809 
1810 /*e
1811  * \dref_Locator_t_ADDRESS_INVALID
1812  */
1813 #define DDS_LOCATOR_ADDRESS_INVALID RTPS_LOCATOR_ADDRESS_INVALID
1814 
1815 #endif /* !RTI_CERT */
1816 
1817 
1818 /*e
1819  * \dref_Locator_t_KIND_UDPv4
1820  */
1821 #define DDS_LOCATOR_KIND_UDPv4 RTPS_LOCATOR_KIND_UDPv4
1822 
1823 /*e
1824  * \dref_Locator_t_KIND_UDPv6
1825  */
1826 #define DDS_LOCATOR_KIND_UDPv6 RTPS_LOCATOR_KIND_UDPv6
1827 
1828 /*e
1829  * \dref_Locator_t_KIND_RESERVED
1830  */
1831 #define DDS_LOCATOR_KIND_RESERVED RTPS_LOCATOR_KIND_RESERVED
1832 
1833 /*e
1834  * \dref_Locator_t_KIND_SHMEM
1835  */
1836 #define DDS_LOCATOR_KIND_SHMEM RTPS_LOCATOR_KIND_SHMEM
1837 
1838 /* ----------------------------------------------------------------- */
1839 
1840 /*e \dref_ProtocolVersion_t
1841  */
1842 typedef struct DDS_ProtocolVersion
1843 {
1844  /*e \dref_ProtocolVersion_t_major
1845  */
1846  DDS_Octet major;
1847 
1848  /*e \dref_ProtocolVersion_t_minor
1849  */
1850  DDS_Octet minor;
1851 } DDS_ProtocolVersion_t;
1852 
1853 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProtocolVersion);
1854 
1855 /*i \dref_ProtocolVersion_DEFAULT
1856  */
1857 #define DDS_PROTOCOL_VERSION_DEFAULT { 0, 0 }
1858 
1859 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_0
1860  */
1861 #define DDS_PROTOCOLVERSION_1_0 { 1, 0 }
1862 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_1
1863  */
1864 #define DDS_PROTOCOLVERSION_1_1 { 1, 1 }
1865 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_2
1866  */
1867 #define DDS_PROTOCOLVERSION_1_2 { 1, 2 }
1868 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1869  */
1870 #define DDS_PROTOCOLVERSION_2_0 { 2, 0 }
1871 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_2_1
1872  */
1873 #define DDS_PROTOCOLVERSION_2_1 { 2, 1 }
1874 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1875  */
1876 #define DDS_PROTOCOLVERSION { 2, 1 }
1877 
1878 /*e \dref_VendorId_t_LENGTH_MAX
1879  */
1880 #define DDS_VENDOR_ID_LENGTH_MAX 2
1881 
1882 /*e \dref_VendorId_t
1883  */
1884 struct DDS_VendorId
1885 {
1886  /*e \dref_VendorId_t_vendorId
1887  */
1888  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1889 };
1890 
1891 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1892 /*e \dref_VendorId_t
1893  */
1894 struct DDS_VendorId_t
1895 {
1896  /*e \dref_VendorId_t_vendorId
1897  */
1898  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1899 };
1900 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1901 
1902 
1903 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_VendorId);
1904 #define DDS_VendorId_t DDS_VendorId
1905 
1906 /*i \dref_VendorId_dEFAULT
1907  */
1908 #define DDS_VENDOR_ID_DEFAULT { {0, 0} }
1909 
1910 /*i \dref_VendorId_t_VENDORID_UNKNOWN
1911  */
1912 #define DDS_VENDORID_UNKNOWN { {0, 0} }
1913 
1914 /* ----------------------------------------------------------------- */
1915 
1916 /*e \dref_ProductVersion_t
1917  */
1918 struct DDS_ProductVersion
1919 {
1920  /*e \dref_ProductVersion_t_major
1921  */
1922  DDS_Char major;
1923 
1924  /*e \dref_ProductVersion_t_minor
1925  */
1926  DDS_Char minor;
1927 
1928  /*e \dref_ProductVersion_t_release
1929  */
1930  DDS_Char release;
1931 
1932  /*e \dref_ProductVersion_t_revision
1933  */
1934  DDS_Char revision;
1935 };
1936 
1937 
1938 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1939 /*e \dref_ProductVersion_t
1940  */
1941 struct DDS_ProductVersion_t
1942 {
1943  /*e \dref_ProductVersion_t_major
1944  */
1945  DDS_Char major;
1946  /*e \dref_ProductVersion_t_minor
1947  */
1948  DDS_Char minor;
1949  /*e \dref_ProductVersion_t_release
1950  */
1951  DDS_Char release;
1952  /*e \dref_ProductVersion_t_revision
1953  */
1954  DDS_Char revision;
1955 };
1956 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1957 
1958 #define DDS_ProductVersion_t DDS_ProductVersion
1959 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProductVersion);
1960 
1961 /*e \dref_ProductVersion_t_UNKNOWN
1962  */
1963 #define DDS_PRODUCTVERSION_UNKNOWN { 0, 0, '0', 0 }
1964 
1965 /*i \dref_ProductVersion_DEFAULT
1966  */
1967 #define DDS_PRODUCTVERSION_DEFAULT { 2, 0, 'c', 1 }
1968 
1969 #ifndef RTI_CERT
1970 
1971 /*e \dref_DomainParticipant_C_Library_get_version
1972  */
1973 DDSCDllExport const char*
1974 DDSC_Library_get_version(void);
1975 #endif
1976 
1977 /* ----------------------------------------------------------------- */
1978 /* DATA_READER_PROTOCOL_X (eXtension QoS) */
1979 /* ----------------------------------------------------------------- */
1980 /*e \dref_DataReaderProtocolQosGroupDocs
1981  */
1982 
1983 /*e \dref_DATAREADERPROTOCOL_QOS_POLICY_NAME
1984  */
1985 extern DDSCDllVariable const char *const DDS_DATAREADERPROTOCOL_QOS_POLICY_NAME;
1986 
1987 /* ----------------------------------------------------------------- */
1988 /*e \dref_DataReaderProtocolQosPolicy
1989  */
1990 struct DDSCPPDllExport DDS_DataReaderProtocolQosPolicy
1991 {
1992  /*e \dref_DataReaderProtocolQosPolicy_rtps_object_id
1993  */
1994  DDS_UnsignedLong rtps_object_id;
1995 
1996  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataReaderProtocolQosPolicy)
1997 };
1998 
1999 /*i \dref_DataReaderProtocolQosPolicy_DEFAULT
2000  */
2001 #define DDS_DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT \
2002 { \
2003  DDS_RTPS_AUTO_ID \
2004 }
2005 
2006 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataReaderProtocolQosPolicy)
2007 
2008 /* ----------------------------------------------------------------- */
2009 
2010 /*e \dref_RtpsReliableWriterProtocol_t
2011  */
2012  struct DDSCPPDllExport DDS_RtpsReliableWriterProtocol_t
2013  {
2014  /*e \dref_RtpsReliableWriterProtocol_t_heartbeat_period
2015  */
2016  struct DDS_Duration_t heartbeat_period;
2017 
2018  /*e \dref_RtpsReliableWriterProtocol_t_heartbeats_per_max_samples
2019  */
2020  DDS_Long heartbeats_per_max_samples;
2021 
2022  /*e \dref_RtpsReliableWriterProtocol_t_max_send_window
2023  */
2024  DDS_Long max_send_window;
2025 
2026  /*e \dref_RtpsReliableWriterProtocol_t_max_heartbeat_retries
2027  */
2028  DDS_Long max_heartbeat_retries;
2029 
2030  /*i \dref_RtpsReliableWriterProtocol_t_first_write_sequence_number
2031  */
2032  struct DDS_SequenceNumber_t first_write_sequence_number;
2033  };
2034 
2035 #define DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW (DDS_LENGTH_UNLIMITED)
2036 
2037 /*i \dref_RtpsReliableWriterProtocol_DEFAULT
2038  */
2039 #define DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT { \
2040  {3,0}, /* hb_period */ \
2041  1, /* hb_per_max_samples */ \
2042  DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW, /* max_send_window */ \
2043  DDS_LENGTH_UNLIMITED, /* max_heartbeat_retries */ \
2044  {0,1} /* first_write_sequence_number */\
2045 }
2046 
2047 /* ----------------------------------------------------------------- */
2048 /* DATA_WRITER_PROTOCOL_X (eXtension QoS) */
2049 /* ----------------------------------------------------------------- */
2050 /*e \dref_DataWriterProtocolQosGroupDocs
2051  */
2052 
2053 /*e \dref_DATAWRITERPROTOCOL_QOS_POLICY_NAME
2054  */
2055 extern DDSCDllVariable const char *const DDS_DATAWRITERPROTOCOL_QOS_POLICY_NAME;
2056 
2057 /* ----------------------------------------------------------------- */
2058 /*e \dref_DataWriterProtocolQosPolicy
2059  */
2060 struct DDSCPPDllExport DDS_DataWriterProtocolQosPolicy
2061 {
2062  /*e \dref_DataWriterProtocolQosPolicy_rtps_object_id
2063  */
2064  DDS_UnsignedLong rtps_object_id;
2065 
2066  /*e \dref_DataWriterProtocolQosPolicy_rtps_reliable_writer
2067  */
2068  struct DDS_RtpsReliableWriterProtocol_t rtps_reliable_writer;
2069 
2070  /*e \dref_DataWriterProtocolQosPolicy_serialize_on_write
2071  */
2072  DDS_Boolean serialize_on_write;
2073 
2074  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataWriterProtocolQosPolicy)
2075 };
2076 
2077 /*i \dref_DataWriterProtocolQosPolicy_DEFAULT
2078  */
2079 #define DDS_DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT \
2080 { DDS_RTPS_AUTO_ID, \
2081  DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT,\
2082  RTI_TRUE \
2083 }
2084 
2085 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataWriterProtocolQosPolicy)
2086 
2087 /* ----------------------------------------------------------------- */
2088 /* TRANSPORT_QOS_POLICY (eXtension QoS) */
2089 /* ----------------------------------------------------------------- */
2090 /*e \dref_TransportQosGroupDocs
2091  */
2092 
2093 /*e \dref_TRANSPORT_QOS_POLICY_NAME
2094  */
2095 extern DDSCDllVariable const char *const DDS_TRANSPORT_QOS_POLICY_NAME;
2096 
2097 /* ----------------------------------------------------------------- */
2098 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2099 /*i \dref_StringSeq
2100  */
2101 struct DDS_StringSeq {};
2102 #endif
2103 
2104 
2105 /*e \dref_TransportQosPolicy
2106  */
2107 struct DDSCPPDllExport DDS_TransportQosPolicy
2108 {
2109  /*e \dref_TransportQosPolicy_enabled_transports
2110  */
2111  struct DDS_StringSeq enabled_transports;
2112 
2113  DDSC_CPP_QOS_POLICY_METHODS(DDS_TransportQosPolicy)
2114 };
2115 
2116 /*i \dref_TransportQosPolicy_DEFAULT
2117  */
2118 #define DDS_TRANSPORT_QOS_POLICY_DEFAULT \
2119 {\
2120  DDS_SEQUENCE_INITIALIZER \
2121 }
2122 
2123 DDSC_QOS_POLICY_METHODS_DECL(DDS_TransportQosPolicy)
2124 
2125 /* ----------------------------------------------------------------- */
2126 /* DOMAIN_PARTICIPANT_RESOURCE_LIMITS_X (eXtension QoS) */
2127 /* ----------------------------------------------------------------- */
2128 /*e \dref_DomainParticipantResourceLimitsQosGroupDocs
2129  */
2130 
2131 /*e \dref_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME
2132  */
2133 extern DDSCDllVariable const char *const
2134  DDS_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME;
2135 
2136 /* ----------------------------------------------------------------- */
2137 
2138 /*e \dref_DomainParticipantResourceLimitsQosPolicy
2139  */
2140 struct DDSCPPDllExport DDS_DomainParticipantResourceLimitsQosPolicy
2141 {
2142  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_writer_allocation
2143  */
2144  DDS_Long local_writer_allocation;
2145 
2146  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_reader_allocation
2147  */
2148  DDS_Long local_reader_allocation;
2149 
2150  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_publisher_allocation
2151  */
2152  DDS_Long local_publisher_allocation;
2153 
2154  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_subscriber_allocation
2155  */
2156  DDS_Long local_subscriber_allocation;
2157 
2158  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_topic_allocation
2159  */
2160  DDS_Long local_topic_allocation;
2161 
2162  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_type_allocation
2163  */
2164  DDS_Long local_type_allocation;
2165 
2166  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_participant_allocation
2167  */
2168  DDS_Long remote_participant_allocation;
2169 
2170  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_writer_allocation
2171  */
2172  DDS_Long remote_writer_allocation;
2173 
2174  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_reader_allocation
2175  */
2176  DDS_Long remote_reader_allocation;
2177 
2178  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_writer_reader_pair_allocation
2179  */
2180  DDS_Long matching_writer_reader_pair_allocation;
2181 
2182  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_reader_writer_pair_allocation
2183  */
2184  DDS_Long matching_reader_writer_pair_allocation;
2185 
2186  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_receive_ports
2187  */
2188  DDS_Long max_receive_ports;
2189 
2190  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_destination_ports
2191  */
2192  DDS_Long max_destination_ports;
2193 
2194  DDSC_CPP_QOS_POLICY_METHODS(DDS_DomainParticipantResourceLimitsQosPolicy)
2195 };
2196 
2197 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2198  *
2199  * This constant is used below in
2200  * DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT; other types
2201  * should not use it alone.
2202  */
2203 #define DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT (32L)
2204 
2205 
2206 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2207  *
2208  * Several fields in this structure are actually never used. These fields
2209  * should be explicitly initialized when this structure is copied
2210  * from a lower layer structure to prevent the values from being left in
2211  * an uninitialized state. The unused fields include:
2212  *
2213  * - local_publisher_allocation.max_count
2214  * - local_subscriber_allocation.max_count
2215  * - local_topic_allocation.max_count
2216  * - matching_writer_reader_pair_allocation.initial_count
2217  * - matching_writer_reader_pair_allocation.max_count
2218  * - matching_reader_writer_pair_allocation.initial_count
2219  * - matching_reader_writer_pair_allocation.max_count
2220  */
2221 /*i \dref_DomainParticipantReasourceLimitsQosPolicy_DEFAULT
2222  */
2223 #define DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT \
2224 {1L, /*local_writer_allocation*/ \
2225  1L, /*local_reader_allocation*/ \
2226  1L, /*local_publisher_allocation*/ \
2227  1L, /*local_subscriber_allocation*/ \
2228  1L, /*local_topic_allocation*/ \
2229  1L, /*local_type_allocation*/ \
2230  1L, /*remote_participant_allocation*/ \
2231  1L, /*remote_writer_allocation*/ \
2232  1L, /*remote_reader_allocation*/ \
2233  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2234  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2235  8L,\
2236  8L \
2237 }
2238 
2239 DDSC_QOS_POLICY_METHODS_DECL(DDS_DomainParticipantResourceLimitsQosPolicy)
2240 
2241 /* ----------------------------------------------------------------- */
2242 
2243 /*i \dref_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH
2244  */
2245 #define DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH (4)
2246 
2247 /*e \dref_BuiltinTopicKey_t
2248  */
2249 typedef struct DDS_BuiltinTopicKey_t
2250 {
2251  /*e \dref_BuiltinTopicKey_t_value
2252  */
2253  DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE value[DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH];
2254 } DDS_BuiltinTopicKey_t;
2255 
2256 /*i @ingroup BuiltinTopicGroupDocs
2257  */
2258 #define DDS_BuiltinTopicKey_t_INITIALIZER { {0, 0, 0, 0} }
2259 
2260 /*e \dref_BuiltinTopicKey_t_AUTO
2261  */
2262 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_AUTO;
2263 
2264 /*e \dref_BuiltinTopicKey_t_UNKNOWN
2265  */
2266 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_UNKNOWN;
2267 
2268 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2269  */
2270 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_UNKNOWN;
2271 
2272 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2273  */
2274 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_AUTO;
2275 
2276 /*i \ingroup BuiltinTopicGroupDocs_equals
2277 */
2278 DDSCDllExport DDS_Boolean
2279 DDS_BuiltinTopicKey_equals(const DDS_BuiltinTopicKey_t *a,
2280  const DDS_BuiltinTopicKey_t *b);
2281 
2282 /*i \ingroup BuiltinTopicGroupDocs_prefix_equals
2283  */
2284 DDSCDllExport DDS_Boolean
2285 DDS_BuiltinTopicKey_prefix_equals(const DDS_BuiltinTopicKey_t *a,
2286  const DDS_BuiltinTopicKey_t *b);
2287 
2288 /*i \ingroup BuiltinTopicGroupDocs_suffix_equals
2289  */
2290 DDSCDllExport DDS_Boolean
2291 DDS_BuiltinTopicKey_suffix_equals(const DDS_BuiltinTopicKey_t *a,
2292  const DDS_BuiltinTopicKey_t *b);
2293 
2294 /*i \ingroup BuiltinTopicGroupDocs_copy_prefix
2295  */
2296 DDSCDllExport void
2297 DDS_BuiltinTopicKey_copy_prefix(DDS_BuiltinTopicKey_t *a,
2298  const DDS_BuiltinTopicKey_t *b);
2299 
2300 /*i \ingroup BuiltinTopicGroupDocs_copy_suffix
2301  */
2302 DDSCDllExport void
2303 DDS_BuiltinTopicKey_copy_suffix(DDS_BuiltinTopicKey_t *a,
2304  const DDS_BuiltinTopicKey_t *b);
2305 
2306 /*i \ingroup BuiltinTopicGroupDocs_from_guid
2307  */
2308 DDSCDllExport void
2309 DDS_BuiltinTopicKey_from_guid(DDS_BuiltinTopicKey_t *in,
2310  const DDS_InstanceHandle_t *out);
2311 /*ci
2312  * \brief Compare two DDS_BuiltinTopicKey_t structure for ordering
2313  *
2314  * \param[in] left Left side of comparison
2315  * \param[in] right Right side of comparison
2316  *
2317  * \return positive integer if left is greater than right,
2318  * negative integer if left is less than right,
2319  * zero if left is equal to right
2320  */
2321 DDSCDllExport DDS_Long
2322 DDS_BuiltinTopicKey_compare(const DDS_BuiltinTopicKey_t *left,
2323  const DDS_BuiltinTopicKey_t *right);
2324 
2325 /* ================================================================= */
2326 /* Condition and Waitsets */
2327 /* ================================================================= */
2328 
2329 /*ce \dref_Entity
2330  */
2331 typedef struct DDS_EntityImpl DDS_Entity;
2332 
2333 /* ----------------------------------------------------------------- */
2334 /*e \dref_ConditionsAndWaitsetsModuleDocs
2335  */
2336 
2337 /*ce \dref_Condition
2338  */
2339 typedef struct DDS_ConditionImpl DDS_Condition;
2340 
2341 /*ci @ingroup DDSConditionsModule
2342  @brief Pointer to DDS_Condition.
2343  */
2344 typedef struct DDS_ConditionImpl *DDS_Condition_ptr;
2345 
2346 /*ce \dref_ConditionSeq
2347  */
2348 #define T struct DDS_ConditionImpl*
2349 #ifndef RTI_CERT
2350 #define TSeq_ensure_length
2351 #define TSeq_has_ownership
2352 #endif
2353 #define TSeq DDS_ConditionSeq
2354 #include <reda/reda_sequence_decl.h>
2355 
2356 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2357 /*ce \dref_ConditionSeq
2358  */
2359 struct DDS_ConditionSeq {};
2360 #endif
2361 
2362 /*ce \dref_Condition_get_trigger_value
2363  */
2364 DDSCDllExport DDS_Boolean
2365 DDS_Condition_get_trigger_value(DDS_Condition *self);
2366 
2367 /*i \dref_Condition_set_wrapper
2368  */
2369 DDSCDllExport void
2370 DDS_ConditionImpl_set_wrapper(DDS_Condition *self, void *wrapper);
2371 
2372 /*i \dref_Condition_get_wrapper
2373  */
2374 DDSCDllExport void**
2375 DDS_ConditionImpl_get_wrapper_ref(DDS_Condition *self);
2376 
2377 /* ----------------------------------------------------------------- */
2378 
2379 /*ce \dref_GuardCondition
2380  */
2381 typedef struct DDS_GuardConditionImpl DDS_GuardCondition;
2382 
2383 #define DDS_GuardCondition_as_condition(guard_condition_ptr_) \
2384  ((DDS_Condition*) guard_condition_ptr_)
2385 
2386 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2387 /*ce \dref_GuardCondition_as_condition
2388  */
2389 DDS_Condition* DDS_GuardCondition_as_condition(DDS_GuardCondition* guard_cond);
2390 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2391 
2392 /*ce \dref_GuardCondition_new
2393  */
2394 DDSCDllExport DDS_GuardCondition*
2395 DDS_GuardCondition_new(void);
2396 
2397 #ifndef RTI_CERT
2398 /*ce \dref_GuardCondition_delete
2399  */
2400 DDSCDllExport DDS_ReturnCode_t
2401 DDS_GuardCondition_delete(DDS_GuardCondition *self);
2402 #endif
2403 
2404 /*ce \dref_GuardCondition_set_trigger_value
2405  */
2406 DDSCDllExport DDS_ReturnCode_t
2407 DDS_GuardCondition_set_trigger_value(DDS_GuardCondition *self,
2408  DDS_Boolean value);
2409 
2410 /* ----------------------------------------------------------------- */
2411 
2412 /*ce \dref_StatusCondition
2413  */
2414 typedef struct DDS_StatusConditionImpl DDS_StatusCondition;
2415 
2416 #define DDS_StatusCondition_as_condition(status_cond_ptr_) \
2417  ((DDS_Condition*) status_cond_ptr_)
2418 
2419 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2420 /*ce \dref_StatusCondition_as_condition
2421  */
2422 DDS_Condition* DDS_StatusCondition_as_condition(
2423  DDS_StatusCondition *statusCondition);
2424 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2425 
2426 
2427 /*ce \dref_StatusCondition_get_enabled_statuses
2428  */
2429 DDSCDllExport DDS_StatusMask
2430 DDS_StatusCondition_get_enabled_statuses(DDS_StatusCondition *self);
2431 
2432 /*ce \dref_StatusCondition_set_enabled_statuses
2433  */
2434 DDSCDllExport DDS_ReturnCode_t
2435 DDS_StatusCondition_set_enabled_statuses(DDS_StatusCondition *self,
2436  DDS_StatusMask mask);
2437 
2438 /*ce \dref_StatusCondition_get_entity
2439  */
2440 DDSCDllExport DDS_Entity*
2441 DDS_StatusCondition_get_entity(DDS_StatusCondition *self);
2442 
2443 /*ce \dref_WaitSet
2444  */
2445 typedef struct DDS_WaitSetImpl DDS_WaitSet;
2446 
2447 /*ce \dref_WaitSet_new
2448  */
2449 DDSCDllExport DDS_WaitSet*
2450 DDS_WaitSet_new(void);
2451 
2452 /*ce \dref_WaitSet_wait
2453  */
2454 DDSCDllExport DDS_ReturnCode_t
2455 DDS_WaitSet_wait(DDS_WaitSet *self,
2456  struct DDS_ConditionSeq *active_conditions,
2457  const struct DDS_Duration_t *timeout);
2458 
2459 /*ce \dref_WaitSet_attach_condition
2460  */
2461 DDSCDllExport DDS_ReturnCode_t
2462 DDS_WaitSet_attach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2463 
2464 #ifndef RTI_CERT
2465 /*ce \dref_WaitSet_delete
2466  */
2467 DDSCDllExport DDS_ReturnCode_t
2468 DDS_WaitSet_delete(DDS_WaitSet *self);
2469 #endif /* !RTI_CERT */
2470 
2471 #ifndef RTI_CERT
2472 /*ce \dref_WaitSet_detach_condition
2473  */
2474 DDSCDllExport DDS_ReturnCode_t
2475 DDS_WaitSet_detach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2476 #endif /* !RTI_CERT */
2477 
2478 
2479 /*ce \dref_WaitSet_get_conditions
2480  */
2481 DDSCDllExport DDS_ReturnCode_t
2482 DDS_WaitSet_get_conditions(DDS_WaitSet *self,
2483  struct DDS_ConditionSeq *attached_conditions);
2484 
2485 /* ================================================================= */
2486 /* Listeners */
2487 /* ================================================================= */
2488 /*e \dref_EntityModuleDocs
2489  */
2490 
2491 /*ce \dref_Listener
2492  */
2493 struct DDS_Listener
2494 {
2495  /*ce \dref_Listener_listener_data
2496  */
2497  void *listener_data;
2498 };
2499 
2500 /*ce \dref_Listener_INITIALIZER
2501  */
2502 #define DDS_Listener_INITIALIZER { NULL }
2503 
2504 /* ================================================================= */
2505 /* Entity typedef */
2506 /* ================================================================= */
2507 
2508 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2509 /*ce \dref_DomainEntity
2510  */
2511 typedef struct DDS_DomainEntityImpl DDS_DomainEntity;
2512 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
2513 
2514 /* ================================================================= */
2515 /* DDS_Entity */
2516 /* ================================================================= */
2517 
2518 /*ce \dref_Entity_enable
2519  */
2520 DDSCDllExport DDS_ReturnCode_t
2521 DDS_Entity_enable(DDS_Entity * self);
2522 
2523 /*ce \dref_Entity_is_enabled
2524  */
2525 DDSCDllExport DDS_Boolean
2526 DDS_Entity_is_enabled(DDS_Entity * self);
2527 
2528 /*ce \dref_Entity_get_instance_handle
2529  */
2530 DDSCDllExport DDS_InstanceHandle_t
2531 DDS_Entity_get_instance_handle(DDS_Entity * self);
2532 
2533 /*ce \dref_Entity_get_entity_kind
2534  */
2535 DDSCDllExport DDS_EntityKind_t
2536 DDS_Entity_get_entity_kind(DDS_Entity *self);
2537 
2538 /*ce \dref_Entity_get_statuscondition
2539  */
2540 DDSCDllExport DDS_StatusCondition*
2541 DDS_Entity_get_statuscondition(DDS_Entity *self);
2542 
2543 /*ce \dref_Entity_get_status_changes
2544  */
2545 DDSCDllExport DDS_StatusMask
2546 DDS_Entity_get_status_changes(DDS_Entity *self);
2547 
2548 /*ci
2549  * \brief Associate a language-dependent wrapper object with a DDS_Entity.
2550  *
2551  * \details
2552  * This operation is used to support access to the functionality of
2553  * the C implementation from other compatible programming languages, such as C++.
2554  * Implementations of the Micro API in these programming languages may use
2555  * this facility to associate objects created in their run-time environments
2556  * with DDS_Entity instances by means of this operation, and then access
2557  * them using DDS_Entity_get_wrapper, typically to support the correct
2558  * propagation of events from the C core to the wrapping programming language's
2559  * layer.
2560  *
2561  * \param[in] self a non NULL DDS_Entity
2562  * \param[in] wrapper pointer to a wrapper instance or NULL to delete an
2563  * existing association.
2564  */
2565 DDSCDllExport void
2566 DDS_Entity_set_wrapper(DDS_Entity *self, void *wrapper);
2567 
2568 /*ci
2569  * \brief Access a language-dependent wrapper object attached to the DDS_Entity.
2570  *
2571  * \long This operation is used to support access to the functionality of
2572  * the C implementation from other compatible programming languages, such as C++.
2573  * Implementations of the Micro API in these programming languages may use
2574  * this facility to associate objects created in their run-time environments
2575  * with DDS_Entity instances by means of DDS_Entity_set_wrapper, typically
2576  * to support the correct propagation of events from the C core to the wrapping
2577  * programming language's layer.
2578  *
2579  * \param[in] self a non NULL DDS_Entity
2580  *
2581  * \return a pointer to a wrapper object previously or NULL if none had been
2582  * previously set using DDS_Entity_set_wrapper.
2583  */
2584 DDSCDllExport void*
2585 DDS_Entity_get_wrapper(DDS_Entity *self);
2586 
2587 /* ----------------------------------------------------------------- */
2588 /* ENTITY_NAME */
2589 /* ----------------------------------------------------------------- */
2590 /*e \dref_EntityNameQosGroupDocs
2591  */
2592 
2593 /*e \dref_ENTITYNAME_QOS_POLICY_NAME
2594  */
2595 extern DDSCDllVariable const char *const DDS_ENTITYNAME_QOS_POLICY_NAME;
2596 
2597 /*e \dref_AUTO_NAME_ENTITY
2598  */
2599 extern DDSCDllVariable const char *const DDS_AUTO_NAME_ENTITY;
2600 
2601 /* ----------------------------------------------------------------- */
2602 /*e \dref_EntityNameQosPolicy_NAME_MAX
2603  */
2604 #define DDS_ENTITYNAME_QOS_NAME_MAX 255
2605 
2606 #ifdef RTI_WIN32
2607 #pragma warning(push)
2608 #pragma warning(disable: 4522)
2609 #endif
2610 
2611 /*e \dref_EntityNameQosPolicy
2612  */
2613 struct DDSCPPDllExport DDS_EntityNameQosPolicy
2614 {
2615  /*e \dref_EntityNameQosPolicy_name
2616  */
2617  char name[DDS_ENTITYNAME_QOS_NAME_MAX + 1];
2618 
2619  DDSC_CPP_QOS_POLICY_METHODS(DDS_EntityNameQosPolicy)
2620 
2621 #ifdef RTI_CPP
2622 public:
2623  bool set_name(const char *const name);
2624 #ifdef RTI_CERT
2625  private:
2626 #else
2627  public:
2628 #endif
2629  DDS_EntityNameQosPolicy& operator=(const char *const name);
2630  DDS_EntityNameQosPolicy& operator=(const DDS_EntityNameQosPolicy& from);
2631  const DDS_EntityNameQosPolicy& operator=(const DDS_EntityNameQosPolicy& from) const;
2632  bool operator==(const DDS_EntityNameQosPolicy& other) const;
2633  bool operator==(const char *const name) const;
2634  bool operator!=(const DDS_EntityNameQosPolicy& other) const;
2635  bool operator!=(const char *const name) const;
2636 #endif
2637 };
2638 
2639 #ifdef RTI_WIN32
2640 #pragma warning(pop)
2641 #endif
2642 
2643 /*i \dref_EntityNameQosPolicy_DEFAULT
2644  */
2645 #define DDS_ENTITY_NAME_QOS_POLICY_DEFAULT { {'\0'} }
2646 
2647 DDSC_QOS_POLICY_METHODS_DECL(DDS_EntityNameQosPolicy)
2648 
2649 /*e \dref_EntityNameQosPolicy_set_name
2650  */
2651 DDSCDllExport DDS_Boolean
2652 DDS_EntityNameQosPolicy_set_name(struct DDS_EntityNameQosPolicy *const self,
2653  const char *const name);
2654 
2655 /* ================================================================= */
2656 /* RTI_Management */
2657 /* ================================================================= */
2658 
2659 /*i \dref_ManagementQosPolicy
2660  */
2661 struct DDSCPPDllExport RTI_ManagementQosPolicy
2662 {
2663  DDS_Boolean is_hidden;
2664  DDS_Boolean is_anonymous;
2665  DDS_Boolean disable_unregister_dispose_for_unpublished_instance;
2666 
2667  DDSC_CPP_QOS_POLICY_METHODS(RTI_ManagementQosPolicy)
2668 };
2669 
2670 /*i \dref_ManagementQosPolicy_DEFAULT
2671  */
2672 #define RTI_MANAGEMENT_QOS_POLICY_DEFAULT { \
2673  DDS_BOOLEAN_FALSE,\
2674  DDS_BOOLEAN_FALSE, \
2675  DDS_BOOLEAN_FALSE \
2676 }
2677 
2678 DDSC_QOS_POLICY_METHODS_DECL(RTI_ManagementQosPolicy)
2679 
2680 /* ================================================================= */
2681 /* DDS_DomainEntity */
2682 /* ================================================================= */
2683 
2684 /*ce \dref_DomainParticipant
2685  */
2686 typedef struct DDS_DomainParticipantImpl DDS_DomainParticipant;
2687 
2688 /* ----------------------------------------------------------------- */
2689 
2690 /* ================================================================= */
2691 /* DDSHST_History */
2692 /* ================================================================= */
2693 /*i \dref_DDSHST_ReturnCode_T
2694  */
2695 typedef enum
2696 {
2697  DDSHST_RETCODE_ERROR = -1000,
2698  DDSHST_RETCODE_NOSPACE,
2699  DDSHST_RETCODE_EXISTS,
2700  DDSHST_RETCODE_NOT_EXISTS,
2701  DDSHST_RETCODE_INVALID_PROPERTY,
2702  DDSHST_RETCODE_INVALID_ENTRY_REQUEST,
2703  DDSHST_RETCODE_NOT_SUPPORTED,
2704  DDSHST_RETCODE_SUCCESS = 0
2705 } DDSHST_ReturnCode_T;
2706 
2707 /*i \dref_ReplacePolicyKind_T
2708  */
2709 typedef enum
2710 {
2711  DDSHST_REPLACE_POLICY_KIND_OLDEST,
2712  DDSHST_REPLACE_POLICY_KIND_NONE
2713 } DDSHST_ReplacePolicyKind_T;
2714 
2715 
2716 /* ----------------------------------------------------------------- */
2717 /* WRITE_PARAMS */
2718 /* ----------------------------------------------------------------- */
2719 
2720 /*e \dref_SampleIdentity_t
2721  */
2722 struct DDSCPPDllExport DDS_SampleIdentity_t
2723 {
2724  /*e \dref_SampleIdentity_t_writer_guid */
2725  struct DDS_GUID_t writer_guid;
2726  /*e \dref_SampleIdentity_t_sequence_number */
2727  struct DDS_SequenceNumber_t sequence_number;
2728 
2729  DDSC_CPP_QOS_POLICY_METHODS(DDS_SampleIdentity_t)
2730 };
2731 
2732 
2733 /*ci \dref_SampleIdentity_t
2734  */
2735 #define DDS_SAMPLE_IDENTITY_UNKNOWN \
2736 { \
2737  DDS_GUID_INITIALIZER, \
2738  DDS_SEQUENCE_NUMBER_UNKNOWN \
2739 }
2740 
2741 /*e \dref_WriteParams_t
2742  */
2743 struct DDSCPPDllExport DDS_WriteParams_t
2744 {
2745  /*i \dref_WriteParams_t_identity
2746  */
2747  struct DDS_SampleIdentity_t identity;
2748 
2749  /*i \dref_WriteParams_t_related_sample_identity
2750  */
2751  struct DDS_SampleIdentity_t related_sample_identity;
2752 
2753  /*e \dref_WriteParams_t_source_timestamp
2754  */
2755  struct DDS_Time_t source_timestamp;
2756 
2757  /*e \dref_WriteParams_t_handle
2758  */
2759  DDS_InstanceHandle_t handle;
2760 
2761  DDSC_CPP_QOS_POLICY_METHODS(DDS_WriteParams_t)
2762 };
2763 
2764 /*e \dref_WriteParams_t_DEFAULT
2765  */
2766 #define DDS_WRITEPARAMS_DEFAULT \
2767 { \
2768  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2769  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2770  DDS_TIME_ZERO, \
2771  DDS_HANDLE_NIL_NATIVE \
2772 }
2773 
2774 /* ================================================================= */
2775 /* DDS Properties */
2776 /* ================================================================= */
2777 /* NOTE:
2778  * DDS_PropertySeq is not exposed as a general purpose property
2779  * sequence. It is only used to send required properties for RTI Tools.
2780  * Thus, although the generic sequence type is used to implement the property
2781  * sequence, its internal use is highly specialized and only a limited
2782  * number of functions are exposed.
2783  */
2784 #define DDS_PropertySeq CDR_PropertySeq
2785 #define DDS_Property CDR_Property
2786 #define DDS_PropertySeq_initialize CDR_PropertySeq_initialize
2787 #define DDS_PropertySeq_set_length CDR_PropertySeq_set_length
2788 #define DDS_PropertySeq_get_length CDR_PropertySeq_get_length
2789 #define DDS_PropertySeq_get_reference CDR_PropertySeq_get_reference
2790 
2791 /*ci
2792  * \brief Get pointer to the DDS participant properties
2793  *
2794  * \details
2795  * The DDS domain participant may send additional information as properties
2796  * in the participant announcement. Typically this is used by discovery plugins
2797  * to serialize the information.
2798  *
2799  * \param[in] self Participant to get properties for
2800  *
2801  * \return A sequence with 0 or more properties on success, NULL if no
2802  * sequence exists.
2803  */
2804 DDSCDllExport struct DDS_PropertySeq*
2805 DDS_DomainParticipant_get_dds_properties(DDS_DomainParticipant *self);
2806 
2807 
2808 /*ci
2809  * \brief Query the domain-participant if the specified locator is supported
2810  *
2811  * \param[in] self Participant to query
2812  *
2813  * \return DDS_BOOLEAN_TRUE if the locator is supported, DDS_BOOLEEAN_FALSE
2814  * otherwise.
2815  */
2816 DDSCDllExport DDS_Boolean
2817 DDS_DomainParticipant_locator_is_supported(DDS_DomainParticipant *self,
2818  struct DDS_Locator *locator);
2819 
2820 #ifdef __cplusplus
2821 } /* extern "C" */
2822 #endif
2823 
2824 #endif /* dds_c_infrastructure_h */
RTI Connext DDS Micro Version 2.4.10 Copyright © Fri Jun 30 2017 Real-Time Innovations, Inc