RTI Connext DDS Micro  Version 2.4.11
 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  /*e \dref_LivelinessQosPolicyKind_AUTOMATIC_LIVELINESS_QOS
1117  */
1118  DDS_AUTOMATIC_LIVELINESS_QOS,
1119 
1120  /*e \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 /* PRESENTATION */
1362 /* ----------------------------------------------------------------- */
1363 /*i \dref_PresentationQosGroupDocs
1364  */
1365 /* ----------------------------------------------------------------- */
1366 /*i \dref_PresentationQosPolicyAccessScopeKind
1367  */
1368 typedef enum
1369 {
1370  /*i \dref_PresentationQosPolicyAccessScopeKind_INSTANCE_PRESENTATION_QOS
1371  */
1372  DDS_INSTANCE_PRESENTATION_QOS,
1373 
1374  /*i \dref_PresentationQosPolicyAccessScopeKind_TOPIC_PRESENTATION_QOS
1375  */
1376  DDS_TOPIC_PRESENTATION_QOS,
1377 
1378  /*i \dref_PresentationQosPolicyAccessScopeKind_GROUP_PRESENTATION_QOS
1379  */
1380  DDS_GROUP_PRESENTATION_QOS,
1381 
1382  /*i \dref_PresentationQosPolicyAccessScopeKind_HIGHEST_OFFERED_PRESENTATION_QOS
1383  */
1384  DDS_HIGHEST_OFFERED_PRESENTATION_QOS
1385 } DDS_PresentationQosPolicyAccessScopeKind;
1386 
1387 /* ----------------------------------------------------------------- */
1388 /*i \dref_PresentationQosPolicy
1389  */
1390 struct DDS_PresentationQosPolicy
1391 {
1392  /*i \dref_PresentationQosPolicy_access_scope
1393  */
1394  DDS_PresentationQosPolicyAccessScopeKind access_scope;
1395 
1396  /*i \dref_PresentationQosPolicy_coherent_access
1397  */
1398  DDS_Boolean coherent_access;
1399 
1400  /*i \dref_PresentationQosPolicy_ordered_access
1401  */
1402  DDS_Boolean ordered_access;
1403 
1404  DDSC_CPP_QOS_POLICY_METHODS(DDS_PresentationQosPolicy)
1405 };
1406 
1407 /*i \dref_PresentationQosPolicy_DEFAULT
1408  */
1409 #define DDS_PRESENTATION_QOS_POLICY_DEFAULT \
1410 { DDS_INSTANCE_PRESENTATION_QOS, DDS_BOOLEAN_FALSE, DDS_BOOLEAN_FALSE }
1411 
1412 DDSC_QOS_POLICY_METHODS_DECL(DDS_PresentationQosPolicy)
1413 
1414 
1415 /* ----------------------------------------------------------------- */
1416 /* DESTINATION_ORDER */
1417 /* ----------------------------------------------------------------- */
1418 /*e \dref_DestinationOrderQosGroupDocs
1419  */
1420 /*e \dref_DestinationOrderPolicyKind
1421 */
1422 typedef enum
1423 {
1424  /*e \dref_DestinationOrderPolicyKind_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS
1425  */
1426  DDS_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,
1427 
1428  /*e \dref_DestinationOrderPolicyKind_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
1429  */
1430  DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
1431 } DDS_DestinationOrderQosPolicyKind;
1432 
1433 /*e \dref_DestinationOrderQosPolicy
1434  */
1435 struct DDSCPPDllExport DDS_DestinationOrderQosPolicy
1436 {
1437  /*e \dref_DestinationOrderQosPolicy_kind
1438  */
1439  DDS_DestinationOrderQosPolicyKind kind;
1440 
1441  /*e \dref_DestinationOrderQosPolicy_source_timestamp_tolerance
1442  */
1443  struct DDS_Duration_t source_timestamp_tolerance;
1444 
1445  DDSC_CPP_QOS_POLICY_METHODS(DDS_DestinationOrderQosPolicy)
1446 };
1447 
1448 /*i \dref_DestinationOrderQosPolicy_DEFAULT
1449  */
1450 #define DDS_DESTINATION_ORDER_QOS_POLICY_DEFAULT \
1451 { \
1452  DDS_BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS, \
1453  {0,100000000} \
1454 }
1455 
1456 DDSC_QOS_POLICY_METHODS_DECL(DDS_DestinationOrderQosPolicy)
1457 
1458 /* ----------------------------------------------------------------- */
1459 /*e \dref_DataReaderResourceLimitsInstanceReplacementKind
1460 */
1461 typedef enum
1462 {
1463  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_NO_INSTANCE_REPLACEMENT_QOS
1464  */
1465  DDS_NO_INSTANCE_REPLACEMENT_QOS,
1466 
1467  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1468  */
1469  DDS_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1470 } DDS_DataReaderResourceLimitsInstanceReplacementKind;
1471 
1472 /* ----------------------------------------------------------------- */
1473 /* DATAREADER_RESOURCE_LIMITS */
1474 /* ----------------------------------------------------------------- */
1475 /*e \dref_DataReaderResourceLimitsQosGroupDocs
1476  */
1477 
1478 /*e \dref_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME
1479  */
1480 extern DDSCDllVariable const char *const
1481  DDS_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME;
1482 
1483 /* ----------------------------------------------------------------- */
1484 /*e \dref_DataReaderResourceLimitsQosPolicy
1485  */
1486 struct DDSCPPDllExport DDS_DataReaderResourceLimitsQosPolicy
1487 {
1488  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers
1489  */
1490  DDS_Long max_remote_writers;
1491 
1492  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers_per_instance
1493  */
1494  DDS_Long max_remote_writers_per_instance;
1495 
1496  /*e \dref_DataReaderResourceLimitsQosPolicy_max_samples_per_remote_writer
1497  */
1498  DDS_Long max_samples_per_remote_writer;
1499 
1500  /*e \dref_DataReaderResourceLimitsQosPolicy_max_outstanding_reads
1501  */
1502  DDS_Long max_outstanding_reads;
1503 
1504  /*e \dref_DataReaderResourceLimitsQosPolicy_instance_replacement
1505  */
1506  DDS_DataReaderResourceLimitsInstanceReplacementKind instance_replacement;
1507 
1508  /*e \dref_DataReaderResourceLimitsQosPolicy_max_routes_per_writer
1509  */
1510  DDS_Long max_routes_per_writer;
1511 
1512  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataReaderResourceLimitsQosPolicy)
1513 };
1514 
1515 /*i \dref_DataReaderResourceLimitsQosPolicy_DEFAULT
1516  */
1517 #define DDS_DATAREADERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1518  1L, /* max_remote_writers */ \
1519  1L, /* max_remote_writers_per_instance */ \
1520  1L, /* max_samples_per_remote_writer */ \
1521  1L, /* max_outstanding_reads */ \
1522  DDS_NO_INSTANCE_REPLACEMENT_QOS, /* Default */ \
1523  4\
1524 }
1525 
1526 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataReaderResourceLimitsQosPolicy)
1527 
1528 /* ----------------------------------------------------------------- */
1529 /* DATAWRITER_RESOURCE_LIMITS */
1530 /* ----------------------------------------------------------------- */
1531 /*e \dref_DataWriterResourceLimitsQosGroupDocs
1532  */
1533 
1534 /*e \dref_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME
1535  */
1536 extern DDSCDllVariable const char *const
1537  DDS_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME;
1538 
1539 /* ----------------------------------------------------------------- */
1540 /*e \dref_DataWriterResourceLimitsQosPolicy
1541  */
1542 struct DDSCPPDllExport DDS_DataWriterResourceLimitsQosPolicy
1543 {
1544  /*e \dref_DataWriterResourceLimitsQosPolicy_max_remote_readers
1545  */
1546  DDS_Long max_remote_readers;
1547 
1548  /*e \dref_DataWriterResourceLimitsQosPolicy_max_routes_per_reader
1549  */
1550  DDS_Long max_routes_per_reader;
1551 
1552  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataWriterResourceLimitsQosPolicy)
1553 };
1554 
1555 /*i \dref_DataWriterResourceLimitsQosPolicy_DEFAULT
1556  */
1557 #define DDS_DATAWRITERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1558  16L, /* max_remote_readers */ \
1559  4\
1560 }
1561 
1562 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataWriterResourceLimitsQosPolicy)
1563 
1564 /* ----------------------------------------------------------------- */
1565 /* ENTITY_FACTORY */
1566 /* ----------------------------------------------------------------- */
1567 /*e \dref_EntityFactoryQosGroupDocs
1568  */
1569 
1570 /*e \dref_ENTITYFACTORY_QOS_POLICY_NAME
1571  */
1572 extern DDSCDllVariable const char *const DDS_ENTITYFACTORY_QOS_POLICY_NAME;
1573 
1574 /* ----------------------------------------------------------------- */
1575 /*e \dref_EntityFactoryQosPolicy
1576  */
1577 struct DDSCPPDllExport DDS_EntityFactoryQosPolicy
1578 {
1579  /*e \dref_EntityFactoryQosPolicy_autoenable_created_entities
1580  */
1581  DDS_Boolean autoenable_created_entities;
1582 
1583  DDSC_CPP_QOS_POLICY_METHODS(DDS_EntityFactoryQosPolicy)
1584 };
1585 
1586 /*i \dref_EntityFactoryQosPolicy_DEFAULT
1587  */
1588 #define DDS_ENTITY_FACTORY_QOS_POLICY_DEFAULT { DDS_BOOLEAN_TRUE }
1589 
1590 DDSC_QOS_POLICY_METHODS_DECL(DDS_EntityFactoryQosPolicy);
1591 
1592 /* ----------------------------------------------------------------- */
1593 /* EXTENDED QOS SUPPORT */
1594 /* ----------------------------------------------------------------- */
1595 
1596 /* ----------------------------------------------------------------- */
1597 /*e
1598  * \dref_ExtendedQosSupportGroupDocs
1599  */
1600 #define DDS_LENGTH_UNLIMITED (-1)
1601 
1602 #define DDS_LENGTH_AUTO (-2)
1603 
1604 /* ----------------------------------------------------------------- */
1605 
1606 /* ----------------------------------------------------------------- */
1607 /* TYPESUPPORT */
1608 /* ----------------------------------------------------------------- */
1609 /*i \dref_TypeSupportQosGroupDocs
1610 */
1611 
1612 /*i \dref_TYPESUPPORT_QOS_POLICY_NAME
1613  */
1614 extern DDSCDllVariable const char *const DDS_TYPESUPPORT_QOS_POLICY_NAME;
1615 
1616 /* ----------------------------------------------------------------- */
1617 /*i \dref_TypeSupportQosPolicy
1618  */
1619 struct DDSCPPDllExport DDS_TypeSupportQosPolicy
1620 {
1621  /*e \dref_TypeSupportQosPolicy_plugin_data
1622  */
1623  void *plugin_data;
1624 
1625  DDSC_CPP_QOS_POLICY_METHODS(DDS_TypeSupportQosPolicy)
1626 };
1627 
1628 /*i \dref_TypeSupportQosPolicy_DEFAULT
1629  */
1630 #define DDS_TYPESUPPORT_QOS_POLICY_DEFAULT \
1631 { NULL }
1632 
1633 DDSC_QOS_POLICY_METHODS_DECL(DDS_TypeSupportQosPolicy)
1634 
1635 /* ----------------------------------------------------------------- */
1636 /* SYSTEM_RESOURCE_LIMITS_X (eXtension QoS) */
1637 /* ----------------------------------------------------------------- */
1638 /*e \dref_SystemResourceLimitsQosGroupDocs
1639  */
1640 
1641 /*e \dref_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME
1642  */
1643 extern DDSCDllVariable const char *const DDS_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME;
1644 
1645 /* ----------------------------------------------------------------- */
1646 
1647 /*e \dref_SystemResourceLimitsQosPolicy
1648  */
1649 struct DDSCPPDllExport DDS_SystemResourceLimitsQosPolicy
1650 {
1651  /*e \dref_SystemResourceLimitsQosPolicy_max_participants
1652  */
1653  DDS_Long max_participants;
1654 
1655  /*e \dref_SystemResourceLimitsQosPolicy_max_components
1656  */
1657  DDS_Long max_components;
1658 
1659  DDSC_CPP_QOS_POLICY_METHODS(DDS_SystemResourceLimitsQosPolicy)
1660 };
1661 
1662 /*i \dref_SystemResourceLimitsQosPolicy_DEFAULT
1663  */
1664 #if UDP_TRANSFORMS_ENABLED
1665 #define DDS_SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { 1L,64L }
1666 #else
1667 #define DDS_SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { 1L,16L }
1668 #endif /* UDP_TRANSFORMS_ENABLED */
1669 
1670 DDSC_QOS_POLICY_METHODS_DECL(DDS_SystemResourceLimitsQosPolicy)
1671 
1672 /* ----------------------------------------------------------------- */
1673 /* WIRE_PROTOCOL_X (eXtension QoS) */
1674 /* ----------------------------------------------------------------- */
1675 /*e \dref_WireProtocolQosGroupDocs
1676  */
1677 
1678 #define DDS_RtpsWellKnownPorts NETIO_RtpsPortParam
1679 
1680 /*e \dref_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS
1681  */
1682 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1683  DDS_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS;
1684 
1685 /*e \dref_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS
1686  */
1687 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1688  DDS_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS;
1689 
1690 /*i @ingroup DDSWireProtocolQosModule
1691  these defaults are compatible with >= 4.2d
1692  */
1693 
1694 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1695 /*e \dref_RtpsWellKnownPorts_t
1696  */
1697 struct DDS_RtpsWellKnownPorts_t
1698 {
1699  /*e \dref_RtpsWellKnownPorts_t_port_base
1700  */
1701  DDS_Long port_base;
1702 
1703  /*e \dref_RtpsWellKnownPorts_t_domain_id_gain
1704  */
1705  DDS_Long domain_id_gain;
1706 
1707  /*e \dref_RtpsWellKnownPorts_t_participant_id_gain
1708  */
1709  DDS_Long participant_id_gain;
1710 
1711  /*e \dref_RtpsWellKnownPorts_t_builtin_multicast_port_offset
1712  */
1713  DDS_Long builtin_multicast_port_offset;
1714 
1715  /*e \dref_RtpsWellKnownPorts_t_builtin_unicast_port_offset
1716  */
1717  DDS_Long builtin_unicast_port_offset;
1718 
1719  /*e \dref_RtpsWellKnownPorts_t_user_multicast_port_offset
1720  */
1721  DDS_Long user_multicast_port_offset;
1722 
1723  /*e \dref_RtpsWellKnownPorts_t_user_unicast_port_offset
1724  */
1725  DDS_Long user_unicast_port_offset;
1726 };
1727 
1728 #endif /* DOXYGEN_DOCUMENTATION_ONLY */
1729 
1730 #define DDS_RtpsWellKnownPorts_t DDS_RtpsWellKnownPorts
1731 
1732 /*i \dref_RtpsWellKnownPorts_DEFAULT
1733  */
1734 #define DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT \
1735 { \
1736  7400, /* port_base */ \
1737  250, /* domain_id_gain */ \
1738  2, /* participant_id_gain */ \
1739  0, /* builtin_multicast_port_offset */ \
1740  10, /* builtin_unicast_port_offset */ \
1741  1, /* user_multicast_port_offset */ \
1742  11 /* user_unicast_port_offset */ \
1743 }
1744 
1745 /*e \dref_WIREPROTOCOL_QOS_POLICY_NAME
1746  */
1747 extern DDSCDllVariable const char *const DDS_WIREPROTOCOL_QOS_POLICY_NAME;
1748 
1749 /* ----------------------------------------------------------------- */
1750 /*e \dref_WireProtocolQosPolicy
1751  */
1752 struct DDSCPPDllExport DDS_WireProtocolQosPolicy
1753 {
1754  /*e \dref_WireProtocolQosPolicy_participant_id
1755  */
1756  DDS_Long participant_id;
1757 
1758  /*e \dref_WireProtocolQosPolicy_rtps_host_id
1759  */
1760  DDS_UnsignedLong rtps_host_id;
1761 
1762  /*e \dref_WireProtocolQosPolicy_rtps_app_id
1763  */
1764  DDS_UnsignedLong rtps_app_id;
1765 
1766  /*e \dref_WireProtocolQosPolicy_rtps_instance_id
1767  */
1768  DDS_UnsignedLong rtps_instance_id;
1769 
1770  /*e \dref_WireProtocolQosPolicy_rtps_well_known_ports
1771  */
1772  struct DDS_RtpsWellKnownPorts_t rtps_well_known_ports;
1773 
1774  DDSC_CPP_QOS_POLICY_METHODS(DDS_WireProtocolQosPolicy)
1775 };
1776 
1777 /*e
1778  */
1779 enum
1780 {
1781  /*e \dref_WireProtocolQosPolicy_RTPS_AUTO_ID
1782  */
1783  DDS_RTPS_AUTO_ID = 0
1784 };
1785 
1786 /*i \dref_WireProtocolQosPolicy_DEFAULT
1787  */
1788 #define DDS_WIRE_PROTOCOL_QOS_POLICY_DEFAULT { \
1789 -1 /* auto participant_id */, \
1790 DDS_RTPS_AUTO_ID /* rtps_host_id */, \
1791 DDS_RTPS_AUTO_ID /* rtps_app_id */, \
1792 DDS_RTPS_AUTO_ID /* rtps_instance_id */, \
1793 DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT /* rtps_well_known_ports */\
1794 }
1795 
1796 DDSC_QOS_POLICY_METHODS_DECL(DDS_WireProtocolQosPolicy)
1797 
1798 /* ----------------------------------------------------------------- */
1799 
1800 /*i
1801  * Alias for DDS_Locator
1802  */
1803 #define DDS_Locator RTPS_Locator
1804 
1805 /*i
1806  * Alias for DDS_Locator_t
1807  */
1808 #define DDS_Locator_t RTPS_Locator_t
1809 
1810 /*i
1811  * Alias for DDS_LocatorUdpv4_t
1812  */
1813 #define DDS_LocatorUdpv4_t RTPS_LocatorUdpv4_t
1814 
1815 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1816 
1817 /*e \dref_Locator_t
1818  */
1819 struct DDS_Locator_t
1820 {
1821  /*e \dref_Locator_t_kind
1822  */
1823  DDS_Long kind;
1824 
1825  /*e \dref_Locator_t_port
1826  */
1827  DDS_UnsignedLong port;
1828 
1829  /*e \dref_Locator_t_address
1830  */
1831  DDS_Octet address[RTPS_LOCATOR_ADDRESS_LENGTH_MAX];
1832 };
1833 
1834 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1835 
1836 #define T struct RTPS_Locator
1837 #define TSeq DDS_LocatorSeq
1838 #define REDA_SEQUENCE_USER_API
1839 #define TSeq_is_equal
1840 #include <reda/reda_sequence_decl.h>
1841 
1842 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1843 /*e \dref_LocatorSeq
1844  */
1845 struct DDS_LocatorSeq {};
1846 #endif
1847 
1848 /*e
1849  * \dref_Locator_t_INVALID
1850  */
1851 #define DDS_LOCATOR_INVALID RTPS_LOCATOR_INVALID
1852 
1853 #ifndef RTI_CERT
1854 /*e
1855  * \dref_Locator_t_DEFAULT
1856  */
1857 #define DDS_LOCATOR_DEFAULT RTPS_LOCATOR_DEFAULT
1858 
1859 /*e
1860  * \dref_Locator_t_KIND_INVALID
1861  */
1862 #define DDS_LOCATOR_KIND_INVALID RTPS_LOCATOR_KIND_INVALID
1863 
1864 /*e
1865  * \dref_Locator_t_PORT_INVALID
1866  */
1867 #define DDS_LOCATOR_PORT_INVALID RTPS_LOCATOR_PORT_INVALID
1868 
1869 /*e
1870  * \dref_Locator_t_ADDRESS_INVALID
1871  */
1872 #define DDS_LOCATOR_ADDRESS_INVALID RTPS_LOCATOR_ADDRESS_INVALID
1873 
1874 #endif /* !RTI_CERT */
1875 
1876 
1877 /*e
1878  * \dref_Locator_t_KIND_UDPv4
1879  */
1880 #define DDS_LOCATOR_KIND_UDPv4 RTPS_LOCATOR_KIND_UDPv4
1881 
1882 /*e
1883  * \dref_Locator_t_KIND_UDPv6
1884  */
1885 #define DDS_LOCATOR_KIND_UDPv6 RTPS_LOCATOR_KIND_UDPv6
1886 
1887 /*e
1888  * \dref_Locator_t_KIND_RESERVED
1889  */
1890 #define DDS_LOCATOR_KIND_RESERVED RTPS_LOCATOR_KIND_RESERVED
1891 
1892 /*e
1893  * \dref_Locator_t_KIND_SHMEM
1894  */
1895 #define DDS_LOCATOR_KIND_SHMEM RTPS_LOCATOR_KIND_SHMEM
1896 
1897 /* ----------------------------------------------------------------- */
1898 
1899 /*e \dref_ProtocolVersion_t
1900  */
1901 typedef struct DDS_ProtocolVersion
1902 {
1903  /*e \dref_ProtocolVersion_t_major
1904  */
1905  DDS_Octet major;
1906 
1907  /*e \dref_ProtocolVersion_t_minor
1908  */
1909  DDS_Octet minor;
1910 } DDS_ProtocolVersion_t;
1911 
1912 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProtocolVersion);
1913 
1914 /*i \dref_ProtocolVersion_DEFAULT
1915  */
1916 #define DDS_PROTOCOL_VERSION_DEFAULT { 0, 0 }
1917 
1918 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_0
1919  */
1920 #define DDS_PROTOCOLVERSION_1_0 { 1, 0 }
1921 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_1
1922  */
1923 #define DDS_PROTOCOLVERSION_1_1 { 1, 1 }
1924 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_2
1925  */
1926 #define DDS_PROTOCOLVERSION_1_2 { 1, 2 }
1927 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1928  */
1929 #define DDS_PROTOCOLVERSION_2_0 { 2, 0 }
1930 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_2_1
1931  */
1932 #define DDS_PROTOCOLVERSION_2_1 { 2, 1 }
1933 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1934  */
1935 #define DDS_PROTOCOLVERSION { 2, 1 }
1936 
1937 /*e \dref_VendorId_t_LENGTH_MAX
1938  */
1939 #define DDS_VENDOR_ID_LENGTH_MAX 2
1940 
1941 /*e \dref_VendorId_t
1942  */
1943 struct DDS_VendorId
1944 {
1945  /*e \dref_VendorId_t_vendorId
1946  */
1947  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1948 };
1949 
1950 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1951 /*e \dref_VendorId_t
1952  */
1953 struct DDS_VendorId_t
1954 {
1955  /*e \dref_VendorId_t_vendorId
1956  */
1957  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1958 };
1959 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1960 
1961 
1962 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_VendorId);
1963 #define DDS_VendorId_t DDS_VendorId
1964 
1965 /*i \dref_VendorId_dEFAULT
1966  */
1967 #define DDS_VENDOR_ID_DEFAULT { {0, 0} }
1968 
1969 /*i \dref_VendorId_t_VENDORID_UNKNOWN
1970  */
1971 #define DDS_VENDORID_UNKNOWN { {0, 0} }
1972 
1973 /* ----------------------------------------------------------------- */
1974 
1975 /*e \dref_ProductVersion_t
1976  */
1977 struct DDS_ProductVersion
1978 {
1979  /*e \dref_ProductVersion_t_major
1980  */
1981  DDS_Char major;
1982 
1983  /*e \dref_ProductVersion_t_minor
1984  */
1985  DDS_Char minor;
1986 
1987  /*e \dref_ProductVersion_t_release
1988  */
1989  DDS_Char release;
1990 
1991  /*e \dref_ProductVersion_t_revision
1992  */
1993  DDS_Char revision;
1994 };
1995 
1996 
1997 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1998 /*e \dref_ProductVersion_t
1999  */
2000 struct DDS_ProductVersion_t
2001 {
2002  /*e \dref_ProductVersion_t_major
2003  */
2004  DDS_Char major;
2005  /*e \dref_ProductVersion_t_minor
2006  */
2007  DDS_Char minor;
2008  /*e \dref_ProductVersion_t_release
2009  */
2010  DDS_Char release;
2011  /*e \dref_ProductVersion_t_revision
2012  */
2013  DDS_Char revision;
2014 };
2015 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
2016 
2017 #define DDS_ProductVersion_t DDS_ProductVersion
2018 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProductVersion);
2019 
2020 /*e \dref_ProductVersion_t_UNKNOWN
2021  */
2022 #define DDS_PRODUCTVERSION_UNKNOWN { 0, 0, '0', 0 }
2023 
2024 /*i \dref_ProductVersion_DEFAULT
2025  */
2026 #define DDS_PRODUCTVERSION_DEFAULT { 2, 0, 'c', 1 }
2027 
2028 #ifndef RTI_CERT
2029 
2030 /*e \dref_DomainParticipant_C_Library_get_version
2031  */
2032 DDSCDllExport const char*
2033 DDSC_Library_get_version(void);
2034 #endif
2035 
2036 /* ----------------------------------------------------------------- */
2037 /* DATA_READER_PROTOCOL_X (eXtension QoS) */
2038 /* ----------------------------------------------------------------- */
2039 /*e \dref_DataReaderProtocolQosGroupDocs
2040  */
2041 
2042 /*e \dref_DATAREADERPROTOCOL_QOS_POLICY_NAME
2043  */
2044 extern DDSCDllVariable const char *const DDS_DATAREADERPROTOCOL_QOS_POLICY_NAME;
2045 
2046 /* ----------------------------------------------------------------- */
2047 /*e \dref_DataReaderProtocolQosPolicy
2048  */
2049 struct DDSCPPDllExport DDS_DataReaderProtocolQosPolicy
2050 {
2051  /*e \dref_DataReaderProtocolQosPolicy_rtps_object_id
2052  */
2053  DDS_UnsignedLong rtps_object_id;
2054 
2055  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataReaderProtocolQosPolicy)
2056 };
2057 
2058 /*i \dref_DataReaderProtocolQosPolicy_DEFAULT
2059  */
2060 #define DDS_DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT \
2061 { \
2062  DDS_RTPS_AUTO_ID \
2063 }
2064 
2065 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataReaderProtocolQosPolicy)
2066 
2067 /* ----------------------------------------------------------------- */
2068 
2069 /*e \dref_RtpsReliableWriterProtocol_t
2070  */
2071  struct DDSCPPDllExport DDS_RtpsReliableWriterProtocol_t
2072  {
2073  /*e \dref_RtpsReliableWriterProtocol_t_heartbeat_period
2074  */
2075  struct DDS_Duration_t heartbeat_period;
2076 
2077  /*e \dref_RtpsReliableWriterProtocol_t_heartbeats_per_max_samples
2078  */
2079  DDS_Long heartbeats_per_max_samples;
2080 
2081  /*e \dref_RtpsReliableWriterProtocol_t_max_send_window
2082  */
2083  DDS_Long max_send_window;
2084 
2085  /*e \dref_RtpsReliableWriterProtocol_t_max_heartbeat_retries
2086  */
2087  DDS_Long max_heartbeat_retries;
2088 
2089  /*i \dref_RtpsReliableWriterProtocol_t_first_write_sequence_number
2090  */
2091  struct DDS_SequenceNumber_t first_write_sequence_number;
2092  };
2093 
2094 #define DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW (DDS_LENGTH_UNLIMITED)
2095 
2096 /*i \dref_RtpsReliableWriterProtocol_DEFAULT
2097  */
2098 #define DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT { \
2099  {3,0}, /* hb_period */ \
2100  1, /* hb_per_max_samples */ \
2101  DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW, /* max_send_window */ \
2102  DDS_LENGTH_UNLIMITED, /* max_heartbeat_retries */ \
2103  {0,1} /* first_write_sequence_number */\
2104 }
2105 
2106 /* ----------------------------------------------------------------- */
2107 /* DATA_WRITER_PROTOCOL_X (eXtension QoS) */
2108 /* ----------------------------------------------------------------- */
2109 /*e \dref_DataWriterProtocolQosGroupDocs
2110  */
2111 
2112 /*e \dref_DATAWRITERPROTOCOL_QOS_POLICY_NAME
2113  */
2114 extern DDSCDllVariable const char *const DDS_DATAWRITERPROTOCOL_QOS_POLICY_NAME;
2115 
2116 /* ----------------------------------------------------------------- */
2117 /*e \dref_DataWriterProtocolQosPolicy
2118  */
2119 struct DDSCPPDllExport DDS_DataWriterProtocolQosPolicy
2120 {
2121  /*e \dref_DataWriterProtocolQosPolicy_rtps_object_id
2122  */
2123  DDS_UnsignedLong rtps_object_id;
2124 
2125  /*e \dref_DataWriterProtocolQosPolicy_rtps_reliable_writer
2126  */
2127  struct DDS_RtpsReliableWriterProtocol_t rtps_reliable_writer;
2128 
2129  /*e \dref_DataWriterProtocolQosPolicy_serialize_on_write
2130  */
2131  DDS_Boolean serialize_on_write;
2132 
2133  DDSC_CPP_QOS_POLICY_METHODS(DDS_DataWriterProtocolQosPolicy)
2134 };
2135 
2136 /*i \dref_DataWriterProtocolQosPolicy_DEFAULT
2137  */
2138 #define DDS_DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT \
2139 { DDS_RTPS_AUTO_ID, \
2140  DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT,\
2141  RTI_TRUE \
2142 }
2143 
2144 DDSC_QOS_POLICY_METHODS_DECL(DDS_DataWriterProtocolQosPolicy)
2145 
2146 /* ----------------------------------------------------------------- */
2147 /* TRANSPORT_QOS_POLICY (eXtension QoS) */
2148 /* ----------------------------------------------------------------- */
2149 /*e \dref_TransportQosGroupDocs
2150  */
2151 
2152 /*e \dref_TRANSPORT_QOS_POLICY_NAME
2153  */
2154 extern DDSCDllVariable const char *const DDS_TRANSPORT_QOS_POLICY_NAME;
2155 
2156 /* ----------------------------------------------------------------- */
2157 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2158 /*i \dref_StringSeq
2159  */
2160 struct DDS_StringSeq {};
2161 #endif
2162 
2163 
2164 /*e \dref_TransportQosPolicy
2165  */
2166 struct DDSCPPDllExport DDS_TransportQosPolicy
2167 {
2168  /*e \dref_TransportQosPolicy_enabled_transports
2169  */
2170  struct DDS_StringSeq enabled_transports;
2171 
2172  DDSC_CPP_QOS_POLICY_METHODS(DDS_TransportQosPolicy)
2173 };
2174 
2175 /*i \dref_TransportQosPolicy_DEFAULT
2176  */
2177 #define DDS_TRANSPORT_QOS_POLICY_DEFAULT \
2178 {\
2179  DDS_SEQUENCE_INITIALIZER \
2180 }
2181 
2182 DDSC_QOS_POLICY_METHODS_DECL(DDS_TransportQosPolicy)
2183 
2184 /* ----------------------------------------------------------------- */
2185 /* DOMAIN_PARTICIPANT_RESOURCE_LIMITS_X (eXtension QoS) */
2186 /* ----------------------------------------------------------------- */
2187 /*e \dref_DomainParticipantResourceLimitsQosGroupDocs
2188  */
2189 
2190 /*e \dref_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME
2191  */
2192 extern DDSCDllVariable const char *const
2193  DDS_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME;
2194 
2195 /* ----------------------------------------------------------------- */
2196 
2197 /*e \dref_DomainParticipantResourceLimitsQosPolicy
2198  */
2199 struct DDSCPPDllExport DDS_DomainParticipantResourceLimitsQosPolicy
2200 {
2201  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_writer_allocation
2202  */
2203  DDS_Long local_writer_allocation;
2204 
2205  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_reader_allocation
2206  */
2207  DDS_Long local_reader_allocation;
2208 
2209  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_publisher_allocation
2210  */
2211  DDS_Long local_publisher_allocation;
2212 
2213  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_subscriber_allocation
2214  */
2215  DDS_Long local_subscriber_allocation;
2216 
2217  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_topic_allocation
2218  */
2219  DDS_Long local_topic_allocation;
2220 
2221  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_type_allocation
2222  */
2223  DDS_Long local_type_allocation;
2224 
2225  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_participant_allocation
2226  */
2227  DDS_Long remote_participant_allocation;
2228 
2229  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_writer_allocation
2230  */
2231  DDS_Long remote_writer_allocation;
2232 
2233  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_reader_allocation
2234  */
2235  DDS_Long remote_reader_allocation;
2236 
2237  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_writer_reader_pair_allocation
2238  */
2239  DDS_Long matching_writer_reader_pair_allocation;
2240 
2241  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_reader_writer_pair_allocation
2242  */
2243  DDS_Long matching_reader_writer_pair_allocation;
2244 
2245  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_receive_ports
2246  */
2247  DDS_Long max_receive_ports;
2248 
2249  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_destination_ports
2250  */
2251  DDS_Long max_destination_ports;
2252 
2253  DDSC_CPP_QOS_POLICY_METHODS(DDS_DomainParticipantResourceLimitsQosPolicy)
2254 };
2255 
2256 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2257  *
2258  * This constant is used below in
2259  * DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT; other types
2260  * should not use it alone.
2261  */
2262 #define DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT (32L)
2263 
2264 
2265 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2266  *
2267  * Several fields in this structure are actually never used. These fields
2268  * should be explicitly initialized when this structure is copied
2269  * from a lower layer structure to prevent the values from being left in
2270  * an uninitialized state. The unused fields include:
2271  *
2272  * - local_publisher_allocation.max_count
2273  * - local_subscriber_allocation.max_count
2274  * - local_topic_allocation.max_count
2275  * - matching_writer_reader_pair_allocation.initial_count
2276  * - matching_writer_reader_pair_allocation.max_count
2277  * - matching_reader_writer_pair_allocation.initial_count
2278  * - matching_reader_writer_pair_allocation.max_count
2279  */
2280 /*i \dref_DomainParticipantReasourceLimitsQosPolicy_DEFAULT
2281  */
2282 #define DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT \
2283 {1L, /*local_writer_allocation*/ \
2284  1L, /*local_reader_allocation*/ \
2285  1L, /*local_publisher_allocation*/ \
2286  1L, /*local_subscriber_allocation*/ \
2287  1L, /*local_topic_allocation*/ \
2288  1L, /*local_type_allocation*/ \
2289  1L, /*remote_participant_allocation*/ \
2290  1L, /*remote_writer_allocation*/ \
2291  1L, /*remote_reader_allocation*/ \
2292  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2293  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2294  8L,\
2295  8L \
2296 }
2297 
2298 DDSC_QOS_POLICY_METHODS_DECL(DDS_DomainParticipantResourceLimitsQosPolicy)
2299 
2300 /* ----------------------------------------------------------------- */
2301 
2302 /*i \dref_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH
2303  */
2304 #define DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH (4)
2305 
2306 /*e \dref_BuiltinTopicKey_t
2307  */
2308 typedef struct DDS_BuiltinTopicKey_t
2309 {
2310  /*e \dref_BuiltinTopicKey_t_value
2311  */
2312  DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE value[DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH];
2313 } DDS_BuiltinTopicKey_t;
2314 
2315 /*i @ingroup BuiltinTopicGroupDocs
2316  */
2317 #define DDS_BuiltinTopicKey_t_INITIALIZER { {0, 0, 0, 0} }
2318 
2319 /*e \dref_BuiltinTopicKey_t_AUTO
2320  */
2321 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_AUTO;
2322 
2323 /*e \dref_BuiltinTopicKey_t_UNKNOWN
2324  */
2325 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_UNKNOWN;
2326 
2327 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2328  */
2329 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_UNKNOWN;
2330 
2331 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2332  */
2333 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_AUTO;
2334 
2335 /*i \ingroup BuiltinTopicGroupDocs_equals
2336 */
2337 DDSCDllExport DDS_Boolean
2338 DDS_BuiltinTopicKey_equals(const DDS_BuiltinTopicKey_t *a,
2339  const DDS_BuiltinTopicKey_t *b);
2340 
2341 /*i \ingroup BuiltinTopicGroupDocs_prefix_equals
2342  */
2343 DDSCDllExport DDS_Boolean
2344 DDS_BuiltinTopicKey_prefix_equals(const DDS_BuiltinTopicKey_t *a,
2345  const DDS_BuiltinTopicKey_t *b);
2346 
2347 /*i \ingroup BuiltinTopicGroupDocs_suffix_equals
2348  */
2349 DDSCDllExport DDS_Boolean
2350 DDS_BuiltinTopicKey_suffix_equals(const DDS_BuiltinTopicKey_t *a,
2351  const DDS_BuiltinTopicKey_t *b);
2352 
2353 /*i \ingroup BuiltinTopicGroupDocs_copy_prefix
2354  */
2355 DDSCDllExport void
2356 DDS_BuiltinTopicKey_copy_prefix(DDS_BuiltinTopicKey_t *a,
2357  const DDS_BuiltinTopicKey_t *b);
2358 
2359 /*i \ingroup BuiltinTopicGroupDocs_copy_suffix
2360  */
2361 DDSCDllExport void
2362 DDS_BuiltinTopicKey_copy_suffix(DDS_BuiltinTopicKey_t *a,
2363  const DDS_BuiltinTopicKey_t *b);
2364 
2365 /*i \ingroup BuiltinTopicGroupDocs_from_guid
2366  */
2367 DDSCDllExport void
2368 DDS_BuiltinTopicKey_from_guid(DDS_BuiltinTopicKey_t *in,
2369  const DDS_InstanceHandle_t *out);
2370 /*ci
2371  * \brief Compare two DDS_BuiltinTopicKey_t structure for ordering
2372  *
2373  * \param[in] left Left side of comparison
2374  * \param[in] right Right side of comparison
2375  *
2376  * \return positive integer if left is greater than right,
2377  * negative integer if left is less than right,
2378  * zero if left is equal to right
2379  */
2380 DDSCDllExport DDS_Long
2381 DDS_BuiltinTopicKey_compare(const DDS_BuiltinTopicKey_t *left,
2382  const DDS_BuiltinTopicKey_t *right);
2383 
2384 /* ================================================================= */
2385 /* Condition and Waitsets */
2386 /* ================================================================= */
2387 
2388 /*ce \dref_Entity
2389  */
2390 typedef struct DDS_EntityImpl DDS_Entity;
2391 
2392 /* ----------------------------------------------------------------- */
2393 /*e \dref_ConditionsAndWaitsetsModuleDocs
2394  */
2395 
2396 /*ce \dref_Condition
2397  */
2398 typedef struct DDS_ConditionImpl DDS_Condition;
2399 
2400 /*ci @ingroup DDSConditionsModule
2401  @brief Pointer to DDS_Condition.
2402  */
2403 typedef struct DDS_ConditionImpl *DDS_Condition_ptr;
2404 
2405 /*ce \dref_ConditionSeq
2406  */
2407 #define T struct DDS_ConditionImpl*
2408 #ifndef RTI_CERT
2409 #define TSeq_ensure_length
2410 #define TSeq_has_ownership
2411 #endif
2412 #define TSeq DDS_ConditionSeq
2413 #include <reda/reda_sequence_decl.h>
2414 
2415 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2416 /*ce \dref_ConditionSeq
2417  */
2418 struct DDS_ConditionSeq {};
2419 #endif
2420 
2421 /*ce \dref_Condition_get_trigger_value
2422  */
2423 DDSCDllExport DDS_Boolean
2424 DDS_Condition_get_trigger_value(DDS_Condition *self);
2425 
2426 /*i \dref_Condition_set_wrapper
2427  */
2428 DDSCDllExport void
2429 DDS_ConditionImpl_set_wrapper(DDS_Condition *self, void *wrapper);
2430 
2431 /*i \dref_Condition_get_wrapper
2432  */
2433 DDSCDllExport void**
2434 DDS_ConditionImpl_get_wrapper_ref(DDS_Condition *self);
2435 
2436 /* ----------------------------------------------------------------- */
2437 
2438 /*ce \dref_GuardCondition
2439  */
2440 typedef struct DDS_GuardConditionImpl DDS_GuardCondition;
2441 
2442 #define DDS_GuardCondition_as_condition(guard_condition_ptr_) \
2443  ((DDS_Condition*) guard_condition_ptr_)
2444 
2445 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2446 /*ce \dref_GuardCondition_as_condition
2447  */
2448 DDS_Condition* DDS_GuardCondition_as_condition(DDS_GuardCondition* guard_cond);
2449 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2450 
2451 /*ce \dref_GuardCondition_new
2452  */
2453 DDSCDllExport DDS_GuardCondition*
2454 DDS_GuardCondition_new(void);
2455 
2456 #ifndef RTI_CERT
2457 /*ce \dref_GuardCondition_delete
2458  */
2459 DDSCDllExport DDS_ReturnCode_t
2460 DDS_GuardCondition_delete(DDS_GuardCondition *self);
2461 #endif
2462 
2463 /*ce \dref_GuardCondition_set_trigger_value
2464  */
2465 DDSCDllExport DDS_ReturnCode_t
2466 DDS_GuardCondition_set_trigger_value(DDS_GuardCondition *self,
2467  DDS_Boolean value);
2468 
2469 /* ----------------------------------------------------------------- */
2470 
2471 /*ce \dref_StatusCondition
2472  */
2473 typedef struct DDS_StatusConditionImpl DDS_StatusCondition;
2474 
2475 #define DDS_StatusCondition_as_condition(status_cond_ptr_) \
2476  ((DDS_Condition*) status_cond_ptr_)
2477 
2478 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2479 /*ce \dref_StatusCondition_as_condition
2480  */
2481 DDS_Condition* DDS_StatusCondition_as_condition(
2482  DDS_StatusCondition *statusCondition);
2483 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2484 
2485 
2486 /*ce \dref_StatusCondition_get_enabled_statuses
2487  */
2488 DDSCDllExport DDS_StatusMask
2489 DDS_StatusCondition_get_enabled_statuses(DDS_StatusCondition *self);
2490 
2491 /*ce \dref_StatusCondition_set_enabled_statuses
2492  */
2493 DDSCDllExport DDS_ReturnCode_t
2494 DDS_StatusCondition_set_enabled_statuses(DDS_StatusCondition *self,
2495  DDS_StatusMask mask);
2496 
2497 /*ce \dref_StatusCondition_get_entity
2498  */
2499 DDSCDllExport DDS_Entity*
2500 DDS_StatusCondition_get_entity(DDS_StatusCondition *self);
2501 
2502 /*ce \dref_WaitSet
2503  */
2504 typedef struct DDS_WaitSetImpl DDS_WaitSet;
2505 
2506 /*ce \dref_WaitSet_new
2507  */
2508 DDSCDllExport DDS_WaitSet*
2509 DDS_WaitSet_new(void);
2510 
2511 /*ce \dref_WaitSet_wait
2512  */
2513 DDSCDllExport DDS_ReturnCode_t
2514 DDS_WaitSet_wait(DDS_WaitSet *self,
2515  struct DDS_ConditionSeq *active_conditions,
2516  const struct DDS_Duration_t *timeout);
2517 
2518 /*ce \dref_WaitSet_attach_condition
2519  */
2520 DDSCDllExport DDS_ReturnCode_t
2521 DDS_WaitSet_attach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2522 
2523 #ifndef RTI_CERT
2524 /*ce \dref_WaitSet_delete
2525  */
2526 DDSCDllExport DDS_ReturnCode_t
2527 DDS_WaitSet_delete(DDS_WaitSet *self);
2528 #endif /* !RTI_CERT */
2529 
2530 #ifndef RTI_CERT
2531 /*ce \dref_WaitSet_detach_condition
2532  */
2533 DDSCDllExport DDS_ReturnCode_t
2534 DDS_WaitSet_detach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2535 #endif /* !RTI_CERT */
2536 
2537 
2538 /*ce \dref_WaitSet_get_conditions
2539  */
2540 DDSCDllExport DDS_ReturnCode_t
2541 DDS_WaitSet_get_conditions(DDS_WaitSet *self,
2542  struct DDS_ConditionSeq *attached_conditions);
2543 
2544 /* ================================================================= */
2545 /* Listeners */
2546 /* ================================================================= */
2547 /*e \dref_EntityModuleDocs
2548  */
2549 
2550 /*ce \dref_Listener
2551  */
2552 struct DDS_Listener
2553 {
2554  /*ce \dref_Listener_listener_data
2555  */
2556  void *listener_data;
2557 };
2558 
2559 /*ce \dref_Listener_INITIALIZER
2560  */
2561 #define DDS_Listener_INITIALIZER { NULL }
2562 
2563 /* ================================================================= */
2564 /* Entity typedef */
2565 /* ================================================================= */
2566 
2567 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2568 /*ce \dref_DomainEntity
2569  */
2570 typedef struct DDS_DomainEntityImpl DDS_DomainEntity;
2571 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
2572 
2573 /* ================================================================= */
2574 /* DDS_Entity */
2575 /* ================================================================= */
2576 
2577 /*ce \dref_Entity_enable
2578  */
2579 DDSCDllExport DDS_ReturnCode_t
2580 DDS_Entity_enable(DDS_Entity * self);
2581 
2582 /*ce \dref_Entity_is_enabled
2583  */
2584 DDSCDllExport DDS_Boolean
2585 DDS_Entity_is_enabled(DDS_Entity * self);
2586 
2587 /*ce \dref_Entity_get_instance_handle
2588  */
2589 DDSCDllExport DDS_InstanceHandle_t
2590 DDS_Entity_get_instance_handle(DDS_Entity * self);
2591 
2592 /*ce \dref_Entity_get_entity_kind
2593  */
2594 DDSCDllExport DDS_EntityKind_t
2595 DDS_Entity_get_entity_kind(DDS_Entity *self);
2596 
2597 /*ce \dref_Entity_get_statuscondition
2598  */
2599 DDSCDllExport DDS_StatusCondition*
2600 DDS_Entity_get_statuscondition(DDS_Entity *self);
2601 
2602 /*ce \dref_Entity_get_status_changes
2603  */
2604 DDSCDllExport DDS_StatusMask
2605 DDS_Entity_get_status_changes(DDS_Entity *self);
2606 
2607 /*ci
2608  * \brief Associate a language-dependent wrapper object with a DDS_Entity.
2609  *
2610  * \details
2611  * This operation is used to support access to the functionality of
2612  * the C implementation from other compatible programming languages, such as C++.
2613  * Implementations of the Micro API in these programming languages may use
2614  * this facility to associate objects created in their run-time environments
2615  * with DDS_Entity instances by means of this operation, and then access
2616  * them using DDS_Entity_get_wrapper, typically to support the correct
2617  * propagation of events from the C core to the wrapping programming language's
2618  * layer.
2619  *
2620  * \param[in] self a non NULL DDS_Entity
2621  * \param[in] wrapper pointer to a wrapper instance or NULL to delete an
2622  * existing association.
2623  */
2624 DDSCDllExport void
2625 DDS_Entity_set_wrapper(DDS_Entity *self, void *wrapper);
2626 
2627 /*ci
2628  * \brief Access a language-dependent wrapper object attached to the DDS_Entity.
2629  *
2630  * \long This operation is used to support access to the functionality of
2631  * the C implementation from other compatible programming languages, such as C++.
2632  * Implementations of the Micro API in these programming languages may use
2633  * this facility to associate objects created in their run-time environments
2634  * with DDS_Entity instances by means of DDS_Entity_set_wrapper, typically
2635  * to support the correct propagation of events from the C core to the wrapping
2636  * programming language's layer.
2637  *
2638  * \param[in] self a non NULL DDS_Entity
2639  *
2640  * \return a pointer to a wrapper object previously or NULL if none had been
2641  * previously set using DDS_Entity_set_wrapper.
2642  */
2643 DDSCDllExport void*
2644 DDS_Entity_get_wrapper(DDS_Entity *self);
2645 
2646 /* ----------------------------------------------------------------- */
2647 /* ENTITY_NAME */
2648 /* ----------------------------------------------------------------- */
2649 /*e \dref_EntityNameQosGroupDocs
2650  */
2651 
2652 /*e \dref_ENTITYNAME_QOS_POLICY_NAME
2653  */
2654 extern DDSCDllVariable const char *const DDS_ENTITYNAME_QOS_POLICY_NAME;
2655 
2656 /*e \dref_AUTO_NAME_ENTITY
2657  */
2658 extern DDSCDllVariable const char *const DDS_AUTO_NAME_ENTITY;
2659 
2660 /* ----------------------------------------------------------------- */
2661 /*e \dref_EntityNameQosPolicy_NAME_MAX
2662  */
2663 #define DDS_ENTITYNAME_QOS_NAME_MAX 255
2664 
2665 #ifdef RTI_WIN32
2666 #pragma warning(push)
2667 #pragma warning(disable: 4522)
2668 #endif
2669 
2670 /*e \dref_EntityNameQosPolicy
2671  */
2672 struct DDSCPPDllExport DDS_EntityNameQosPolicy
2673 {
2674  /*e \dref_EntityNameQosPolicy_name
2675  */
2676  char name[DDS_ENTITYNAME_QOS_NAME_MAX + 1];
2677 
2678  DDSC_CPP_QOS_POLICY_METHODS(DDS_EntityNameQosPolicy)
2679 
2680 #ifdef RTI_CPP
2681 public:
2682  bool set_name(const char *const name);
2683 #ifdef RTI_CERT
2684  private:
2685 #else
2686  public:
2687 #endif
2688  DDS_EntityNameQosPolicy& operator=(const char *const name);
2689  DDS_EntityNameQosPolicy& operator=(const DDS_EntityNameQosPolicy& from);
2690  const DDS_EntityNameQosPolicy& operator=(const DDS_EntityNameQosPolicy& from) const;
2691  bool operator==(const DDS_EntityNameQosPolicy& other) const;
2692  bool operator==(const char *const name) const;
2693  bool operator!=(const DDS_EntityNameQosPolicy& other) const;
2694  bool operator!=(const char *const name) const;
2695 #endif
2696 };
2697 
2698 #ifdef RTI_WIN32
2699 #pragma warning(pop)
2700 #endif
2701 
2702 /*i \dref_EntityNameQosPolicy_DEFAULT
2703  */
2704 #define DDS_ENTITY_NAME_QOS_POLICY_DEFAULT { {'\0'} }
2705 
2706 DDSC_QOS_POLICY_METHODS_DECL(DDS_EntityNameQosPolicy)
2707 
2708 /*e \dref_EntityNameQosPolicy_set_name
2709  */
2710 DDSCDllExport DDS_Boolean
2711 DDS_EntityNameQosPolicy_set_name(struct DDS_EntityNameQosPolicy *const self,
2712  const char *const name);
2713 
2714 /* ================================================================= */
2715 /* RTI_Management */
2716 /* ================================================================= */
2717 
2718 /*i \dref_ManagementQosPolicy
2719  */
2720 struct DDSCPPDllExport RTI_ManagementQosPolicy
2721 {
2722  DDS_Boolean is_hidden;
2723  DDS_Boolean is_anonymous;
2724  DDS_Boolean disable_unregister_dispose_for_unpublished_instance;
2725 
2726  DDSC_CPP_QOS_POLICY_METHODS(RTI_ManagementQosPolicy)
2727 };
2728 
2729 /*i \dref_ManagementQosPolicy_DEFAULT
2730  */
2731 #define RTI_MANAGEMENT_QOS_POLICY_DEFAULT { \
2732  DDS_BOOLEAN_FALSE,\
2733  DDS_BOOLEAN_FALSE, \
2734  DDS_BOOLEAN_FALSE \
2735 }
2736 
2737 DDSC_QOS_POLICY_METHODS_DECL(RTI_ManagementQosPolicy)
2738 
2739 /* ================================================================= */
2740 /* DDS_DomainEntity */
2741 /* ================================================================= */
2742 
2743 /*ce \dref_DomainParticipant
2744  */
2745 typedef struct DDS_DomainParticipantImpl DDS_DomainParticipant;
2746 
2747 /* ----------------------------------------------------------------- */
2748 
2749 /* ================================================================= */
2750 /* DDSHST_History */
2751 /* ================================================================= */
2752 /*i \dref_DDSHST_ReturnCode_T
2753  */
2754 typedef enum
2755 {
2756  DDSHST_RETCODE_ERROR = -1000,
2757  DDSHST_RETCODE_NOSPACE,
2758  DDSHST_RETCODE_EXISTS,
2759  DDSHST_RETCODE_NOT_EXISTS,
2760  DDSHST_RETCODE_INVALID_PROPERTY,
2761  DDSHST_RETCODE_INVALID_ENTRY_REQUEST,
2762  DDSHST_RETCODE_NOT_SUPPORTED,
2763  DDSHST_RETCODE_SUCCESS = 0
2764 } DDSHST_ReturnCode_T;
2765 
2766 /*i \dref_ReplacePolicyKind_T
2767  */
2768 typedef enum
2769 {
2770  DDSHST_REPLACE_POLICY_KIND_OLDEST,
2771  DDSHST_REPLACE_POLICY_KIND_NONE
2772 } DDSHST_ReplacePolicyKind_T;
2773 
2774 
2775 /* ----------------------------------------------------------------- */
2776 /* WRITE_PARAMS */
2777 /* ----------------------------------------------------------------- */
2778 
2779 /*e \dref_SampleIdentity_t
2780  */
2781 struct DDSCPPDllExport DDS_SampleIdentity_t
2782 {
2783  /*e \dref_SampleIdentity_t_writer_guid */
2784  struct DDS_GUID_t writer_guid;
2785  /*e \dref_SampleIdentity_t_sequence_number */
2786  struct DDS_SequenceNumber_t sequence_number;
2787 
2788  DDSC_CPP_QOS_POLICY_METHODS(DDS_SampleIdentity_t)
2789 };
2790 
2791 
2792 /*ci \dref_SampleIdentity_t
2793  */
2794 #define DDS_SAMPLE_IDENTITY_UNKNOWN \
2795 { \
2796  DDS_GUID_INITIALIZER, \
2797  DDS_SEQUENCE_NUMBER_UNKNOWN \
2798 }
2799 
2800 /*e \dref_WriteParams_t
2801  */
2802 struct DDSCPPDllExport DDS_WriteParams_t
2803 {
2804  /*i \dref_WriteParams_t_identity
2805  */
2806  struct DDS_SampleIdentity_t identity;
2807 
2808  /*i \dref_WriteParams_t_related_sample_identity
2809  */
2810  struct DDS_SampleIdentity_t related_sample_identity;
2811 
2812  /*e \dref_WriteParams_t_source_timestamp
2813  */
2814  struct DDS_Time_t source_timestamp;
2815 
2816  /*e \dref_WriteParams_t_handle
2817  */
2818  DDS_InstanceHandle_t handle;
2819 
2820  DDSC_CPP_QOS_POLICY_METHODS(DDS_WriteParams_t)
2821 };
2822 
2823 /*e \dref_WriteParams_t_DEFAULT
2824  */
2825 #define DDS_WRITEPARAMS_DEFAULT \
2826 { \
2827  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2828  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2829  DDS_TIME_ZERO, \
2830  DDS_HANDLE_NIL_NATIVE \
2831 }
2832 
2833 /* ================================================================= */
2834 /* DDS Properties */
2835 /* ================================================================= */
2836 /* NOTE:
2837  * DDS_PropertySeq is not exposed as a general purpose property
2838  * sequence. It is only used to send required properties for RTI Tools.
2839  * Thus, although the generic sequence type is used to implement the property
2840  * sequence, its internal use is highly specialized and only a limited
2841  * number of functions are exposed.
2842  */
2843 #define DDS_PropertySeq CDR_PropertySeq
2844 #define DDS_Property CDR_Property
2845 #define DDS_PropertySeq_initialize CDR_PropertySeq_initialize
2846 #define DDS_PropertySeq_set_length CDR_PropertySeq_set_length
2847 #define DDS_PropertySeq_get_length CDR_PropertySeq_get_length
2848 #define DDS_PropertySeq_get_reference CDR_PropertySeq_get_reference
2849 
2850 /*ci
2851  * \brief Get pointer to the DDS participant properties
2852  *
2853  * \details
2854  * The DDS domain participant may send additional information as properties
2855  * in the participant announcement. Typically this is used by discovery plugins
2856  * to serialize the information.
2857  *
2858  * \param[in] self Participant to get properties for
2859  *
2860  * \return A sequence with 0 or more properties on success, NULL if no
2861  * sequence exists.
2862  */
2863 DDSCDllExport struct DDS_PropertySeq*
2864 DDS_DomainParticipant_get_dds_properties(DDS_DomainParticipant *self);
2865 
2866 
2867 /*ci
2868  * \brief Query the domain-participant if the specified locator is supported
2869  *
2870  * \param[in] self Participant to query
2871  *
2872  * \return DDS_BOOLEAN_TRUE if the locator is supported, DDS_BOOLEEAN_FALSE
2873  * otherwise.
2874  */
2875 DDSCDllExport DDS_Boolean
2876 DDS_DomainParticipant_locator_is_supported(DDS_DomainParticipant *self,
2877  struct DDS_Locator *locator);
2878 
2879 #ifdef __cplusplus
2880 } /* extern "C" */
2881 #endif
2882 
2883 #endif /* dds_c_infrastructure_h */
RTI Connext DDS Micro Version 2.4.11 Copyright © Mon Jul 23 2018 Real-Time Innovations, Inc