RTI Connext DDS Micro  Version 2.4.6
 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-2015.
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  * 04nov2015,tk MICRO-1505 - Reduce memory footprint
16  * 15jul2015,tk MICRO-1426/PR#15358 Added Added DDS_Duration_delta_gt
17  * 30jun2015,tk MICRO-1323/PR#15020 Refactored definition of DDS_DURATION_INFINITE
18  * 19may2015,as MICRO-1193 Refactoring of Sequence API levels
19  * 02apr2014,eh MICRO-964/PR#12378 Remove from Cert unused locator defines
20  * 16mar2015,tk MICRO-1129/PR#14274 Increased size of entity_name to
21  * DDS_ENTITYNAME_QOS_NAME_MAX + 1
22  * 25feb2015,eh MICRO-1040/PR#13555 Remove unused DDS_Guid_equals/copy/compare
23  * 09feb2015,tk MICRO-1061/PR#13633 DDS_AUTOMATIC_LIVELINESS_QOS is now default
24  * 08oct2014,tk MICRO-919 Added SampleLostReason to SampleLost status
25  * MICRO-918 Removed TimeBasedFilter qos policy (unsupported)
26  * 20sep2014,as Make support functions for QosPolicy types private; remove macros DDSC_CPP_VALUE_TYPE_SUPPORT_FUNCTIONS
27  * and DDSC_CPP_SUPPORT_TYPE_SUPPORT_FUNCTIONS; update DDSC_CPP_VALUE_TYPE_SUPPORT_METHODS and
28  * DDSC_CPP_STATUS_TYPE_SUPPORT_METHODS to only define method signatures (no inline implementation)
29  * 04aug2014,tk MICRO-846/PR#10203 - Limit exposure of PropertySeq API
30  * MICRO-848/PR#10206 - Limit exposure of PropertySeq API
31  * 29jul2014,tk MICRO-864/PR#10245 Fixed C++ DDS_DataReaderResourceLimitsQosPolicy
32  * 19jul2013,as Added support for C++
33  * 06feb2013,eh MICRO-262: add max_remote_readers
34  * 29jun2012,tk Written
35  */
36 /*ce
37  * \file
38  * \brief DDS Domain Module definitions
39  */
40 /*e @addtogroup DDSInfrastructureModule Infrastructure Module
41  @ingroup DDSCModule
42 
43  @brief Defines the \dds infrastructure package
44 */
45 #ifndef dds_c_infrastructure_h
46 #define dds_c_infrastructure_h
47 
48 #ifndef dds_c_dll_h
49 #include "dds_c/dds_c_dll.h"
50 #endif
51 #ifndef osapi_thread_h
52 #include "osapi/osapi_thread.h"
53 #endif
54 #ifndef netio_rtps_h
55 #include "netio/netio_rtps.h"
56 #endif
57 #ifndef rtps_rtps_h
58 #include "rtps/rtps_rtps.h"
59 #endif
60 #ifndef dds_c_common_h
61 #include "dds_c/dds_c_common.h"
62 #endif
63 #ifndef dds_c_string_h
64 #include "dds_c/dds_c_string.h"
65 #endif
66 #ifndef dds_c_sequence_h
67 #include "dds_c/dds_c_sequence.h"
68 #endif
69 
70 #ifdef __cplusplus
71 extern "C"
72 {
73 #endif
74 
75 #ifndef NULL
76 #define NULL 0
77 #endif
78 
79 /* ================================================================= */
80 /* Micro DDS */
81 /* ================================================================= */
82 #define RTI_MICRODDS
83 #define RTI_MICRODDS_MAJOR 2
84 #define RTI_MICRODDS_MINOR 0
85 
86 /* ================================================================= */
87 /* CPP VALUE-TYPE SUPPORT */
88 /* ================================================================= */
89 
90 
91 #ifdef RTI_CPP
92 #ifndef RTI_CERT
93 #define DDSC_CPP_SUPPORT_METHODS_EXTENDED(T) \
94  public:\
95  T();\
96  ~T();\
97  DDS_ReturnCode_t copy(const T& from);\
98  T(const T& from);\
99  T& operator=(const T& from);\
100  bool operator==(const T& other);\
101  bool operator!=(const T& other);
102 #else /* ifdef RTI_CERT */
103 #define DDSC_CPP_SUPPORT_METHODS_EXTENDED(T) \
104  public:\
105  T();\
106  ~T();\
107  DDS_ReturnCode_t copy(const T& from);\
108  private: \
109  T(const T& from);\
110  T& operator=(const T& from);\
111  bool operator==(const T& other);\
112  bool operator!=(const T& other);
113 #endif /* ifdef RTI_CERT */
114 
115 #ifndef RTI_CERT
116 #define DDSC_CPP_SUPPORT_METHODS_BASIC(T) \
117  public:\
118  T();\
119  ~T();\
120  T(const T& from);\
121  T& operator=(const T& from);\
122  bool operator==(const T& other);\
123  bool operator!=(const T& other);
124 #else
125 #define DDSC_CPP_SUPPORT_METHODS_BASIC(T) \
126  public:\
127  T();\
128  ~T();\
129  private: \
130  T(const T& from);\
131  T& operator=(const T& from);\
132  bool operator==(const T& other);\
133  bool operator!=(const T& other);
134 #endif
135 
136 #else /* ifdef RTI_CPP */
137 #define DDSC_CPP_SUPPORT_METHODS_EXTENDED(T)
138 #define DDSC_CPP_SUPPORT_METHODS_BASIC(T)
139 #endif /* ifdef RTI_CPP */
140 
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_SUPPORT_METHODS_BASIC(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_SUPPORT_METHODS_BASIC(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_SUPPORT_METHODS_BASIC(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 DDS_DeadlineQosPolicy
975 {
976  /*e \dref_DeadlineQosPolicy_period
977  */
978  struct DDS_Duration_t period;
979 };
980 
981 /*ci
982  * \brief Calculate the sampling frequency for the deadline Qos policy
983  *
984  * \details
985  *
986  * A deadline is measured between two sent or received samples. However,
987  * when no more samples are received there is nothing to compare against. To
988  * solve this problem a periodic check can be performed. Every period a check
989  * is performed to check if a sample should have been received. If the time
990  * since the last check exceeds the deadline period the deadline has been
991  * missed. This function calculates a reasonable sampling frequency for
992  * different deadlines. The sampling frequency is based on a reasonable effort
993  * to detect a stale instance without overloading the CPU. The constants used
994  * in this function are not used elsewhere and the method to calculate the
995  * sampling frequency is considered a formula. Thus, the constants are not
996  * considered magic.
997  *
998  * NOTE: This function assumes valid deadline and sample_freq inputs.
999  * Invalid arguments have undefined behavior.
1000  *
1001  * \param[in] deadline The deadline to calculate a sampling frequency for
1002  * \param[out] sample_freq A suitable sampling frequency for deadline
1003  */
1004 DDSCDllExport void
1005 DDS_DeadlineQosPolicy_get_sample_freq(
1006  const struct DDS_DeadlineQosPolicy *const deadline,
1007  struct DDS_Duration_t *const sample_freq);
1008 
1009 /*i
1010  * \brief Convert a duration to ms
1011  *
1012  * \details
1013  * This function converts from sec,nanosec to milliseconds. Note that
1014  * no check is performed for overflow.
1015  *
1016  * \param[in] self Duration structure to convert to ms
1017  */
1018 DDSCDllExport DDS_Long
1019 DDS_Duration_to_ms(const struct DDS_Duration_t *const self);
1020 
1021 /*i \dref_DeadlineQosPolicy_DEFAULT
1022  * Default is infinite
1023  */
1024 #define DDS_DEADLINE_QOS_POLICY_DEFAULT \
1025 {DDS_DURATION_INFINITE_INITIALIZER}
1026 
1027 /* ----------------------------------------------------------------- */
1028 /* OWNERSHIP */
1029 /* ----------------------------------------------------------------- */
1030 /*e \dref_OwnershipQosGroupDocs
1031  */
1032 
1033 /*e \dref_OWNERSHIP_QOS_POLICY_NAME
1034  */
1035 extern DDSCDllVariable const char *const DDS_OWNERSHIP_QOS_POLICY_NAME;
1036 
1037 /* ----------------------------------------------------------------- */
1038 /*e \dref_OwnershipQosPolicyKind
1039  */
1040 typedef enum
1041 {
1042  /*e \dref_OwnershipQosPolicyKind_SHARED_OWNERSHIP_QOS
1043  */
1044  DDS_SHARED_OWNERSHIP_QOS,
1045 
1046  /*e \dref_OwnershipQosPolicyKind_EXCLUSIVE_OWNERSHIP_QOS
1047  */
1048  DDS_EXCLUSIVE_OWNERSHIP_QOS
1049 } DDS_OwnershipQosPolicyKind;
1050 
1051 /* ----------------------------------------------------------------- */
1052 /*e \dref_OwnershipQosPolicy
1053  */
1054 struct DDS_OwnershipQosPolicy
1055 {
1056  /*e \dref_OwnershipQosPolicy_kind
1057  */
1058  DDS_OwnershipQosPolicyKind kind;
1059 };
1060 
1061 /*i \dref_OwnershipQosPolicy_DEFAULT
1062  */
1063 #define DDS_OWNERSHIP_QOS_POLICY_DEFAULT { DDS_SHARED_OWNERSHIP_QOS }
1064 
1065 /* ----------------------------------------------------------------- */
1066 /* OWNERSHIP_STRENGTH */
1067 /* ----------------------------------------------------------------- */
1068 /*e \dref_OwnershipStrengthQosGroupDocs
1069  */
1070 
1071 /*e \dref_OWNERSHIPSTRENGTH_QOS_POLICY_NAME
1072  */
1073 extern DDSCDllVariable const char *const DDS_OWNERSHIPSTRENGTH_QOS_POLICY_NAME;
1074 
1075 /* ----------------------------------------------------------------- */
1076 /*e \dref_OwnershipStrengthQosPolicy
1077  */
1078 struct DDS_OwnershipStrengthQosPolicy
1079 {
1080  /*e \dref_OwnershipStrengthQosPolicy_value
1081  */
1082  DDS_Long value;
1083 };
1084 
1085 /*i \dref_OwnershipStrengthQosPolicy_DEFAULT
1086  */
1087 #define DDS_OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT { 0L }
1088 
1089 /* ----------------------------------------------------------------- */
1090 /* LIVELINESS */
1091 /* ----------------------------------------------------------------- */
1092 /*e \dref_LivelinessQosGroupDocs
1093  */
1094 
1095 /*e \dref_LIVELINESS_QOS_POLICY_NAME
1096  */
1097 extern DDSCDllVariable const char *const DDS_LIVELINESS_QOS_POLICY_NAME;
1098 
1099 /* ----------------------------------------------------------------- */
1100 /*e \dref_LivelinessQosPolicyKind
1101  */
1102 typedef enum
1103 {
1104  /*i \dref_LivelinessQosPolicyKind_AUTOMATIC_LIVELINESS_QOS
1105  */
1106  DDS_AUTOMATIC_LIVELINESS_QOS,
1107 
1108  /*i \dref_LivelinessQosPolicyKind_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
1109  */
1110  DDS_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
1111 
1112  /*e \dref_LivelinessQosPolicyKind_MANUAL_BY_TOPIC_LIVELINESS_QOS
1113  */
1114  DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS
1115 } DDS_LivelinessQosPolicyKind;
1116 
1117 /* ----------------------------------------------------------------- */
1118 /*e \dref_LivelinessQosPolicy
1119  */
1120 struct DDS_LivelinessQosPolicy
1121 {
1122  /*e \dref_LivelinessQosPolicy_kind
1123  */
1124  DDS_LivelinessQosPolicyKind kind;
1125 
1126  /*e \dref_LivelinessQosPolicy_lease_duration
1127  */
1128  struct DDS_Duration_t lease_duration;
1129 };
1130 
1131 /*i \dref_LivelinessQosPolicy_DEFAULT
1132  * Default least duration is infinite
1133  */
1134 #define DDS_LIVELINESS_QOS_POLICY_DEFAULT \
1135 {\
1136  DDS_AUTOMATIC_LIVELINESS_QOS,\
1137  DDS_DURATION_INFINITE_INITIALIZER \
1138 }
1139 
1140 /* ----------------------------------------------------------------- */
1141 /* RELIABILITY */
1142 /* ----------------------------------------------------------------- */
1143 /*e \dref_ReliabilityQosGroupDocs
1144  */
1145 
1146 /*e \dref_RELIABILITY_QOS_POLICY_NAME
1147  */
1148 extern DDSCDllVariable const char *const DDS_RELIABILITY_QOS_POLICY_NAME;
1149 
1150 /* ----------------------------------------------------------------- */
1151 /*e \dref_ReliabilityQosPolicyKind
1152  */
1153 typedef enum
1154 {
1155  /*e \dref_ReliabilityQosPolicyKind_BEST_EFFORT_RELIABILITY_QOS
1156  */
1157  DDS_BEST_EFFORT_RELIABILITY_QOS = 0x01,
1158 
1159  /*e \dref_ReliabilityQosPolicyKind_RELIABLE_RELIABILITY_QOS
1160  * NOTE: The RTPS spec defines reliability as 0x03 to comply with RTPS spec.
1161  * However, RTI Connext Core uses 0x3, as well as others.
1162  */
1163  DDS_RELIABLE_RELIABILITY_QOS = 0x02
1164 } DDS_ReliabilityQosPolicyKind;
1165 
1166 /* ----------------------------------------------------------------- */
1167 /*e \dref_ReliabilityQosPolicy
1168  */
1169 struct DDS_ReliabilityQosPolicy
1170 {
1171  /*e \dref_ReliabilityQosPolicy_kind
1172  */
1173  DDS_ReliabilityQosPolicyKind kind;
1174 
1175  /*e \dref_ReliabilityQosPolicy_max_blocking_time
1176  */
1177  struct DDS_Duration_t max_blocking_time;
1178 };
1179 
1180 /*i \dref_ReliabilityQosPolicy_DEFAULT
1181  */
1182 #define DDS_RELIABILITY_QOS_POLICY_DEFAULT \
1183  { DDS_BEST_EFFORT_RELIABILITY_QOS, \
1184  {0L, 0UL} }
1185 
1186 
1187 /* ----------------------------------------------------------------- */
1188 /* HISTORY */
1189 /* ----------------------------------------------------------------- */
1190 /*e \dref_HistoryQosGroupDocs
1191  */
1192 
1193 /*e \dref_HISTORY_QOS_POLICY_NAME
1194  */
1195 extern DDSCDllVariable const char *const DDS_HISTORY_QOS_POLICY_NAME;
1196 
1197 /* ----------------------------------------------------------------- */
1198 /*e \dref_HistoryQosPolicyKind
1199  */
1200 typedef enum
1201 {
1202  /*e \dref_HistoryQosPolicyKind_KEEP_LAST_HISTORY_QOS
1203  */
1204  DDS_KEEP_LAST_HISTORY_QOS,
1205 
1206  /*i \dref_HistoryQosPolicyKind_KEEP_ALL_HISTORY_QOS
1207  */
1208  DDS_KEEP_ALL_HISTORY_QOS
1209 } DDS_HistoryQosPolicyKind;
1210 
1211 /*ci \brief The maximum allowed history depth.
1212  *
1213  * \details
1214  * The maximum depth is the maximum positive integer which can be
1215  * represented by a 32 bit signed integer.
1216  */
1217 #define DDS_MAX_DEPTH_HISTORY_QOS (2147483647)
1218 
1219 /* ----------------------------------------------------------------- */
1220 /*e \dref_HistoryQosPolicy
1221  */
1222 struct DDS_HistoryQosPolicy
1223 {
1224  /*e \dref_HistoryQosPolicy_kind
1225  */
1226  DDS_HistoryQosPolicyKind kind;
1227 
1228  /*e \dref_HistoryQosPolicy_depth
1229  */
1230  DDS_Long depth;
1231 };
1232 
1233 /*i \dref_HistoryQosPolicy_DEFAULT
1234  */
1235 #define DDS_HISTORY_QOS_POLICY_DEFAULT { DDS_KEEP_LAST_HISTORY_QOS, \
1236  1L /* depth */ }
1237 
1238 /* ----------------------------------------------------------------- */
1239 /* DURABILITY */
1240 /* ----------------------------------------------------------------- */
1241 /*e \dref_DurabilityQosGroupDocs
1242 */
1243 
1244 /*e \dref_DURABILITY_QOS_POLICY_NAME
1245  */
1246 extern DDSCDllVariable const char *const DDS_DURABILITY_QOS_POLICY_NAME;
1247 
1248 /* ----------------------------------------------------------------- */
1249 /*e \dref_DurabilityQosPolicyKind
1250 */
1251 typedef enum
1252 {
1253  /*e \dref_DurabilityQosPolicyKind_VOLATILE_DURABILITY_QOS
1254  */
1255  DDS_VOLATILE_DURABILITY_QOS,
1256 
1257  /*e \dref_DurabilityQosPolicyKind_TRANSIENT_LOCAL_DURABILITY_QOS
1258  */
1259  DDS_TRANSIENT_LOCAL_DURABILITY_QOS,
1260 
1261  /*i \dref_DurabilityQosPolicyKind_TRANSIENT_DURABILITY_QOS
1262  */
1263  DDS_TRANSIENT_DURABILITY_QOS,
1264 
1265  /*i \dref_DurabilityQosPolicyKind_PERSISTENT_DURABILITY_QOS
1266  */
1267  DDS_PERSISTENT_DURABILITY_QOS
1268 } DDS_DurabilityQosPolicyKind;
1269 
1270 /* ----------------------------------------------------------------- */
1271 /*e \dref_DurabilityQosPolicy
1272  */
1273 struct DDS_DurabilityQosPolicy
1274 {
1275  /*e \dref_DurabilityQosPolicy_kind
1276  */
1277  DDS_DurabilityQosPolicyKind kind;
1278 };
1279 
1280 /*i \dref_DurabilityQosPolicy_DEFAULT
1281  */
1282 #define DDS_DURABILITY_QOS_POLICY_DEFAULT \
1283 { DDS_VOLATILE_DURABILITY_QOS }
1284 
1285 /* ----------------------------------------------------------------- */
1286 /* RESOURCE_LIMITS */
1287 /* ----------------------------------------------------------------- */
1288 /*e \dref_ResourceLimitsQosGroupDocs
1289  */
1290 
1291 /*e \dref_RESOURCELIMITS_QOS_POLICY_NAME
1292  */
1293 extern DDSCDllVariable const char *const DDS_RESOURCELIMITS_QOS_POLICY_NAME;
1294 
1295 /*e \dref_LENGTH_UNLIMITED
1296  */
1297 extern DDSCDllVariable const DDS_Long DDS_LENGTH_UNLIMITED;
1298 
1299 /*e \dref_LENGTH_AUTO
1300  */
1301 extern DDSCDllVariable const DDS_Long DDS_LENGTH_AUTO;
1302 
1303 /* ----------------------------------------------------------------- */
1304 /*e \dref_ResourceLimitsQosPolicy
1305  */
1306 struct DDS_ResourceLimitsQosPolicy
1307 {
1308  /*e \dref_ResourceLimitsQosPolicy_max_samples
1309  */
1310  DDS_Long max_samples;
1311 
1312  /*e \dref_ResourceLimitsQosPolicy_max_instances
1313  */
1314  DDS_Long max_instances;
1315 
1316  /*e \dref_ResourceLimitsQosPolicy_max_samples_per_instance
1317  */
1318  DDS_Long max_samples_per_instance;
1319 };
1320 
1321 /*i \dref_ResourceLimitsQosPolicy_DEFAULT
1322  */
1323 #define DDS_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1324  1L, /* max_samples */ \
1325  1L, /* max_instances */ \
1326  1L, /* max_samples_per_instance */ \
1327 }
1328 
1329 /* ----------------------------------------------------------------- */
1330 /*e \dref_DataReaderResourceLimitsInstanceReplacementKind
1331 */
1332 typedef enum
1333 {
1334  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_NO_INSTANCE_REPLACEMENT_QOS
1335  */
1336  DDS_NO_INSTANCE_REPLACEMENT_QOS,
1337 
1338  /*e \dref_DataReaderResourceLimitsInstanceReplacementKind_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1339  */
1340  DDS_REPLACE_OLDEST_INSTANCE_REPLACEMENT_QOS
1341 } DDS_DataReaderResourceLimitsInstanceReplacementKind;
1342 
1343 /* ----------------------------------------------------------------- */
1344 /* DATAREADER_RESOURCE_LIMITS */
1345 /* ----------------------------------------------------------------- */
1346 /*e \dref_DataReaderResourceLimitsQosGroupDocs
1347  */
1348 
1349 /*e \dref_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME
1350  */
1351 extern DDSCDllVariable const char *const
1352  DDS_DATAREADERRESOURCELIMITS_QOS_POLICY_NAME;
1353 
1354 /* ----------------------------------------------------------------- */
1355 /*e \dref_DataReaderResourceLimitsQosPolicy
1356  */
1357 struct DDS_DataReaderResourceLimitsQosPolicy
1358 {
1359  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers
1360  */
1361  DDS_Long max_remote_writers;
1362 
1363  /*e \dref_DataReaderResourceLimitsQosPolicy_max_remote_writers_per_instance
1364  */
1365  DDS_Long max_remote_writers_per_instance;
1366 
1367  /*e \dref_DataReaderResourceLimitsQosPolicy_max_samples_per_remote_writer
1368  */
1369  DDS_Long max_samples_per_remote_writer;
1370 
1371  /*e \dref_DataReaderResourceLimitsQosPolicy_max_outstanding_reads
1372  */
1373  DDS_Long max_outstanding_reads;
1374 
1375  /*e \dref_DataReaderResourceLimitsQosPolicy_instance_replacement
1376  */
1377  DDS_DataReaderResourceLimitsInstanceReplacementKind instance_replacement;
1378 
1379  /*e \dref_DataReaderResourceLimitsQosPolicy_max_routes_per_writer
1380  */
1381  DDS_Long max_routes_per_writer;
1382 };
1383 
1384 /*i \dref_DataReaderResourceLimitsQosPolicy_DEFAULT
1385  */
1386 #define DDS_DATAREADERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1387  1L, /* max_remote_writers */ \
1388  1L, /* max_remote_writers_per_instance */ \
1389  1L, /* max_samples_per_remote_writer */ \
1390  1L, /* max_outstanding_reads */ \
1391  DDS_NO_INSTANCE_REPLACEMENT_QOS, /* Default */ \
1392  4\
1393 }
1394 
1395 /* ----------------------------------------------------------------- */
1396 /* DATAWRITER_RESOURCE_LIMITS */
1397 /* ----------------------------------------------------------------- */
1398 /*e \dref_DataWriterResourceLimitsQosGroupDocs
1399  */
1400 
1401 /*e \dref_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME
1402  */
1403 extern DDSCDllVariable const char *const
1404  DDS_DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME;
1405 
1406 /* ----------------------------------------------------------------- */
1407 /*e \dref_DataWriterResourceLimitsQosPolicy
1408  */
1409 struct DDS_DataWriterResourceLimitsQosPolicy
1410 {
1411  /*e \dref_DataWriterResourceLimitsQosPolicy_max_remote_readers
1412  */
1413  DDS_Long max_remote_readers;
1414 
1415  /*e \dref_DataWriterResourceLimitsQosPolicy_max_routes_per_reader
1416  */
1417  DDS_Long max_routes_per_reader;
1418 };
1419 
1420 /*i \dref_DataWriterResourceLimitsQosPolicy_DEFAULT
1421  */
1422 #define DDS_DATAWRITERRESOURCE_LIMITS_QOS_POLICY_DEFAULT { \
1423  16L, /* max_remote_readers */ \
1424  4\
1425 }
1426 
1427 /* ----------------------------------------------------------------- */
1428 /* ENTITY_FACTORY */
1429 /* ----------------------------------------------------------------- */
1430 /*e \dref_EntityFactoryQosGroupDocs
1431  */
1432 
1433 /*e \dref_ENTITYFACTORY_QOS_POLICY_NAME
1434  */
1435 extern DDSCDllVariable const char *const DDS_ENTITYFACTORY_QOS_POLICY_NAME;
1436 
1437 /* ----------------------------------------------------------------- */
1438 /*e \dref_EntityFactoryQosPolicy
1439  */
1440 struct DDS_EntityFactoryQosPolicy
1441 {
1442  /*e \dref_EntityFactoryQosPolicy_autoenable_created_entities
1443  */
1444  DDS_Boolean autoenable_created_entities;
1445 };
1446 
1447 /*i \dref_EntityFactoryQosPolicy_DEFAULT
1448  */
1449 #define DDS_ENTITY_FACTORY_QOS_POLICY_DEFAULT { DDS_BOOLEAN_TRUE }
1450 
1451 /* ----------------------------------------------------------------- */
1452 /* EXTENDED QOS SUPPORT */
1453 /* ----------------------------------------------------------------- */
1454 
1455 /* ----------------------------------------------------------------- */
1456 /*e
1457  * \dref_ExtendedQosSupportGroupDocs
1458  */
1459 #define DDS_LENGTH_UNLIMITED (-1)
1460 
1461 #define DDS_LENGTH_AUTO (-2)
1462 
1463 /* ----------------------------------------------------------------- */
1464 
1465 /* ----------------------------------------------------------------- */
1466 /* TYPESUPPORT */
1467 /* ----------------------------------------------------------------- */
1468 /*i \dref_TypeSupportQosGroupDocs
1469 */
1470 
1471 /*i \dref_TYPESUPPORT_QOS_POLICY_NAME
1472  */
1473 extern DDSCDllVariable const char *const DDS_TYPESUPPORT_QOS_POLICY_NAME;
1474 
1475 /* ----------------------------------------------------------------- */
1476 /*i \dref_TypeSupportQosPolicy
1477  */
1478 struct DDS_TypeSupportQosPolicy
1479 {
1480  /*e \dref_TypeSupportQosPolicy_plugin_data
1481  */
1482  void *plugin_data;
1483 };
1484 
1485 /*i \dref_TypeSupportQosPolicy_DEFAULT
1486  */
1487 #define DDS_TYPESUPPORT_QOS_POLICY_DEFAULT \
1488 { NULL }
1489 
1490 /* ----------------------------------------------------------------- */
1491 /* SYSTEM_RESOURCE_LIMITS_X (eXtension QoS) */
1492 /* ----------------------------------------------------------------- */
1493 /*e \dref_SystemResourceLimitsQosGroupDocs
1494  */
1495 
1496 /*e \dref_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME
1497  */
1498 extern DDSCDllVariable const char *const DDS_SYSTEMRESOURCELIMITS_QOS_POLICY_NAME;
1499 
1500 /* ----------------------------------------------------------------- */
1501 
1502 /*e \dref_SystemResourceLimitsQosPolicy
1503  */
1504 struct DDS_SystemResourceLimitsQosPolicy
1505 {
1506  /*e \dref_SystemResourceLimitsQosPolicy_max_participants
1507  */
1508  DDS_Long max_participants;
1509 
1510  /*e \dref_SystemResourceLimitsQosPolicy_max_components
1511  */
1512  DDS_Long max_components;
1513 };
1514 
1515 /*i \dref_SystemResourceLimitsQosPolicy_DEFAULT
1516  */
1517 #define DDS_SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT { 1L,16L }
1518 
1519 /* ----------------------------------------------------------------- */
1520 /* WIRE_PROTOCOL_X (eXtension QoS) */
1521 /* ----------------------------------------------------------------- */
1522 /*e \dref_WireProtocolQosGroupDocs
1523  */
1524 
1525 #define DDS_RtpsWellKnownPorts NETIO_RtpsPortParam
1526 
1527 /*e \dref_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS
1528  */
1529 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1530  DDS_RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS;
1531 
1532 /*e \dref_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS
1533  */
1534 extern DDSCDllVariable struct DDS_RtpsWellKnownPorts_t
1535  DDS_INTEROPERABLE_RTPS_WELL_KNOWN_PORTS;
1536 
1537 /*i @ingroup DDSWireProtocolQosModule
1538  these defaults are compatible with >= 4.2d
1539  */
1540 
1541 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1542 /*e \dref_RtpsWellKnownPorts_t
1543  */
1544 struct DDS_RtpsWellKnownPorts_t
1545 {
1546  /*e \dref_RtpsWellKnownPorts_t_port_base
1547  */
1548  DDS_Long port_base;
1549 
1550  /*e \dref_RtpsWellKnownPorts_t_domain_id_gain
1551  */
1552  DDS_Long domain_id_gain;
1553 
1554  /*e \dref_RtpsWellKnownPorts_t_participant_id_gain
1555  */
1556  DDS_Long participant_id_gain;
1557 
1558  /*e \dref_RtpsWellKnownPorts_t_builtin_multicast_port_offset
1559  */
1560  DDS_Long builtin_multicast_port_offset;
1561 
1562  /*e \dref_RtpsWellKnownPorts_t_builtin_unicast_port_offset
1563  */
1564  DDS_Long builtin_unicast_port_offset;
1565 
1566  /*e \dref_RtpsWellKnownPorts_t_user_multicast_port_offset
1567  */
1568  DDS_Long user_multicast_port_offset;
1569 
1570  /*e \dref_RtpsWellKnownPorts_t_user_unicast_port_offset
1571  */
1572  DDS_Long user_unicast_port_offset;
1573 };
1574 
1575 #endif /* DOXYGEN_DOCUMENTATION_ONLY */
1576 
1577 #define DDS_RtpsWellKnownPorts_t DDS_RtpsWellKnownPorts
1578 
1579 /*i \dref_RtpsWellKnownPorts_DEFAULT
1580  */
1581 #define DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT \
1582 { \
1583  7400, /* port_base */ \
1584  250, /* domain_id_gain */ \
1585  2, /* participant_id_gain */ \
1586  0, /* builtin_multicast_port_offset */ \
1587  10, /* builtin_unicast_port_offset */ \
1588  1, /* user_multicast_port_offset */ \
1589  11 /* user_unicast_port_offset */ \
1590 }
1591 
1592 /*e \dref_WIREPROTOCOL_QOS_POLICY_NAME
1593  */
1594 extern DDSCDllVariable const char *const DDS_WIREPROTOCOL_QOS_POLICY_NAME;
1595 
1596 /* ----------------------------------------------------------------- */
1597 /*e \dref_WireProtocolQosPolicy
1598  */
1599 struct DDS_WireProtocolQosPolicy
1600 {
1601  /*e \dref_WireProtocolQosPolicy_participant_id
1602  */
1603  DDS_Long participant_id;
1604 
1605  /*e \dref_WireProtocolQosPolicy_rtps_host_id
1606  */
1607  DDS_UnsignedLong rtps_host_id;
1608 
1609  /*e \dref_WireProtocolQosPolicy_rtps_app_id
1610  */
1611  DDS_UnsignedLong rtps_app_id;
1612 
1613  /*e \dref_WireProtocolQosPolicy_rtps_instance_id
1614  */
1615  DDS_UnsignedLong rtps_instance_id;
1616 
1617  /*e \dref_WireProtocolQosPolicy_rtps_well_known_ports
1618  */
1619  struct DDS_RtpsWellKnownPorts_t rtps_well_known_ports;
1620 };
1621 
1622 /*e
1623  */
1624 enum
1625 {
1626  /*e \dref_WireProtocolQosPolicy_RTPS_AUTO_ID
1627  */
1628  DDS_RTPS_AUTO_ID = 0
1629 };
1630 
1631 /*i \dref_WireProtocolQosPolicy_DEFAULT
1632  */
1633 #define DDS_WIRE_PROTOCOL_QOS_POLICY_DEFAULT { \
1634 -1 /* auto participant_id */, \
1635 DDS_RTPS_AUTO_ID /* rtps_host_id */, \
1636 DDS_RTPS_AUTO_ID /* rtps_app_id */, \
1637 DDS_RTPS_AUTO_ID /* rtps_instance_id */, \
1638 DDS_RTPS_WELL_KNOWN_PORTS_DEFAULT /* rtps_well_known_ports */\
1639 }
1640 
1641 /* ----------------------------------------------------------------- */
1642 
1643 /*i
1644  * Alias for DDS_Locator
1645  */
1646 #define DDS_Locator RTPS_Locator
1647 
1648 /*i
1649  * Alias for DDS_Locator_t
1650  */
1651 #define DDS_Locator_t RTPS_Locator_t
1652 
1653 /*i
1654  * Alias for DDS_LocatorUdpv4_t
1655  */
1656 #define DDS_LocatorUdpv4_t RTPS_LocatorUdpv4_t
1657 
1658 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1659 
1660 /*e \dref_Locator_t
1661  */
1662 struct DDS_Locator_t
1663 {
1664  /*e \dref_Locator_t_kind
1665  */
1666  DDS_Long kind;
1667 
1668  /*e \dref_Locator_t_port
1669  */
1670  DDS_UnsignedLong port;
1671 
1672  /*e \dref_Locator_t_address
1673  */
1674  DDS_Octet address[RTPS_LOCATOR_ADDRESS_LENGTH_MAX];
1675 };
1676 
1677 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1678 
1679 #define T struct RTPS_Locator
1680 #define TSeq DDS_LocatorSeq
1681 #define REDA_SEQUENCE_USER_API
1682 #define TSeq_is_equal
1683 #include <reda/reda_sequence_decl.h>
1684 
1685 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1686 /*e \dref_LocatorSeq
1687  */
1688 struct DDS_LocatorSeq {};
1689 #endif
1690 
1691 /*e
1692  * \dref_Locator_t_INVALID
1693  */
1694 #define DDS_LOCATOR_INVALID RTPS_LOCATOR_INVALID
1695 
1696 #ifndef RTI_CERT
1697 /*e
1698  * \dref_Locator_t_DEFAULT
1699  */
1700 #define DDS_LOCATOR_DEFAULT RTPS_LOCATOR_DEFAULT
1701 
1702 /*e
1703  * \dref_Locator_t_KIND_INVALID
1704  */
1705 #define DDS_LOCATOR_KIND_INVALID RTPS_LOCATOR_KIND_INVALID
1706 
1707 /*e
1708  * \dref_Locator_t_PORT_INVALID
1709  */
1710 #define DDS_LOCATOR_PORT_INVALID RTPS_LOCATOR_PORT_INVALID
1711 
1712 /*e
1713  * \dref_Locator_t_ADDRESS_INVALID
1714  */
1715 #define DDS_LOCATOR_ADDRESS_INVALID RTPS_LOCATOR_ADDRESS_INVALID
1716 
1717 #endif /* !RTI_CERT */
1718 
1719 
1720 /*e
1721  * \dref_Locator_t_KIND_UDPv4
1722  */
1723 #define DDS_LOCATOR_KIND_UDPv4 RTPS_LOCATOR_KIND_UDPv4
1724 
1725 /*e
1726  * \dref_Locator_t_KIND_UDPv6
1727  */
1728 #define DDS_LOCATOR_KIND_UDPv6 RTPS_LOCATOR_KIND_UDPv6
1729 
1730 /*e
1731  * \dref_Locator_t_KIND_RESERVED
1732  */
1733 #define DDS_LOCATOR_KIND_RESERVED RTPS_LOCATOR_KIND_RESERVED
1734 
1735 /*e
1736  * \dref_Locator_t_KIND_SHMEM
1737  */
1738 #define DDS_LOCATOR_KIND_SHMEM RTPS_LOCATOR_KIND_SHMEM
1739 
1740 /* ----------------------------------------------------------------- */
1741 
1742 /*e \dref_ProtocolVersion_t
1743  */
1744 typedef struct DDS_ProtocolVersion
1745 {
1746  /*e \dref_ProtocolVersion_t_major
1747  */
1748  DDS_Octet major;
1749 
1750  /*e \dref_ProtocolVersion_t_minor
1751  */
1752  DDS_Octet minor;
1753 } DDS_ProtocolVersion_t;
1754 
1755 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProtocolVersion);
1756 
1757 /*i \dref_ProtocolVersion_DEFAULT
1758  */
1759 #define DDS_PROTOCOL_VERSION_DEFAULT { 0, 0 }
1760 
1761 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_0
1762  */
1763 #define DDS_PROTOCOLVERSION_1_0 { 1, 0 }
1764 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_1
1765  */
1766 #define DDS_PROTOCOLVERSION_1_1 { 1, 1 }
1767 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_1_2
1768  */
1769 #define DDS_PROTOCOLVERSION_1_2 { 1, 2 }
1770 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1771  */
1772 #define DDS_PROTOCOLVERSION_2_0 { 2, 0 }
1773 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION_2_1
1774  */
1775 #define DDS_PROTOCOLVERSION_2_1 { 2, 1 }
1776 /*e \dref_ProtocolVersion_t_PROTOCOLVERSION
1777  */
1778 #define DDS_PROTOCOLVERSION { 2, 1 }
1779 
1780 /*e \dref_VendorId_t_LENGTH_MAX
1781  */
1782 #define DDS_VENDOR_ID_LENGTH_MAX 2
1783 
1784 /*e \dref_VendorId_t
1785  */
1786 struct DDS_VendorId
1787 {
1788  /*e \dref_VendorId_t_vendorId
1789  */
1790  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1791 };
1792 
1793 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1794 /*e \dref_VendorId_t
1795  */
1796 struct DDS_VendorId_t
1797 {
1798  /*e \dref_VendorId_t_vendorId
1799  */
1800  DDS_Octet vendorId[DDS_VENDOR_ID_LENGTH_MAX];
1801 };
1802 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1803 
1804 
1805 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_VendorId);
1806 #define DDS_VendorId_t DDS_VendorId
1807 
1808 /*i \dref_VendorId_dEFAULT
1809  */
1810 #define DDS_VENDOR_ID_DEFAULT { {0, 0} }
1811 
1812 /*i \dref_VendorId_t_VENDORID_UNKNOWN
1813  */
1814 #define DDS_VENDORID_UNKNOWN { {0, 0} }
1815 
1816 /* ----------------------------------------------------------------- */
1817 
1818 /*e \dref_ProductVersion_t
1819  */
1820 struct DDS_ProductVersion
1821 {
1822  /*e \dref_ProductVersion_t_major
1823  */
1824  DDS_Char major;
1825 
1826  /*e \dref_ProductVersion_t_minor
1827  */
1828  DDS_Char minor;
1829 
1830  /*e \dref_ProductVersion_t_release
1831  */
1832  DDS_Char release;
1833 
1834  /*e \dref_ProductVersion_t_revision
1835  */
1836  DDS_Char revision;
1837 };
1838 
1839 
1840 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1841 /*e \dref_ProductVersion_t
1842  */
1843 struct DDS_ProductVersion_t
1844 {
1845  /*e \dref_ProductVersion_t_major
1846  */
1847  DDS_Char major;
1848  /*e \dref_ProductVersion_t_minor
1849  */
1850  DDS_Char minor;
1851  /*e \dref_ProductVersion_t_release
1852  */
1853  DDS_Char release;
1854  /*e \dref_ProductVersion_t_revision
1855  */
1856  DDS_Char revision;
1857 };
1858 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
1859 
1860 #define DDS_ProductVersion_t DDS_ProductVersion
1861 DDSC_VARIABLE_LENGTH_VALUE_TYPE_SUPPORT_BASIC(DDS_ProductVersion);
1862 
1863 /*e \dref_ProductVersion_t_UNKNOWN
1864  */
1865 #define DDS_PRODUCTVERSION_UNKNOWN { 0, 0, '0', 0 }
1866 
1867 /*i \dref_ProductVersion_DEFAULT
1868  */
1869 #define DDS_PRODUCTVERSION_DEFAULT { 2, 0, 'c', 1 }
1870 
1871 
1872 /* ----------------------------------------------------------------- */
1873 /* DATA_READER_PROTOCOL_X (eXtension QoS) */
1874 /* ----------------------------------------------------------------- */
1875 /*e \dref_DataReaderProtocolQosGroupDocs
1876  */
1877 
1878 /*e \dref_DATAREADERPROTOCOL_QOS_POLICY_NAME
1879  */
1880 extern DDSCDllVariable const char *const DDS_DATAREADERPROTOCOL_QOS_POLICY_NAME;
1881 
1882 /* ----------------------------------------------------------------- */
1883 /*e \dref_DataReaderProtocolQosPolicy
1884  */
1885 struct DDS_DataReaderProtocolQosPolicy
1886 {
1887  /*e \dref_DataReaderProtocolQosPolicy_rtps_object_id
1888  */
1889  DDS_UnsignedLong rtps_object_id;
1890 };
1891 
1892 /*i \dref_DataReaderProtocolQosPolicy_DEFAULT
1893  */
1894 #define DDS_DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT \
1895 { \
1896  DDS_RTPS_AUTO_ID \
1897 }
1898 
1899 /* ----------------------------------------------------------------- */
1900 
1901 /*e \dref_RtpsReliableWriterProtocol_t
1902  */
1903  struct DDS_RtpsReliableWriterProtocol_t
1904  {
1905  /*e \dref_RtpsReliableWriterProtocol_t_heartbeat_period
1906  */
1907  struct DDS_Duration_t heartbeat_period;
1908 
1909  /*e \dref_RtpsReliableWriterProtocol_t_heartbeats_per_max_samples
1910  */
1911  DDS_Long heartbeats_per_max_samples;
1912 
1913  /*e \dref_RtpsReliableWriterProtocol_t_max_send_window
1914  */
1915  DDS_Long max_send_window;
1916 
1917  /*e \dref_RtpsReliableWriterProtocol_t_max_heartbeat_retries
1918  */
1919  DDS_Long max_heartbeat_retries;
1920 
1921  /*i \dref_RtpsReliableWriterProtocol_t_first_write_sequence_number
1922  */
1923  struct DDS_SequenceNumber_t first_write_sequence_number;
1924  };
1925 
1926 #define DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW (DDS_LENGTH_UNLIMITED)
1927 
1928 /*i \dref_RtpsReliableWriterProtocol_DEFAULT
1929  */
1930 #define DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT { \
1931  {3,0}, /* hb_period */ \
1932  1, /* hb_per_max_samples */ \
1933  DDS_RTPSRELIABLEWRITER_DEFAULT_SEND_WINDOW, /* max_send_window */ \
1934  DDS_LENGTH_UNLIMITED, /* max_heartbeat_retries */ \
1935  {0,1} /* first_write_sequence_number */\
1936 }
1937 
1938 /* ----------------------------------------------------------------- */
1939 /* DATA_WRITER_PROTOCOL_X (eXtension QoS) */
1940 /* ----------------------------------------------------------------- */
1941 /*e \dref_DataWriterProtocolQosGroupDocs
1942  */
1943 
1944 /*e \dref_DATAWRITERPROTOCOL_QOS_POLICY_NAME
1945  */
1946 extern DDSCDllVariable const char *const DDS_DATAWRITERPROTOCOL_QOS_POLICY_NAME;
1947 
1948 /* ----------------------------------------------------------------- */
1949 /*e \dref_DataWriterProtocolQosPolicy
1950  */
1951 struct DDS_DataWriterProtocolQosPolicy
1952 {
1953  /*e \dref_DataWriterProtocolQosPolicy_rtps_object_id
1954  */
1955  DDS_UnsignedLong rtps_object_id;
1956 
1957  /*e \dref_DataWriterProtocolQosPolicy_rtps_reliable_writer
1958  */
1959  struct DDS_RtpsReliableWriterProtocol_t rtps_reliable_writer;
1960 
1961  /*e \dref_DataWriterProtocolQosPolicy_serialize_on_write
1962  */
1963  DDS_Boolean serialize_on_write;
1964 };
1965 
1966 /*i \dref_DataWriterProtocolQosPolicy_DEFAULT
1967  */
1968 #define DDS_DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT \
1969 { DDS_RTPS_AUTO_ID, \
1970  DDS_RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT,\
1971  RTI_TRUE \
1972 }
1973 
1974 /* ----------------------------------------------------------------- */
1975 /* TRANSPORT_QOS_POLICY (eXtension QoS) */
1976 /* ----------------------------------------------------------------- */
1977 /*e \dref_TransportQosGroupDocs
1978  */
1979 
1980 /*e \dref_TRANSPORT_QOS_POLICY_NAME
1981  */
1982 extern DDSCDllVariable const char *const DDS_TRANSPORT_QOS_POLICY_NAME;
1983 
1984 /* ----------------------------------------------------------------- */
1985 #ifdef DOXYGEN_DOCUMENTATION_ONLY
1986 /*i \dref_StringSeq
1987  */
1988 struct DDS_StringSeq {};
1989 #endif
1990 
1991 
1992 /*e \dref_TransportQosPolicy
1993  */
1994 struct DDS_TransportQosPolicy
1995 {
1996  /*e \dref_TransportQosPolicy_enabled_transports
1997  */
1998  struct DDS_StringSeq enabled_transports;
1999 };
2000 
2001 /*i \dref_TransportQosPolicy_DEFAULT
2002  */
2003 #define DDS_TRANSPORT_QOS_POLICY_DEFAULT \
2004 {\
2005  DDS_SEQUENCE_INITIALIZER \
2006 }
2007 
2008 /* ----------------------------------------------------------------- */
2009 /* DOMAIN_PARTICIPANT_RESOURCE_LIMITS_X (eXtension QoS) */
2010 /* ----------------------------------------------------------------- */
2011 /*e \dref_DomainParticipantResourceLimitsQosGroupDocs
2012  */
2013 
2014 /*e \dref_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME
2015  */
2016 extern DDSCDllVariable const char *const
2017  DDS_DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME;
2018 
2019 /* ----------------------------------------------------------------- */
2020 
2021 /*e \dref_DomainParticipantResourceLimitsQosPolicy
2022  */
2023 struct DDS_DomainParticipantResourceLimitsQosPolicy
2024 {
2025  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_writer_allocation
2026  */
2027  DDS_Long local_writer_allocation;
2028 
2029  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_reader_allocation
2030  */
2031  DDS_Long local_reader_allocation;
2032 
2033  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_publisher_allocation
2034  */
2035  DDS_Long local_publisher_allocation;
2036 
2037  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_subscriber_allocation
2038  */
2039  DDS_Long local_subscriber_allocation;
2040 
2041  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_topic_allocation
2042  */
2043  DDS_Long local_topic_allocation;
2044 
2045  /*e \dref_DomainParticipantResourceLimitsQosPolicy_local_type_allocation
2046  */
2047  DDS_Long local_type_allocation;
2048 
2049  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_participant_allocation
2050  */
2051  DDS_Long remote_participant_allocation;
2052 
2053  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_writer_allocation
2054  */
2055  DDS_Long remote_writer_allocation;
2056 
2057  /*e \dref_DomainParticipantResourceLimitsQosPolicy_remote_reader_allocation
2058  */
2059  DDS_Long remote_reader_allocation;
2060 
2061  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_writer_reader_pair_allocation
2062  */
2063  DDS_Long matching_writer_reader_pair_allocation;
2064 
2065  /*e \dref_DomainParticipantResourceLimitsQosPolicy_matching_reader_writer_pair_allocation
2066  */
2067  DDS_Long matching_reader_writer_pair_allocation;
2068 
2069  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_receive_ports
2070  */
2071  DDS_Long max_receive_ports;
2072 
2073  /*e \dref_DomainParticipantResourceLimitsQosPolicy_max_destination_ports
2074  */
2075  DDS_Long max_destination_ports;
2076 };
2077 
2078 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2079  *
2080  * This constant is used below in
2081  * DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT; other types
2082  * should not use it alone.
2083  */
2084 #define DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT (32L)
2085 
2086 
2087 /*i @ingroup DDSDomainParticipantResourceLimitsQosModule
2088  *
2089  * Several fields in this structure are actually never used. These fields
2090  * should be explicitly initialized when this structure is copied
2091  * from a lower layer structure to prevent the values from being left in
2092  * an uninitialized state. The unused fields include:
2093  *
2094  * - local_publisher_allocation.max_count
2095  * - local_subscriber_allocation.max_count
2096  * - local_topic_allocation.max_count
2097  * - matching_writer_reader_pair_allocation.initial_count
2098  * - matching_writer_reader_pair_allocation.max_count
2099  * - matching_reader_writer_pair_allocation.initial_count
2100  * - matching_reader_writer_pair_allocation.max_count
2101  */
2102 /*i \dref_DomainParticipantReasourceLimitsQosPolicy_DEFAULT
2103  */
2104 #define DDS_DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT \
2105 {1L, /*local_writer_allocation*/ \
2106  1L, /*local_reader_allocation*/ \
2107  1L, /*local_publisher_allocation*/ \
2108  1L, /*local_subscriber_allocation*/ \
2109  1L, /*local_topic_allocation*/ \
2110  1L, /*local_type_allocation*/ \
2111  1L, /*remote_participant_allocation*/ \
2112  1L, /*remote_writer_allocation*/ \
2113  1L, /*remote_reader_allocation*/ \
2114  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2115  DDS_DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, \
2116  8L,\
2117  8L \
2118 }
2119 
2120 /* ----------------------------------------------------------------- */
2121 
2122 /*i \dref_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH
2123  */
2124 #define DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH (4)
2125 
2126 /*e \dref_BuiltinTopicKey_t
2127  */
2128 typedef struct DDS_BuiltinTopicKey_t
2129 {
2130  /*e \dref_BuiltinTopicKey_t_value
2131  */
2132  DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE value[DDS_BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH];
2133 } DDS_BuiltinTopicKey_t;
2134 
2135 /*i @ingroup BuiltinTopicGroupDocs
2136  */
2137 #define DDS_BuiltinTopicKey_t_INITIALIZER { {0, 0, 0, 0} }
2138 
2139 /*e \dref_BuiltinTopicKey_t_AUTO
2140  */
2141 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_AUTO;
2142 
2143 /*e \dref_BuiltinTopicKey_t_UNKNOWN
2144  */
2145 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_UNKNOWN;
2146 
2147 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2148  */
2149 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_UNKNOWN;
2150 
2151 /*i \dref_BuiltinTopicKey_t_PREFIX_UNKNOWN
2152  */
2153 extern DDSCDllVariable const struct DDS_BuiltinTopicKey_t DDS_BUILTINTOPICKEY_PREFIX_AUTO;
2154 
2155 /*i \ingroup BuiltinTopicGroupDocs_equals
2156 */
2157 DDSCDllExport DDS_Boolean
2158 DDS_BuiltinTopicKey_equals(const DDS_BuiltinTopicKey_t *a,
2159  const DDS_BuiltinTopicKey_t *b);
2160 
2161 /*i \ingroup BuiltinTopicGroupDocs_prefix_equals
2162  */
2163 DDSCDllExport DDS_Boolean
2164 DDS_BuiltinTopicKey_prefix_equals(const DDS_BuiltinTopicKey_t *a,
2165  const DDS_BuiltinTopicKey_t *b);
2166 
2167 /*i \ingroup BuiltinTopicGroupDocs_suffix_equals
2168  */
2169 DDSCDllExport DDS_Boolean
2170 DDS_BuiltinTopicKey_suffix_equals(const DDS_BuiltinTopicKey_t *a,
2171  const DDS_BuiltinTopicKey_t *b);
2172 
2173 /*i \ingroup BuiltinTopicGroupDocs_copy_prefix
2174  */
2175 DDSCDllExport void
2176 DDS_BuiltinTopicKey_copy_prefix(DDS_BuiltinTopicKey_t *a,
2177  const DDS_BuiltinTopicKey_t *b);
2178 
2179 /*i \ingroup BuiltinTopicGroupDocs_copy_suffix
2180  */
2181 DDSCDllExport void
2182 DDS_BuiltinTopicKey_copy_suffix(DDS_BuiltinTopicKey_t *a,
2183  const DDS_BuiltinTopicKey_t *b);
2184 
2185 /*i \ingroup BuiltinTopicGroupDocs_from_guid
2186  */
2187 DDSCDllExport void
2188 DDS_BuiltinTopicKey_from_guid(DDS_BuiltinTopicKey_t *in,
2189  const DDS_InstanceHandle_t *out);
2190 /*ci
2191  * \brief Compare two DDS_BuiltinTopicKey_t structure for ordering
2192  *
2193  * \param[in] left Left side of comparison
2194  * \param[in] right Right side of comparison
2195  *
2196  * \return positive integer if left is greater than right,
2197  * negative integer if left is less than right,
2198  * zero if left is equal to right
2199  */
2200 DDSCDllExport DDS_Long
2201 DDS_BuiltinTopicKey_compare(const DDS_BuiltinTopicKey_t *left,
2202  const DDS_BuiltinTopicKey_t *right);
2203 
2204 /* ================================================================= */
2205 /* Condition and Waitsets */
2206 /* ================================================================= */
2207 
2208 /*ce \dref_Entity
2209  */
2210 typedef struct DDS_EntityImpl DDS_Entity;
2211 
2212 /* ----------------------------------------------------------------- */
2213 /*e \dref_ConditionsAndWaitsetsModuleDocs
2214  */
2215 
2216 /*ce \dref_Condition
2217  */
2218 typedef struct DDS_ConditionImpl DDS_Condition;
2219 
2220 /*ci @ingroup DDSConditionsModule
2221  @brief Pointer to DDS_Condition.
2222  */
2223 typedef struct DDS_ConditionImpl *DDS_Condition_ptr;
2224 
2225 /*ce \dref_ConditionSeq
2226  */
2227 #define T struct DDS_ConditionImpl*
2228 #define TSeq DDS_ConditionSeq
2229 #include <reda/reda_sequence_decl.h>
2230 
2231 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2232 /*ce \dref_ConditionSeq
2233  */
2234 struct DDS_ConditionSeq {};
2235 #endif
2236 
2237 /*ce \dref_Condition_get_trigger_value
2238  */
2239 DDSCDllExport DDS_Boolean
2240 DDS_Condition_get_trigger_value(DDS_Condition *self);
2241 
2242 /*i \dref_Condition_set_wrapper
2243  */
2244 DDSCDllExport void
2245 DDS_ConditionImpl_set_wrapper(DDS_Condition *self, void *wrapper);
2246 
2247 /*i \dref_Condition_get_wrapper
2248  */
2249 DDSCDllExport void**
2250 DDS_ConditionImpl_get_wrapper_ref(DDS_Condition *self);
2251 
2252 /* ----------------------------------------------------------------- */
2253 
2254 /*ce \dref_GuardCondition
2255  */
2256 typedef struct DDS_GuardConditionImpl DDS_GuardCondition;
2257 
2258 #define DDS_GuardCondition_as_condition(guard_condition_ptr_) \
2259  ((DDS_Condition*) guard_condition_ptr_)
2260 
2261 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2262 /*ce \dref_GuardCondition_as_condition
2263  */
2264 DDS_Condition* DDS_GuardCondition_as_condition(DDS_GuardCondition* guard_cond);
2265 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2266 
2267 /*ce \dref_GuardCondition_new
2268  */
2269 DDSCDllExport DDS_GuardCondition*
2270 DDS_GuardCondition_new(void);
2271 
2272 #ifndef RTI_CERT
2273 /*ce \dref_GuardCondition_delete
2274  */
2275 DDSCDllExport DDS_ReturnCode_t
2276 DDS_GuardCondition_delete(DDS_GuardCondition *self);
2277 #endif
2278 
2279 /*ce \dref_GuardCondition_set_trigger_value
2280  */
2281 DDSCDllExport DDS_ReturnCode_t
2282 DDS_GuardCondition_set_trigger_value(DDS_GuardCondition *self,
2283  DDS_Boolean value);
2284 
2285 /* ----------------------------------------------------------------- */
2286 
2287 /*ce \dref_StatusCondition
2288  */
2289 typedef struct DDS_StatusConditionImpl DDS_StatusCondition;
2290 
2291 #define DDS_StatusCondition_as_condition(status_cond_ptr_) \
2292  ((DDS_Condition*) status_cond_ptr_)
2293 
2294 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2295 /*ce \dref_StatusCondition_as_condition
2296  */
2297 DDS_Condition* DDS_StatusCondition_as_condition(
2298  DDS_StatusCondition *statusCondition);
2299 #endif /*DOXYGEN_DOCUMENTATION_ONLY*/
2300 
2301 
2302 /*ce \dref_StatusCondition_get_enabled_statuses
2303  */
2304 DDSCDllExport DDS_StatusMask
2305 DDS_StatusCondition_get_enabled_statuses(DDS_StatusCondition *self);
2306 
2307 /*ce \dref_StatusCondition_set_enabled_statuses
2308  */
2309 DDSCDllExport DDS_ReturnCode_t
2310 DDS_StatusCondition_set_enabled_statuses(DDS_StatusCondition *self,
2311  DDS_StatusMask mask);
2312 
2313 /*ce \dref_StatusCondition_get_entity
2314  */
2315 DDSCDllExport DDS_Entity*
2316 DDS_StatusCondition_get_entity(DDS_StatusCondition *self);
2317 
2318 /*ce \dref_WaitSet
2319  */
2320 typedef struct DDS_WaitSetImpl DDS_WaitSet;
2321 
2322 /*ce \dref_WaitSet_new
2323  */
2324 DDSCDllExport DDS_WaitSet*
2325 DDS_WaitSet_new(void);
2326 
2327 /*ce \dref_WaitSet_wait
2328  */
2329 DDSCDllExport DDS_ReturnCode_t
2330 DDS_WaitSet_wait(DDS_WaitSet *self,
2331  struct DDS_ConditionSeq *active_conditions,
2332  const struct DDS_Duration_t *timeout);
2333 
2334 /*ce \dref_WaitSet_attach_condition
2335  */
2336 DDSCDllExport DDS_ReturnCode_t
2337 DDS_WaitSet_attach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2338 
2339 #ifndef RTI_CERT
2340 /*ce \dref_WaitSet_delete
2341  */
2342 DDSCDllExport DDS_ReturnCode_t
2343 DDS_WaitSet_delete(DDS_WaitSet *self);
2344 #endif /* !RTI_CERT */
2345 
2346 #ifndef RTI_CERT
2347 /*ce \dref_WaitSet_detach_condition
2348  */
2349 DDSCDllExport DDS_ReturnCode_t
2350 DDS_WaitSet_detach_condition(DDS_WaitSet *self,DDS_Condition *cond);
2351 #endif /* !RTI_CERT */
2352 
2353 
2354 /*ce \dref_WaitSet_get_conditions
2355  */
2356 DDSCDllExport DDS_ReturnCode_t
2357 DDS_WaitSet_get_conditions(DDS_WaitSet *self,
2358  struct DDS_ConditionSeq *attached_conditions);
2359 
2360 /* ================================================================= */
2361 /* Listeners */
2362 /* ================================================================= */
2363 /*e \dref_EntityModuleDocs
2364  */
2365 
2366 /*ce \dref_Listener
2367  */
2368 struct DDS_Listener
2369 {
2370  /*ce \dref_Listener_listener_data
2371  */
2372  void *listener_data;
2373 };
2374 
2375 /*ce \dref_Listener_INITIALIZER
2376  */
2377 #define DDS_Listener_INITIALIZER { NULL }
2378 
2379 /* ================================================================= */
2380 /* Entity typedef */
2381 /* ================================================================= */
2382 
2383 #ifdef DOXYGEN_DOCUMENTATION_ONLY
2384 /*ce \dref_DomainEntity
2385  */
2386 typedef struct DDS_DomainEntityImpl DDS_DomainEntity;
2387 #endif /*DOXYGEN_DOCUMENTATION_ONLY */
2388 
2389 /* ================================================================= */
2390 /* DDS_Entity */
2391 /* ================================================================= */
2392 
2393 /*ce \dref_Entity_enable
2394  */
2395 DDSCDllExport DDS_ReturnCode_t
2396 DDS_Entity_enable(DDS_Entity * self);
2397 
2398 /*ce \dref_Entity_is_enabled
2399  */
2400 DDSCDllExport DDS_Boolean
2401 DDS_Entity_is_enabled(DDS_Entity * self);
2402 
2403 /*ce \dref_Entity_get_instance_handle
2404  */
2405 DDSCDllExport DDS_InstanceHandle_t
2406 DDS_Entity_get_instance_handle(DDS_Entity * self);
2407 
2408 /*ce \dref_Entity_get_entity_kind
2409  */
2410 DDSCDllExport DDS_EntityKind_t
2411 DDS_Entity_get_entity_kind(DDS_Entity *self);
2412 
2413 /*ce \dref_Entity_get_statuscondition
2414  */
2415 DDSCDllExport DDS_StatusCondition*
2416 DDS_Entity_get_statuscondition(DDS_Entity *self);
2417 
2418 /*ce \dref_Entity_get_status_changes
2419  */
2420 DDSCDllExport DDS_StatusMask
2421 DDS_Entity_get_status_changes(DDS_Entity *self);
2422 
2423 /*ci
2424  * \brief Associate a language-dependent wrapper object with a DDS_Entity.
2425  *
2426  * \details
2427  * This operation is used to support access to the functionality of
2428  * the C implementation from other compatible programming languages, such as C++.
2429  * Implementations of the Micro API in these programming languages may use
2430  * this facility to associate objects created in their run-time environments
2431  * with DDS_Entity instances by means of this operation, and then access
2432  * them using DDS_Entity_get_wrapper, typically to support the correct
2433  * propagation of events from the C core to the wrapping programming language's
2434  * layer.
2435  *
2436  * \param[in] self a non NULL DDS_Entity
2437  * \param[in] wrapper pointer to a wrapper instance or NULL to delete an
2438  * existing association.
2439  */
2440 DDSCDllExport void
2441 DDS_Entity_set_wrapper(DDS_Entity *self, void *wrapper);
2442 
2443 /*ci
2444  * \brief Access a language-dependent wrapper object attached to the DDS_Entity.
2445  *
2446  * \long This operation is used to support access to the functionality of
2447  * the C implementation from other compatible programming languages, such as C++.
2448  * Implementations of the Micro API in these programming languages may use
2449  * this facility to associate objects created in their run-time environments
2450  * with DDS_Entity instances by means of DDS_Entity_set_wrapper, typically
2451  * to support the correct propagation of events from the C core to the wrapping
2452  * programming language's layer.
2453  *
2454  * \param[in] self a non NULL DDS_Entity
2455  *
2456  * \return a pointer to a wrapper object previously or NULL if none had been
2457  * previously set using DDS_Entity_set_wrapper.
2458  */
2459 DDSCDllExport void*
2460 DDS_Entity_get_wrapper(DDS_Entity *self);
2461 
2462 /* ----------------------------------------------------------------- */
2463 /* ENTITY_NAME */
2464 /* ----------------------------------------------------------------- */
2465 /*e \dref_EntityNameQosGroupDocs
2466  */
2467 
2468 /*e \dref_ENTITYNAME_QOS_POLICY_NAME
2469  */
2470 extern DDSCDllVariable const char *const DDS_ENTITYNAME_QOS_POLICY_NAME;
2471 
2472 /*e \dref_AUTO_NAME_ENTITY
2473  */
2474 extern DDSCDllVariable const char *const DDS_AUTO_NAME_ENTITY;
2475 
2476 /* ----------------------------------------------------------------- */
2477 /*e \dref_EntityNameQosPolicy_NAME_MAX
2478  */
2479 #define DDS_ENTITYNAME_QOS_NAME_MAX 255
2480 
2481 /*e \dref_EntityNameQosPolicy
2482  */
2483 struct DDS_EntityNameQosPolicy
2484 {
2485  /*e \dref_EntityNameQosPolicy_name
2486  */
2487  char name[DDS_ENTITYNAME_QOS_NAME_MAX + 1];
2488 
2489 #ifdef RTI_CPP
2490  DDS_Boolean set_name(const char *const name);
2491 #endif
2492 };
2493 
2494 /*i \dref_EntityNameQosPolicy_DEFAULT
2495  */
2496 #define DDS_ENTITY_NAME_QOS_POLICY_DEFAULT { {'\0'} }
2497 
2498 /*e \dref_EntityNameQosPolicy_set_name
2499  */
2500 DDSCDllExport DDS_Boolean
2501 DDS_EntityNameQosPolicy_set_name(struct DDS_EntityNameQosPolicy *const self,
2502  const char *const name);
2503 
2504 /* ================================================================= */
2505 /* RTI_Management */
2506 /* ================================================================= */
2507 
2508 /*i \dref_ManagementQosPolicy
2509  */
2510 struct RTI_ManagementQosPolicy
2511 {
2512  DDS_Boolean is_hidden;
2513  DDS_Boolean is_anonymous;
2514 };
2515 
2516 /*i \dref_ManagementQosPolicy_DEFAULT
2517  */
2518 #define RTI_MANAGEMENT_QOS_POLICY_DEFAULT { \
2519  DDS_BOOLEAN_FALSE,\
2520  DDS_BOOLEAN_FALSE\
2521 }
2522 
2523 /* ================================================================= */
2524 /* DDS_DomainEntity */
2525 /* ================================================================= */
2526 
2527 /*ce \dref_DomainParticipant
2528  */
2529 typedef struct DDS_DomainParticipantImpl DDS_DomainParticipant;
2530 
2531 /* ----------------------------------------------------------------- */
2532 
2533 /* ================================================================= */
2534 /* DDSHST_History */
2535 /* ================================================================= */
2536 /*i \dref_DDSHST_ReturnCode_T
2537  */
2538 typedef enum
2539 {
2540  DDSHST_RETCODE_ERROR = -1000,
2541  DDSHST_RETCODE_NOSPACE,
2542  DDSHST_RETCODE_EXISTS,
2543  DDSHST_RETCODE_NOT_EXISTS,
2544  DDSHST_RETCODE_INVALID_PROPERTY,
2545  DDSHST_RETCODE_INVALID_ENTRY_REQUEST,
2546  DDSHST_RETCODE_SUCCESS = 0
2547 } DDSHST_ReturnCode_T;
2548 
2549 /*i \dref_ReplacePolicyKind_T
2550  */
2551 typedef enum
2552 {
2553  DDSHST_REPLACE_POLICY_KIND_OLDEST,
2554  DDSHST_REPLACE_POLICY_KIND_NONE
2555 } DDSHST_ReplacePolicyKind_T;
2556 
2557 
2558 /* ----------------------------------------------------------------- */
2559 /* WRITE_PARAMS */
2560 /* ----------------------------------------------------------------- */
2561 
2562 /*e \dref_SampleIdentity_t
2563  */
2564 struct DDSCPPDllExport DDS_SampleIdentity_t
2565 {
2566  /*e \dref_SampleIdentity_t_writer_guid */
2567  struct DDS_GUID_t writer_guid;
2568  /*e \dref_SampleIdentity_t_sequence_number */
2569  struct DDS_SequenceNumber_t sequence_number;
2570 
2571  DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_SampleIdentity_t)
2572 };
2573 
2574 
2575 /*ci \dref_SampleIdentity_t
2576  */
2577 #define DDS_SAMPLE_IDENTITY_UNKNOWN \
2578 { \
2579  DDS_GUID_INITIALIZER, \
2580  DDS_SEQUENCE_NUMBER_UNKNOWN \
2581 }
2582 
2583 /*e \dref_WriteParams_t
2584  */
2585 struct DDSCPPDllExport DDS_WriteParams_t
2586 {
2587  /*i \dref_WriteParams_t_identity
2588  */
2589  struct DDS_SampleIdentity_t identity;
2590 
2591  /*i \dref_WriteParams_t_related_sample_identity
2592  */
2593  struct DDS_SampleIdentity_t related_sample_identity;
2594 
2595  /*e \dref_WriteParams_t_source_timestamp
2596  */
2597  struct DDS_Time_t source_timestamp;
2598 
2599  /*e \dref_WriteParams_t_handle
2600  */
2601  DDS_InstanceHandle_t handle;
2602 
2603  DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_WriteParams_t)
2604 };
2605 
2606 /*e \dref_WriteParams_t_DEFAULT
2607  */
2608 #define DDS_WRITEPARAMS_DEFAULT \
2609 { \
2610  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2611  DDS_SAMPLE_IDENTITY_UNKNOWN, \
2612  DDS_TIME_ZERO, \
2613  DDS_HANDLE_NIL_NATIVE \
2614 }
2615 
2616 /* ================================================================= */
2617 /* DDS Properties */
2618 /* ================================================================= */
2619 /* NOTE:
2620  * DDS_PropertySeq is not exposed as a general purpose property
2621  * sequence. It is only used to send required properties for RTI Tools.
2622  * Thus, although the generic sequence type is used to implement the property
2623  * sequence, its internal use is highly specialized and only a limited
2624  * number of functions are exposed.
2625  */
2626 #define DDS_PropertySeq CDR_PropertySeq
2627 #define DDS_Property CDR_Property
2628 #define DDS_PropertySeq_initialize CDR_PropertySeq_initialize
2629 #define DDS_PropertySeq_set_length CDR_PropertySeq_set_length
2630 #define DDS_PropertySeq_get_length CDR_PropertySeq_get_length
2631 #define DDS_PropertySeq_get_reference CDR_PropertySeq_get_reference
2632 
2633 /*ci
2634  * \brief Get pointer to the DDS participant properties
2635  *
2636  * \details
2637  * The DDS domain participant may send additional information as properties
2638  * in the participant announcement. Typically this is used by discovery plugins
2639  * to serialize the information.
2640  *
2641  * \param[in] self Participant to get properties for
2642  *
2643  * \return A sequence with 0 or more properties on success, NULL if no
2644  * sequence exists.
2645  */
2646 DDSCDllExport struct DDS_PropertySeq*
2647 DDS_DomainParticipant_get_dds_properties(DDS_DomainParticipant *self);
2648 
2649 
2650 /*ci
2651  * \brief Query the domain-participant if the specified locator is supported
2652  *
2653  * \param[in] self Participant to query
2654  *
2655  * \return DDS_BOOLEAN_TRUE if the locator is supported, DDS_BOOLEEAN_FALSE
2656  * otherwise.
2657  */
2658 DDSCDllExport DDS_Boolean
2659 DDS_DomainParticipant_locator_is_supported(DDS_DomainParticipant *self,
2660  struct DDS_Locator *locator);
2661 
2662 #ifdef __cplusplus
2663 } /* extern "C" */
2664 #endif
2665 
2666 #endif /* dds_c_infrastructure_h */
RTI Connext DDS Micro Version 2.4.6 Copyright © Mon Jan 25 2016 Real-Time Innovations, Inc