1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage, Align> {
6 storage: Storage,
7 align: [Align; 0],
8}
9impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
10 #[inline]
11 pub const fn new(storage: Storage) -> Self {
12 Self { storage, align: [] }
13 }
14}
15impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
16where
17 Storage: AsRef<[u8]> + AsMut<[u8]>,
18{
19 #[inline]
20 pub fn get_bit(&self, index: usize) -> bool {
21 debug_assert!(index / 8 < self.storage.as_ref().len());
22 let byte_index = index / 8;
23 let byte = self.storage.as_ref()[byte_index];
24 let bit_index = if cfg!(target_endian = "big") {
25 7 - (index % 8)
26 } else {
27 index % 8
28 };
29 let mask = 1 << bit_index;
30 byte & mask == mask
31 }
32 #[inline]
33 pub fn set_bit(&mut self, index: usize, val: bool) {
34 debug_assert!(index / 8 < self.storage.as_ref().len());
35 let byte_index = index / 8;
36 let byte = &mut self.storage.as_mut()[byte_index];
37 let bit_index = if cfg!(target_endian = "big") {
38 7 - (index % 8)
39 } else {
40 index % 8
41 };
42 let mask = 1 << bit_index;
43 if val {
44 *byte |= mask;
45 } else {
46 *byte &= !mask;
47 }
48 }
49 #[inline]
50 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
51 debug_assert!(bit_width <= 64);
52 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
53 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
54 let mut val = 0;
55 for i in 0..(bit_width as usize) {
56 if self.get_bit(i + bit_offset) {
57 let index = if cfg!(target_endian = "big") {
58 bit_width as usize - 1 - i
59 } else {
60 i
61 };
62 val |= 1 << index;
63 }
64 }
65 val
66 }
67 #[inline]
68 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
69 debug_assert!(bit_width <= 64);
70 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
71 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
72 for i in 0..(bit_width as usize) {
73 let mask = 1 << i;
74 let val_bit_is_set = val & mask == mask;
75 let index = if cfg!(target_endian = "big") {
76 bit_width as usize - 1 - i
77 } else {
78 i
79 };
80 self.set_bit(index + bit_offset, val_bit_is_set);
81 }
82 }
83}
84pub type size_t = ::std::os::raw::c_ulong;
85pub type __uint8_t = ::std::os::raw::c_uchar;
86pub type __int16_t = ::std::os::raw::c_short;
87pub type __uint16_t = ::std::os::raw::c_ushort;
88pub type __int32_t = ::std::os::raw::c_int;
89pub type __uint32_t = ::std::os::raw::c_uint;
90pub type __int64_t = ::std::os::raw::c_long;
91pub type __uint64_t = ::std::os::raw::c_ulong;
92pub type dds_entity_t = i32;
93pub type dds_time_t = i64;
94pub type dds_duration_t = i64;
95#[repr(C)]
96#[derive(Debug, Default, Copy, Clone)]
97pub struct ddsrt_mtime_t {
98 pub v: dds_time_t,
99}
100#[test]
101fn bindgen_test_layout_ddsrt_mtime_t() {
102 assert_eq!(
103 ::std::mem::size_of::<ddsrt_mtime_t>(),
104 8usize,
105 concat!("Size of: ", stringify!(ddsrt_mtime_t))
106 );
107 assert_eq!(
108 ::std::mem::align_of::<ddsrt_mtime_t>(),
109 8usize,
110 concat!("Alignment of ", stringify!(ddsrt_mtime_t))
111 );
112 assert_eq!(
113 unsafe { &(*(::std::ptr::null::<ddsrt_mtime_t>())).v as *const _ as usize },
114 0usize,
115 concat!(
116 "Offset of field: ",
117 stringify!(ddsrt_mtime_t),
118 "::",
119 stringify!(v)
120 )
121 );
122}
123#[repr(C)]
124#[derive(Debug, Default, Copy, Clone)]
125pub struct ddsrt_wctime_t {
126 pub v: dds_time_t,
127}
128#[test]
129fn bindgen_test_layout_ddsrt_wctime_t() {
130 assert_eq!(
131 ::std::mem::size_of::<ddsrt_wctime_t>(),
132 8usize,
133 concat!("Size of: ", stringify!(ddsrt_wctime_t))
134 );
135 assert_eq!(
136 ::std::mem::align_of::<ddsrt_wctime_t>(),
137 8usize,
138 concat!("Alignment of ", stringify!(ddsrt_wctime_t))
139 );
140 assert_eq!(
141 unsafe { &(*(::std::ptr::null::<ddsrt_wctime_t>())).v as *const _ as usize },
142 0usize,
143 concat!(
144 "Offset of field: ",
145 stringify!(ddsrt_wctime_t),
146 "::",
147 stringify!(v)
148 )
149 );
150}
151pub type dds_return_t = i32;
152pub const dds_free_op_t_DDS_FREE_ALL: dds_free_op_t = 7;
153pub const dds_free_op_t_DDS_FREE_CONTENTS: dds_free_op_t = 3;
154pub const dds_free_op_t_DDS_FREE_KEY: dds_free_op_t = 1;
155pub type dds_free_op_t = ::std::os::raw::c_uint;
156extern "C" {
157 pub fn dds_alloc(size: size_t) -> *mut ::std::os::raw::c_void;
158}
159extern "C" {
160 pub fn dds_realloc(
161 ptr: *mut ::std::os::raw::c_void,
162 size: size_t,
163 ) -> *mut ::std::os::raw::c_void;
164}
165extern "C" {
166 pub fn dds_realloc_zero(
167 ptr: *mut ::std::os::raw::c_void,
168 size: size_t,
169 ) -> *mut ::std::os::raw::c_void;
170}
171extern "C" {
172 pub fn dds_free(ptr: *mut ::std::os::raw::c_void);
173}
174extern "C" {
175 pub fn dds_string_alloc(size: size_t) -> *mut ::std::os::raw::c_char;
176}
177extern "C" {
178 pub fn dds_string_dup(str_: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
179}
180extern "C" {
181 pub fn dds_string_free(str_: *mut ::std::os::raw::c_char);
182}
183extern "C" {
184 pub fn dds_sample_free(
185 sample: *mut ::std::os::raw::c_void,
186 desc: *const dds_topic_descriptor,
187 op: dds_free_op_t,
188 );
189}
190pub const dds_stream_opcode_DDS_OP_RTS: dds_stream_opcode = 0;
191pub const dds_stream_opcode_DDS_OP_ADR: dds_stream_opcode = 16777216;
192pub const dds_stream_opcode_DDS_OP_JSR: dds_stream_opcode = 33554432;
193pub const dds_stream_opcode_DDS_OP_JEQ: dds_stream_opcode = 50331648;
194pub const dds_stream_opcode_DDS_OP_DLC: dds_stream_opcode = 67108864;
195pub const dds_stream_opcode_DDS_OP_PLC: dds_stream_opcode = 83886080;
196pub const dds_stream_opcode_DDS_OP_PLM: dds_stream_opcode = 100663296;
197pub const dds_stream_opcode_DDS_OP_KOF: dds_stream_opcode = 117440512;
198pub const dds_stream_opcode_DDS_OP_JEQ4: dds_stream_opcode = 134217728;
199pub type dds_stream_opcode = ::std::os::raw::c_uint;
200pub const dds_stream_typecode_DDS_OP_VAL_1BY: dds_stream_typecode = 1;
201pub const dds_stream_typecode_DDS_OP_VAL_2BY: dds_stream_typecode = 2;
202pub const dds_stream_typecode_DDS_OP_VAL_4BY: dds_stream_typecode = 3;
203pub const dds_stream_typecode_DDS_OP_VAL_8BY: dds_stream_typecode = 4;
204pub const dds_stream_typecode_DDS_OP_VAL_STR: dds_stream_typecode = 5;
205pub const dds_stream_typecode_DDS_OP_VAL_BST: dds_stream_typecode = 6;
206pub const dds_stream_typecode_DDS_OP_VAL_SEQ: dds_stream_typecode = 7;
207pub const dds_stream_typecode_DDS_OP_VAL_ARR: dds_stream_typecode = 8;
208pub const dds_stream_typecode_DDS_OP_VAL_UNI: dds_stream_typecode = 9;
209pub const dds_stream_typecode_DDS_OP_VAL_STU: dds_stream_typecode = 10;
210pub const dds_stream_typecode_DDS_OP_VAL_BSQ: dds_stream_typecode = 11;
211pub const dds_stream_typecode_DDS_OP_VAL_ENU: dds_stream_typecode = 12;
212pub const dds_stream_typecode_DDS_OP_VAL_EXT: dds_stream_typecode = 13;
213pub const dds_stream_typecode_DDS_OP_VAL_BLN: dds_stream_typecode = 14;
214pub const dds_stream_typecode_DDS_OP_VAL_BMK: dds_stream_typecode = 15;
215pub type dds_stream_typecode = ::std::os::raw::c_uint;
216pub const dds_stream_typecode_primary_DDS_OP_TYPE_1BY: dds_stream_typecode_primary = 65536;
217pub const dds_stream_typecode_primary_DDS_OP_TYPE_2BY: dds_stream_typecode_primary = 131072;
218pub const dds_stream_typecode_primary_DDS_OP_TYPE_4BY: dds_stream_typecode_primary = 196608;
219pub const dds_stream_typecode_primary_DDS_OP_TYPE_8BY: dds_stream_typecode_primary = 262144;
220pub const dds_stream_typecode_primary_DDS_OP_TYPE_STR: dds_stream_typecode_primary = 327680;
221pub const dds_stream_typecode_primary_DDS_OP_TYPE_BST: dds_stream_typecode_primary = 393216;
222pub const dds_stream_typecode_primary_DDS_OP_TYPE_SEQ: dds_stream_typecode_primary = 458752;
223pub const dds_stream_typecode_primary_DDS_OP_TYPE_ARR: dds_stream_typecode_primary = 524288;
224pub const dds_stream_typecode_primary_DDS_OP_TYPE_UNI: dds_stream_typecode_primary = 589824;
225pub const dds_stream_typecode_primary_DDS_OP_TYPE_STU: dds_stream_typecode_primary = 655360;
226pub const dds_stream_typecode_primary_DDS_OP_TYPE_BSQ: dds_stream_typecode_primary = 720896;
227pub const dds_stream_typecode_primary_DDS_OP_TYPE_ENU: dds_stream_typecode_primary = 786432;
228pub const dds_stream_typecode_primary_DDS_OP_TYPE_EXT: dds_stream_typecode_primary = 851968;
229pub const dds_stream_typecode_primary_DDS_OP_TYPE_BLN: dds_stream_typecode_primary = 917504;
230pub const dds_stream_typecode_primary_DDS_OP_TYPE_BMK: dds_stream_typecode_primary = 983040;
231pub type dds_stream_typecode_primary = ::std::os::raw::c_uint;
232pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_1BY: dds_stream_typecode_subtype = 256;
233pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_2BY: dds_stream_typecode_subtype = 512;
234pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_4BY: dds_stream_typecode_subtype = 768;
235pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_8BY: dds_stream_typecode_subtype = 1024;
236pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_STR: dds_stream_typecode_subtype = 1280;
237pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_BST: dds_stream_typecode_subtype = 1536;
238pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_SEQ: dds_stream_typecode_subtype = 1792;
239pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_ARR: dds_stream_typecode_subtype = 2048;
240pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_UNI: dds_stream_typecode_subtype = 2304;
241pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_STU: dds_stream_typecode_subtype = 2560;
242pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_BSQ: dds_stream_typecode_subtype = 2816;
243pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_ENU: dds_stream_typecode_subtype = 3072;
244pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_BLN: dds_stream_typecode_subtype = 3584;
245pub const dds_stream_typecode_subtype_DDS_OP_SUBTYPE_BMK: dds_stream_typecode_subtype = 3840;
246pub type dds_stream_typecode_subtype = ::std::os::raw::c_uint;
247#[repr(C)]
248#[derive(Debug, Copy, Clone)]
249pub struct dds_sequence {
250 pub _maximum: u32,
251 pub _length: u32,
252 pub _buffer: *mut u8,
253 pub _release: bool,
254}
255#[test]
256fn bindgen_test_layout_dds_sequence() {
257 assert_eq!(
258 ::std::mem::size_of::<dds_sequence>(),
259 24usize,
260 concat!("Size of: ", stringify!(dds_sequence))
261 );
262 assert_eq!(
263 ::std::mem::align_of::<dds_sequence>(),
264 8usize,
265 concat!("Alignment of ", stringify!(dds_sequence))
266 );
267 assert_eq!(
268 unsafe { &(*(::std::ptr::null::<dds_sequence>()))._maximum as *const _ as usize },
269 0usize,
270 concat!(
271 "Offset of field: ",
272 stringify!(dds_sequence),
273 "::",
274 stringify!(_maximum)
275 )
276 );
277 assert_eq!(
278 unsafe { &(*(::std::ptr::null::<dds_sequence>()))._length as *const _ as usize },
279 4usize,
280 concat!(
281 "Offset of field: ",
282 stringify!(dds_sequence),
283 "::",
284 stringify!(_length)
285 )
286 );
287 assert_eq!(
288 unsafe { &(*(::std::ptr::null::<dds_sequence>()))._buffer as *const _ as usize },
289 8usize,
290 concat!(
291 "Offset of field: ",
292 stringify!(dds_sequence),
293 "::",
294 stringify!(_buffer)
295 )
296 );
297 assert_eq!(
298 unsafe { &(*(::std::ptr::null::<dds_sequence>()))._release as *const _ as usize },
299 16usize,
300 concat!(
301 "Offset of field: ",
302 stringify!(dds_sequence),
303 "::",
304 stringify!(_release)
305 )
306 );
307}
308impl Default for dds_sequence {
309 fn default() -> Self {
310 unsafe { ::std::mem::zeroed() }
311 }
312}
313pub type dds_sequence_t = dds_sequence;
314#[repr(C)]
315#[derive(Debug, Copy, Clone)]
316pub struct dds_key_descriptor {
317 pub m_name: *const ::std::os::raw::c_char,
318 pub m_offset: u32,
319 pub m_idx: u32,
320}
321#[test]
322fn bindgen_test_layout_dds_key_descriptor() {
323 assert_eq!(
324 ::std::mem::size_of::<dds_key_descriptor>(),
325 16usize,
326 concat!("Size of: ", stringify!(dds_key_descriptor))
327 );
328 assert_eq!(
329 ::std::mem::align_of::<dds_key_descriptor>(),
330 8usize,
331 concat!("Alignment of ", stringify!(dds_key_descriptor))
332 );
333 assert_eq!(
334 unsafe { &(*(::std::ptr::null::<dds_key_descriptor>())).m_name as *const _ as usize },
335 0usize,
336 concat!(
337 "Offset of field: ",
338 stringify!(dds_key_descriptor),
339 "::",
340 stringify!(m_name)
341 )
342 );
343 assert_eq!(
344 unsafe { &(*(::std::ptr::null::<dds_key_descriptor>())).m_offset as *const _ as usize },
345 8usize,
346 concat!(
347 "Offset of field: ",
348 stringify!(dds_key_descriptor),
349 "::",
350 stringify!(m_offset)
351 )
352 );
353 assert_eq!(
354 unsafe { &(*(::std::ptr::null::<dds_key_descriptor>())).m_idx as *const _ as usize },
355 12usize,
356 concat!(
357 "Offset of field: ",
358 stringify!(dds_key_descriptor),
359 "::",
360 stringify!(m_idx)
361 )
362 );
363}
364impl Default for dds_key_descriptor {
365 fn default() -> Self {
366 unsafe { ::std::mem::zeroed() }
367 }
368}
369pub type dds_key_descriptor_t = dds_key_descriptor;
370#[repr(C)]
371#[derive(Debug, Copy, Clone)]
372pub struct dds_type_meta_ser {
373 pub data: *mut ::std::os::raw::c_uchar,
374 pub sz: u32,
375}
376#[test]
377fn bindgen_test_layout_dds_type_meta_ser() {
378 assert_eq!(
379 ::std::mem::size_of::<dds_type_meta_ser>(),
380 16usize,
381 concat!("Size of: ", stringify!(dds_type_meta_ser))
382 );
383 assert_eq!(
384 ::std::mem::align_of::<dds_type_meta_ser>(),
385 8usize,
386 concat!("Alignment of ", stringify!(dds_type_meta_ser))
387 );
388 assert_eq!(
389 unsafe { &(*(::std::ptr::null::<dds_type_meta_ser>())).data as *const _ as usize },
390 0usize,
391 concat!(
392 "Offset of field: ",
393 stringify!(dds_type_meta_ser),
394 "::",
395 stringify!(data)
396 )
397 );
398 assert_eq!(
399 unsafe { &(*(::std::ptr::null::<dds_type_meta_ser>())).sz as *const _ as usize },
400 8usize,
401 concat!(
402 "Offset of field: ",
403 stringify!(dds_type_meta_ser),
404 "::",
405 stringify!(sz)
406 )
407 );
408}
409impl Default for dds_type_meta_ser {
410 fn default() -> Self {
411 unsafe { ::std::mem::zeroed() }
412 }
413}
414#[repr(C)]
415#[derive(Debug, Copy, Clone)]
416pub struct dds_topic_descriptor {
417 pub m_size: u32,
418 pub m_align: u32,
419 pub m_flagset: u32,
420 pub m_nkeys: u32,
421 pub m_typename: *const ::std::os::raw::c_char,
422 pub m_keys: *const dds_key_descriptor_t,
423 pub m_nops: u32,
424 pub m_ops: *const u32,
425 pub m_meta: *const ::std::os::raw::c_char,
426 pub type_information: dds_type_meta_ser,
427 pub type_mapping: dds_type_meta_ser,
428 pub restrict_data_representation: u32,
429}
430#[test]
431fn bindgen_test_layout_dds_topic_descriptor() {
432 assert_eq!(
433 ::std::mem::size_of::<dds_topic_descriptor>(),
434 96usize,
435 concat!("Size of: ", stringify!(dds_topic_descriptor))
436 );
437 assert_eq!(
438 ::std::mem::align_of::<dds_topic_descriptor>(),
439 8usize,
440 concat!("Alignment of ", stringify!(dds_topic_descriptor))
441 );
442 assert_eq!(
443 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_size as *const _ as usize },
444 0usize,
445 concat!(
446 "Offset of field: ",
447 stringify!(dds_topic_descriptor),
448 "::",
449 stringify!(m_size)
450 )
451 );
452 assert_eq!(
453 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_align as *const _ as usize },
454 4usize,
455 concat!(
456 "Offset of field: ",
457 stringify!(dds_topic_descriptor),
458 "::",
459 stringify!(m_align)
460 )
461 );
462 assert_eq!(
463 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_flagset as *const _ as usize },
464 8usize,
465 concat!(
466 "Offset of field: ",
467 stringify!(dds_topic_descriptor),
468 "::",
469 stringify!(m_flagset)
470 )
471 );
472 assert_eq!(
473 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_nkeys as *const _ as usize },
474 12usize,
475 concat!(
476 "Offset of field: ",
477 stringify!(dds_topic_descriptor),
478 "::",
479 stringify!(m_nkeys)
480 )
481 );
482 assert_eq!(
483 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_typename as *const _ as usize },
484 16usize,
485 concat!(
486 "Offset of field: ",
487 stringify!(dds_topic_descriptor),
488 "::",
489 stringify!(m_typename)
490 )
491 );
492 assert_eq!(
493 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_keys as *const _ as usize },
494 24usize,
495 concat!(
496 "Offset of field: ",
497 stringify!(dds_topic_descriptor),
498 "::",
499 stringify!(m_keys)
500 )
501 );
502 assert_eq!(
503 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_nops as *const _ as usize },
504 32usize,
505 concat!(
506 "Offset of field: ",
507 stringify!(dds_topic_descriptor),
508 "::",
509 stringify!(m_nops)
510 )
511 );
512 assert_eq!(
513 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_ops as *const _ as usize },
514 40usize,
515 concat!(
516 "Offset of field: ",
517 stringify!(dds_topic_descriptor),
518 "::",
519 stringify!(m_ops)
520 )
521 );
522 assert_eq!(
523 unsafe { &(*(::std::ptr::null::<dds_topic_descriptor>())).m_meta as *const _ as usize },
524 48usize,
525 concat!(
526 "Offset of field: ",
527 stringify!(dds_topic_descriptor),
528 "::",
529 stringify!(m_meta)
530 )
531 );
532 assert_eq!(
533 unsafe {
534 &(*(::std::ptr::null::<dds_topic_descriptor>())).type_information as *const _ as usize
535 },
536 56usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(dds_topic_descriptor),
540 "::",
541 stringify!(type_information)
542 )
543 );
544 assert_eq!(
545 unsafe {
546 &(*(::std::ptr::null::<dds_topic_descriptor>())).type_mapping as *const _ as usize
547 },
548 72usize,
549 concat!(
550 "Offset of field: ",
551 stringify!(dds_topic_descriptor),
552 "::",
553 stringify!(type_mapping)
554 )
555 );
556 assert_eq!(
557 unsafe {
558 &(*(::std::ptr::null::<dds_topic_descriptor>())).restrict_data_representation
559 as *const _ as usize
560 },
561 88usize,
562 concat!(
563 "Offset of field: ",
564 stringify!(dds_topic_descriptor),
565 "::",
566 stringify!(restrict_data_representation)
567 )
568 );
569}
570impl Default for dds_topic_descriptor {
571 fn default() -> Self {
572 unsafe { ::std::mem::zeroed() }
573 }
574}
575pub type dds_topic_descriptor_t = dds_topic_descriptor;
576pub type dds_instance_handle_t = u64;
577pub type dds_domainid_t = u32;
578pub const dds_find_scope_DDS_FIND_SCOPE_GLOBAL: dds_find_scope = 0;
579pub const dds_find_scope_DDS_FIND_SCOPE_LOCAL_DOMAIN: dds_find_scope = 1;
580pub const dds_find_scope_DDS_FIND_SCOPE_PARTICIPANT: dds_find_scope = 2;
581pub type dds_find_scope = ::std::os::raw::c_uint;
582pub use self::dds_find_scope as dds_find_scope_t;
583pub type dds_qos_t = dds_qos;
584#[repr(u32)]
585#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
586pub enum dds_durability_kind {
587 DDS_DURABILITY_VOLATILE = 0,
588 DDS_DURABILITY_TRANSIENT_LOCAL = 1,
589 DDS_DURABILITY_TRANSIENT = 2,
590 DDS_DURABILITY_PERSISTENT = 3,
591}
592pub use self::dds_durability_kind as dds_durability_kind_t;
593#[repr(u32)]
594#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
595pub enum dds_history_kind {
596 DDS_HISTORY_KEEP_LAST = 0,
597 DDS_HISTORY_KEEP_ALL = 1,
598}
599pub use self::dds_history_kind as dds_history_kind_t;
600#[repr(u32)]
601#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
602pub enum dds_ownership_kind {
603 DDS_OWNERSHIP_SHARED = 0,
604 DDS_OWNERSHIP_EXCLUSIVE = 1,
605}
606pub use self::dds_ownership_kind as dds_ownership_kind_t;
607#[repr(u32)]
608#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
609pub enum dds_liveliness_kind {
610 DDS_LIVELINESS_AUTOMATIC = 0,
611 DDS_LIVELINESS_MANUAL_BY_PARTICIPANT = 1,
612 DDS_LIVELINESS_MANUAL_BY_TOPIC = 2,
613}
614pub use self::dds_liveliness_kind as dds_liveliness_kind_t;
615#[repr(u32)]
616#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
617pub enum dds_reliability_kind {
618 DDS_RELIABILITY_BEST_EFFORT = 0,
619 DDS_RELIABILITY_RELIABLE = 1,
620}
621pub use self::dds_reliability_kind as dds_reliability_kind_t;
622#[repr(u32)]
623#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
624pub enum dds_destination_order_kind {
625 DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP = 0,
626 DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP = 1,
627}
628pub use self::dds_destination_order_kind as dds_destination_order_kind_t;
629#[repr(u32)]
630#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
631pub enum dds_presentation_access_scope_kind {
632 DDS_PRESENTATION_INSTANCE = 0,
633 DDS_PRESENTATION_TOPIC = 1,
634 DDS_PRESENTATION_GROUP = 2,
635}
636pub use self::dds_presentation_access_scope_kind as dds_presentation_access_scope_kind_t;
637#[repr(u32)]
638#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
639pub enum dds_ignorelocal_kind {
640 DDS_IGNORELOCAL_NONE = 0,
641 DDS_IGNORELOCAL_PARTICIPANT = 1,
642 DDS_IGNORELOCAL_PROCESS = 2,
643}
644pub use self::dds_ignorelocal_kind as dds_ignorelocal_kind_t;
645pub const dds_type_consistency_kind_DDS_TYPE_CONSISTENCY_DISALLOW_TYPE_COERCION:
646 dds_type_consistency_kind = 0;
647pub const dds_type_consistency_kind_DDS_TYPE_CONSISTENCY_ALLOW_TYPE_COERCION:
648 dds_type_consistency_kind = 1;
649pub type dds_type_consistency_kind = ::std::os::raw::c_uint;
650pub use self::dds_type_consistency_kind as dds_type_consistency_kind_t;
651pub type dds_data_representation_id_t = i16;
652extern "C" {
653 pub fn dds_create_qos() -> *mut dds_qos_t;
654}
655extern "C" {
656 pub fn dds_delete_qos(qos: *mut dds_qos_t);
657}
658extern "C" {
659 pub fn dds_reset_qos(qos: *mut dds_qos_t);
660}
661extern "C" {
662 pub fn dds_copy_qos(dst: *mut dds_qos_t, src: *const dds_qos_t) -> dds_return_t;
663}
664extern "C" {
665 pub fn dds_merge_qos(dst: *mut dds_qos_t, src: *const dds_qos_t);
666}
667extern "C" {
668 pub fn dds_qos_equal(a: *const dds_qos_t, b: *const dds_qos_t) -> bool;
669}
670extern "C" {
671 pub fn dds_qset_userdata(qos: *mut dds_qos_t, value: *const ::std::os::raw::c_void, sz: size_t);
672}
673extern "C" {
674 pub fn dds_qset_topicdata(
675 qos: *mut dds_qos_t,
676 value: *const ::std::os::raw::c_void,
677 sz: size_t,
678 );
679}
680extern "C" {
681 pub fn dds_qset_groupdata(
682 qos: *mut dds_qos_t,
683 value: *const ::std::os::raw::c_void,
684 sz: size_t,
685 );
686}
687extern "C" {
688 pub fn dds_qset_durability(qos: *mut dds_qos_t, kind: dds_durability_kind_t);
689}
690extern "C" {
691 pub fn dds_qset_history(qos: *mut dds_qos_t, kind: dds_history_kind_t, depth: i32);
692}
693extern "C" {
694 pub fn dds_qset_resource_limits(
695 qos: *mut dds_qos_t,
696 max_samples: i32,
697 max_instances: i32,
698 max_samples_per_instance: i32,
699 );
700}
701extern "C" {
702 pub fn dds_qset_presentation(
703 qos: *mut dds_qos_t,
704 access_scope: dds_presentation_access_scope_kind_t,
705 coherent_access: bool,
706 ordered_access: bool,
707 );
708}
709extern "C" {
710 pub fn dds_qset_lifespan(qos: *mut dds_qos_t, lifespan: dds_duration_t);
711}
712extern "C" {
713 pub fn dds_qset_deadline(qos: *mut dds_qos_t, deadline: dds_duration_t);
714}
715extern "C" {
716 pub fn dds_qset_latency_budget(qos: *mut dds_qos_t, duration: dds_duration_t);
717}
718extern "C" {
719 pub fn dds_qset_ownership(qos: *mut dds_qos_t, kind: dds_ownership_kind_t);
720}
721extern "C" {
722 pub fn dds_qset_ownership_strength(qos: *mut dds_qos_t, value: i32);
723}
724extern "C" {
725 pub fn dds_qset_liveliness(
726 qos: *mut dds_qos_t,
727 kind: dds_liveliness_kind_t,
728 lease_duration: dds_duration_t,
729 );
730}
731extern "C" {
732 pub fn dds_qset_time_based_filter(qos: *mut dds_qos_t, minimum_separation: dds_duration_t);
733}
734extern "C" {
735 pub fn dds_qset_partition(qos: *mut dds_qos_t, n: u32, ps: *mut *const ::std::os::raw::c_char);
736}
737extern "C" {
738 pub fn dds_qset_partition1(qos: *mut dds_qos_t, name: *const ::std::os::raw::c_char);
739}
740extern "C" {
741 pub fn dds_qset_reliability(
742 qos: *mut dds_qos_t,
743 kind: dds_reliability_kind_t,
744 max_blocking_time: dds_duration_t,
745 );
746}
747extern "C" {
748 pub fn dds_qset_transport_priority(qos: *mut dds_qos_t, value: i32);
749}
750extern "C" {
751 pub fn dds_qset_destination_order(qos: *mut dds_qos_t, kind: dds_destination_order_kind_t);
752}
753extern "C" {
754 pub fn dds_qset_writer_data_lifecycle(qos: *mut dds_qos_t, autodispose: bool);
755}
756extern "C" {
757 pub fn dds_qset_reader_data_lifecycle(
758 qos: *mut dds_qos_t,
759 autopurge_nowriter_samples_delay: dds_duration_t,
760 autopurge_disposed_samples_delay: dds_duration_t,
761 );
762}
763extern "C" {
764 pub fn dds_qset_durability_service(
765 qos: *mut dds_qos_t,
766 service_cleanup_delay: dds_duration_t,
767 history_kind: dds_history_kind_t,
768 history_depth: i32,
769 max_samples: i32,
770 max_instances: i32,
771 max_samples_per_instance: i32,
772 );
773}
774extern "C" {
775 pub fn dds_qset_ignorelocal(qos: *mut dds_qos_t, ignore: dds_ignorelocal_kind_t);
776}
777extern "C" {
778 pub fn dds_qget_userdata(
779 qos: *const dds_qos_t,
780 value: *mut *mut ::std::os::raw::c_void,
781 sz: *mut size_t,
782 ) -> bool;
783}
784extern "C" {
785 pub fn dds_qget_topicdata(
786 qos: *const dds_qos_t,
787 value: *mut *mut ::std::os::raw::c_void,
788 sz: *mut size_t,
789 ) -> bool;
790}
791extern "C" {
792 pub fn dds_qget_groupdata(
793 qos: *const dds_qos_t,
794 value: *mut *mut ::std::os::raw::c_void,
795 sz: *mut size_t,
796 ) -> bool;
797}
798extern "C" {
799 pub fn dds_qget_durability(qos: *const dds_qos_t, kind: *mut dds_durability_kind_t) -> bool;
800}
801extern "C" {
802 pub fn dds_qget_history(
803 qos: *const dds_qos_t,
804 kind: *mut dds_history_kind_t,
805 depth: *mut i32,
806 ) -> bool;
807}
808extern "C" {
809 pub fn dds_qget_resource_limits(
810 qos: *const dds_qos_t,
811 max_samples: *mut i32,
812 max_instances: *mut i32,
813 max_samples_per_instance: *mut i32,
814 ) -> bool;
815}
816extern "C" {
817 pub fn dds_qget_presentation(
818 qos: *const dds_qos_t,
819 access_scope: *mut dds_presentation_access_scope_kind_t,
820 coherent_access: *mut bool,
821 ordered_access: *mut bool,
822 ) -> bool;
823}
824extern "C" {
825 pub fn dds_qget_lifespan(qos: *const dds_qos_t, lifespan: *mut dds_duration_t) -> bool;
826}
827extern "C" {
828 pub fn dds_qget_deadline(qos: *const dds_qos_t, deadline: *mut dds_duration_t) -> bool;
829}
830extern "C" {
831 pub fn dds_qget_latency_budget(qos: *const dds_qos_t, duration: *mut dds_duration_t) -> bool;
832}
833extern "C" {
834 pub fn dds_qget_ownership(qos: *const dds_qos_t, kind: *mut dds_ownership_kind_t) -> bool;
835}
836extern "C" {
837 pub fn dds_qget_ownership_strength(qos: *const dds_qos_t, value: *mut i32) -> bool;
838}
839extern "C" {
840 pub fn dds_qget_liveliness(
841 qos: *const dds_qos_t,
842 kind: *mut dds_liveliness_kind_t,
843 lease_duration: *mut dds_duration_t,
844 ) -> bool;
845}
846extern "C" {
847 pub fn dds_qget_time_based_filter(
848 qos: *const dds_qos_t,
849 minimum_separation: *mut dds_duration_t,
850 ) -> bool;
851}
852extern "C" {
853 pub fn dds_qget_partition(
854 qos: *const dds_qos_t,
855 n: *mut u32,
856 ps: *mut *mut *mut ::std::os::raw::c_char,
857 ) -> bool;
858}
859extern "C" {
860 pub fn dds_qget_reliability(
861 qos: *const dds_qos_t,
862 kind: *mut dds_reliability_kind_t,
863 max_blocking_time: *mut dds_duration_t,
864 ) -> bool;
865}
866extern "C" {
867 pub fn dds_qget_transport_priority(qos: *const dds_qos_t, value: *mut i32) -> bool;
868}
869extern "C" {
870 pub fn dds_qget_destination_order(
871 qos: *const dds_qos_t,
872 kind: *mut dds_destination_order_kind_t,
873 ) -> bool;
874}
875extern "C" {
876 pub fn dds_qget_writer_data_lifecycle(qos: *const dds_qos_t, autodispose: *mut bool) -> bool;
877}
878extern "C" {
879 pub fn dds_qget_durability_service(
880 qos: *const dds_qos_t,
881 service_cleanup_delay: *mut dds_duration_t,
882 history_kind: *mut dds_history_kind_t,
883 history_depth: *mut i32,
884 max_samples: *mut i32,
885 max_instances: *mut i32,
886 max_samples_per_instance: *mut i32,
887 ) -> bool;
888}
889extern "C" {
890 pub fn dds_qget_ignorelocal(qos: *const dds_qos_t, ignore: *mut dds_ignorelocal_kind_t)
891 -> bool;
892}
893#[repr(C)]
894#[derive(Debug, Default, Copy, Clone)]
895pub struct dds_offered_deadline_missed_status {
896 pub total_count: u32,
897 pub total_count_change: i32,
898 pub last_instance_handle: dds_instance_handle_t,
899}
900#[test]
901fn bindgen_test_layout_dds_offered_deadline_missed_status() {
902 assert_eq!(
903 ::std::mem::size_of::<dds_offered_deadline_missed_status>(),
904 16usize,
905 concat!("Size of: ", stringify!(dds_offered_deadline_missed_status))
906 );
907 assert_eq!(
908 ::std::mem::align_of::<dds_offered_deadline_missed_status>(),
909 8usize,
910 concat!(
911 "Alignment of ",
912 stringify!(dds_offered_deadline_missed_status)
913 )
914 );
915 assert_eq!(
916 unsafe {
917 &(*(::std::ptr::null::<dds_offered_deadline_missed_status>())).total_count as *const _
918 as usize
919 },
920 0usize,
921 concat!(
922 "Offset of field: ",
923 stringify!(dds_offered_deadline_missed_status),
924 "::",
925 stringify!(total_count)
926 )
927 );
928 assert_eq!(
929 unsafe {
930 &(*(::std::ptr::null::<dds_offered_deadline_missed_status>())).total_count_change
931 as *const _ as usize
932 },
933 4usize,
934 concat!(
935 "Offset of field: ",
936 stringify!(dds_offered_deadline_missed_status),
937 "::",
938 stringify!(total_count_change)
939 )
940 );
941 assert_eq!(
942 unsafe {
943 &(*(::std::ptr::null::<dds_offered_deadline_missed_status>())).last_instance_handle
944 as *const _ as usize
945 },
946 8usize,
947 concat!(
948 "Offset of field: ",
949 stringify!(dds_offered_deadline_missed_status),
950 "::",
951 stringify!(last_instance_handle)
952 )
953 );
954}
955pub type dds_offered_deadline_missed_status_t = dds_offered_deadline_missed_status;
956#[repr(C)]
957#[derive(Debug, Default, Copy, Clone)]
958pub struct dds_offered_incompatible_qos_status {
959 pub total_count: u32,
960 pub total_count_change: i32,
961 pub last_policy_id: u32,
962}
963#[test]
964fn bindgen_test_layout_dds_offered_incompatible_qos_status() {
965 assert_eq!(
966 ::std::mem::size_of::<dds_offered_incompatible_qos_status>(),
967 12usize,
968 concat!("Size of: ", stringify!(dds_offered_incompatible_qos_status))
969 );
970 assert_eq!(
971 ::std::mem::align_of::<dds_offered_incompatible_qos_status>(),
972 4usize,
973 concat!(
974 "Alignment of ",
975 stringify!(dds_offered_incompatible_qos_status)
976 )
977 );
978 assert_eq!(
979 unsafe {
980 &(*(::std::ptr::null::<dds_offered_incompatible_qos_status>())).total_count as *const _
981 as usize
982 },
983 0usize,
984 concat!(
985 "Offset of field: ",
986 stringify!(dds_offered_incompatible_qos_status),
987 "::",
988 stringify!(total_count)
989 )
990 );
991 assert_eq!(
992 unsafe {
993 &(*(::std::ptr::null::<dds_offered_incompatible_qos_status>())).total_count_change
994 as *const _ as usize
995 },
996 4usize,
997 concat!(
998 "Offset of field: ",
999 stringify!(dds_offered_incompatible_qos_status),
1000 "::",
1001 stringify!(total_count_change)
1002 )
1003 );
1004 assert_eq!(
1005 unsafe {
1006 &(*(::std::ptr::null::<dds_offered_incompatible_qos_status>())).last_policy_id
1007 as *const _ as usize
1008 },
1009 8usize,
1010 concat!(
1011 "Offset of field: ",
1012 stringify!(dds_offered_incompatible_qos_status),
1013 "::",
1014 stringify!(last_policy_id)
1015 )
1016 );
1017}
1018pub type dds_offered_incompatible_qos_status_t = dds_offered_incompatible_qos_status;
1019#[repr(C)]
1020#[derive(Debug, Default, Copy, Clone)]
1021pub struct dds_publication_matched_status {
1022 pub total_count: u32,
1023 pub total_count_change: i32,
1024 pub current_count: u32,
1025 pub current_count_change: i32,
1026 pub last_subscription_handle: dds_instance_handle_t,
1027}
1028#[test]
1029fn bindgen_test_layout_dds_publication_matched_status() {
1030 assert_eq!(
1031 ::std::mem::size_of::<dds_publication_matched_status>(),
1032 24usize,
1033 concat!("Size of: ", stringify!(dds_publication_matched_status))
1034 );
1035 assert_eq!(
1036 ::std::mem::align_of::<dds_publication_matched_status>(),
1037 8usize,
1038 concat!("Alignment of ", stringify!(dds_publication_matched_status))
1039 );
1040 assert_eq!(
1041 unsafe {
1042 &(*(::std::ptr::null::<dds_publication_matched_status>())).total_count as *const _
1043 as usize
1044 },
1045 0usize,
1046 concat!(
1047 "Offset of field: ",
1048 stringify!(dds_publication_matched_status),
1049 "::",
1050 stringify!(total_count)
1051 )
1052 );
1053 assert_eq!(
1054 unsafe {
1055 &(*(::std::ptr::null::<dds_publication_matched_status>())).total_count_change
1056 as *const _ as usize
1057 },
1058 4usize,
1059 concat!(
1060 "Offset of field: ",
1061 stringify!(dds_publication_matched_status),
1062 "::",
1063 stringify!(total_count_change)
1064 )
1065 );
1066 assert_eq!(
1067 unsafe {
1068 &(*(::std::ptr::null::<dds_publication_matched_status>())).current_count as *const _
1069 as usize
1070 },
1071 8usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(dds_publication_matched_status),
1075 "::",
1076 stringify!(current_count)
1077 )
1078 );
1079 assert_eq!(
1080 unsafe {
1081 &(*(::std::ptr::null::<dds_publication_matched_status>())).current_count_change
1082 as *const _ as usize
1083 },
1084 12usize,
1085 concat!(
1086 "Offset of field: ",
1087 stringify!(dds_publication_matched_status),
1088 "::",
1089 stringify!(current_count_change)
1090 )
1091 );
1092 assert_eq!(
1093 unsafe {
1094 &(*(::std::ptr::null::<dds_publication_matched_status>())).last_subscription_handle
1095 as *const _ as usize
1096 },
1097 16usize,
1098 concat!(
1099 "Offset of field: ",
1100 stringify!(dds_publication_matched_status),
1101 "::",
1102 stringify!(last_subscription_handle)
1103 )
1104 );
1105}
1106pub type dds_publication_matched_status_t = dds_publication_matched_status;
1107#[repr(C)]
1108#[derive(Debug, Default, Copy, Clone)]
1109pub struct dds_liveliness_lost_status {
1110 pub total_count: u32,
1111 pub total_count_change: i32,
1112}
1113#[test]
1114fn bindgen_test_layout_dds_liveliness_lost_status() {
1115 assert_eq!(
1116 ::std::mem::size_of::<dds_liveliness_lost_status>(),
1117 8usize,
1118 concat!("Size of: ", stringify!(dds_liveliness_lost_status))
1119 );
1120 assert_eq!(
1121 ::std::mem::align_of::<dds_liveliness_lost_status>(),
1122 4usize,
1123 concat!("Alignment of ", stringify!(dds_liveliness_lost_status))
1124 );
1125 assert_eq!(
1126 unsafe {
1127 &(*(::std::ptr::null::<dds_liveliness_lost_status>())).total_count as *const _ as usize
1128 },
1129 0usize,
1130 concat!(
1131 "Offset of field: ",
1132 stringify!(dds_liveliness_lost_status),
1133 "::",
1134 stringify!(total_count)
1135 )
1136 );
1137 assert_eq!(
1138 unsafe {
1139 &(*(::std::ptr::null::<dds_liveliness_lost_status>())).total_count_change as *const _
1140 as usize
1141 },
1142 4usize,
1143 concat!(
1144 "Offset of field: ",
1145 stringify!(dds_liveliness_lost_status),
1146 "::",
1147 stringify!(total_count_change)
1148 )
1149 );
1150}
1151pub type dds_liveliness_lost_status_t = dds_liveliness_lost_status;
1152#[repr(C)]
1153#[derive(Debug, Default, Copy, Clone)]
1154pub struct dds_subscription_matched_status {
1155 pub total_count: u32,
1156 pub total_count_change: i32,
1157 pub current_count: u32,
1158 pub current_count_change: i32,
1159 pub last_publication_handle: dds_instance_handle_t,
1160}
1161#[test]
1162fn bindgen_test_layout_dds_subscription_matched_status() {
1163 assert_eq!(
1164 ::std::mem::size_of::<dds_subscription_matched_status>(),
1165 24usize,
1166 concat!("Size of: ", stringify!(dds_subscription_matched_status))
1167 );
1168 assert_eq!(
1169 ::std::mem::align_of::<dds_subscription_matched_status>(),
1170 8usize,
1171 concat!("Alignment of ", stringify!(dds_subscription_matched_status))
1172 );
1173 assert_eq!(
1174 unsafe {
1175 &(*(::std::ptr::null::<dds_subscription_matched_status>())).total_count as *const _
1176 as usize
1177 },
1178 0usize,
1179 concat!(
1180 "Offset of field: ",
1181 stringify!(dds_subscription_matched_status),
1182 "::",
1183 stringify!(total_count)
1184 )
1185 );
1186 assert_eq!(
1187 unsafe {
1188 &(*(::std::ptr::null::<dds_subscription_matched_status>())).total_count_change
1189 as *const _ as usize
1190 },
1191 4usize,
1192 concat!(
1193 "Offset of field: ",
1194 stringify!(dds_subscription_matched_status),
1195 "::",
1196 stringify!(total_count_change)
1197 )
1198 );
1199 assert_eq!(
1200 unsafe {
1201 &(*(::std::ptr::null::<dds_subscription_matched_status>())).current_count as *const _
1202 as usize
1203 },
1204 8usize,
1205 concat!(
1206 "Offset of field: ",
1207 stringify!(dds_subscription_matched_status),
1208 "::",
1209 stringify!(current_count)
1210 )
1211 );
1212 assert_eq!(
1213 unsafe {
1214 &(*(::std::ptr::null::<dds_subscription_matched_status>())).current_count_change
1215 as *const _ as usize
1216 },
1217 12usize,
1218 concat!(
1219 "Offset of field: ",
1220 stringify!(dds_subscription_matched_status),
1221 "::",
1222 stringify!(current_count_change)
1223 )
1224 );
1225 assert_eq!(
1226 unsafe {
1227 &(*(::std::ptr::null::<dds_subscription_matched_status>())).last_publication_handle
1228 as *const _ as usize
1229 },
1230 16usize,
1231 concat!(
1232 "Offset of field: ",
1233 stringify!(dds_subscription_matched_status),
1234 "::",
1235 stringify!(last_publication_handle)
1236 )
1237 );
1238}
1239pub type dds_subscription_matched_status_t = dds_subscription_matched_status;
1240pub const dds_sample_rejected_status_kind_DDS_NOT_REJECTED: dds_sample_rejected_status_kind = 0;
1241pub const dds_sample_rejected_status_kind_DDS_REJECTED_BY_INSTANCES_LIMIT:
1242 dds_sample_rejected_status_kind = 1;
1243pub const dds_sample_rejected_status_kind_DDS_REJECTED_BY_SAMPLES_LIMIT:
1244 dds_sample_rejected_status_kind = 2;
1245pub const dds_sample_rejected_status_kind_DDS_REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT:
1246 dds_sample_rejected_status_kind = 3;
1247pub type dds_sample_rejected_status_kind = ::std::os::raw::c_uint;
1248#[repr(C)]
1249#[derive(Debug, Copy, Clone)]
1250pub struct dds_sample_rejected_status {
1251 pub total_count: u32,
1252 pub total_count_change: i32,
1253 pub last_reason: dds_sample_rejected_status_kind,
1254 pub last_instance_handle: dds_instance_handle_t,
1255}
1256#[test]
1257fn bindgen_test_layout_dds_sample_rejected_status() {
1258 assert_eq!(
1259 ::std::mem::size_of::<dds_sample_rejected_status>(),
1260 24usize,
1261 concat!("Size of: ", stringify!(dds_sample_rejected_status))
1262 );
1263 assert_eq!(
1264 ::std::mem::align_of::<dds_sample_rejected_status>(),
1265 8usize,
1266 concat!("Alignment of ", stringify!(dds_sample_rejected_status))
1267 );
1268 assert_eq!(
1269 unsafe {
1270 &(*(::std::ptr::null::<dds_sample_rejected_status>())).total_count as *const _ as usize
1271 },
1272 0usize,
1273 concat!(
1274 "Offset of field: ",
1275 stringify!(dds_sample_rejected_status),
1276 "::",
1277 stringify!(total_count)
1278 )
1279 );
1280 assert_eq!(
1281 unsafe {
1282 &(*(::std::ptr::null::<dds_sample_rejected_status>())).total_count_change as *const _
1283 as usize
1284 },
1285 4usize,
1286 concat!(
1287 "Offset of field: ",
1288 stringify!(dds_sample_rejected_status),
1289 "::",
1290 stringify!(total_count_change)
1291 )
1292 );
1293 assert_eq!(
1294 unsafe {
1295 &(*(::std::ptr::null::<dds_sample_rejected_status>())).last_reason as *const _ as usize
1296 },
1297 8usize,
1298 concat!(
1299 "Offset of field: ",
1300 stringify!(dds_sample_rejected_status),
1301 "::",
1302 stringify!(last_reason)
1303 )
1304 );
1305 assert_eq!(
1306 unsafe {
1307 &(*(::std::ptr::null::<dds_sample_rejected_status>())).last_instance_handle as *const _
1308 as usize
1309 },
1310 16usize,
1311 concat!(
1312 "Offset of field: ",
1313 stringify!(dds_sample_rejected_status),
1314 "::",
1315 stringify!(last_instance_handle)
1316 )
1317 );
1318}
1319impl Default for dds_sample_rejected_status {
1320 fn default() -> Self {
1321 unsafe { ::std::mem::zeroed() }
1322 }
1323}
1324pub type dds_sample_rejected_status_t = dds_sample_rejected_status;
1325#[repr(C)]
1326#[derive(Debug, Default, Copy, Clone)]
1327pub struct dds_liveliness_changed_status {
1328 pub alive_count: u32,
1329 pub not_alive_count: u32,
1330 pub alive_count_change: i32,
1331 pub not_alive_count_change: i32,
1332 pub last_publication_handle: dds_instance_handle_t,
1333}
1334#[test]
1335fn bindgen_test_layout_dds_liveliness_changed_status() {
1336 assert_eq!(
1337 ::std::mem::size_of::<dds_liveliness_changed_status>(),
1338 24usize,
1339 concat!("Size of: ", stringify!(dds_liveliness_changed_status))
1340 );
1341 assert_eq!(
1342 ::std::mem::align_of::<dds_liveliness_changed_status>(),
1343 8usize,
1344 concat!("Alignment of ", stringify!(dds_liveliness_changed_status))
1345 );
1346 assert_eq!(
1347 unsafe {
1348 &(*(::std::ptr::null::<dds_liveliness_changed_status>())).alive_count as *const _
1349 as usize
1350 },
1351 0usize,
1352 concat!(
1353 "Offset of field: ",
1354 stringify!(dds_liveliness_changed_status),
1355 "::",
1356 stringify!(alive_count)
1357 )
1358 );
1359 assert_eq!(
1360 unsafe {
1361 &(*(::std::ptr::null::<dds_liveliness_changed_status>())).not_alive_count as *const _
1362 as usize
1363 },
1364 4usize,
1365 concat!(
1366 "Offset of field: ",
1367 stringify!(dds_liveliness_changed_status),
1368 "::",
1369 stringify!(not_alive_count)
1370 )
1371 );
1372 assert_eq!(
1373 unsafe {
1374 &(*(::std::ptr::null::<dds_liveliness_changed_status>())).alive_count_change as *const _
1375 as usize
1376 },
1377 8usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(dds_liveliness_changed_status),
1381 "::",
1382 stringify!(alive_count_change)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe {
1387 &(*(::std::ptr::null::<dds_liveliness_changed_status>())).not_alive_count_change
1388 as *const _ as usize
1389 },
1390 12usize,
1391 concat!(
1392 "Offset of field: ",
1393 stringify!(dds_liveliness_changed_status),
1394 "::",
1395 stringify!(not_alive_count_change)
1396 )
1397 );
1398 assert_eq!(
1399 unsafe {
1400 &(*(::std::ptr::null::<dds_liveliness_changed_status>())).last_publication_handle
1401 as *const _ as usize
1402 },
1403 16usize,
1404 concat!(
1405 "Offset of field: ",
1406 stringify!(dds_liveliness_changed_status),
1407 "::",
1408 stringify!(last_publication_handle)
1409 )
1410 );
1411}
1412pub type dds_liveliness_changed_status_t = dds_liveliness_changed_status;
1413#[repr(C)]
1414#[derive(Debug, Default, Copy, Clone)]
1415pub struct dds_requested_deadline_missed_status {
1416 pub total_count: u32,
1417 pub total_count_change: i32,
1418 pub last_instance_handle: dds_instance_handle_t,
1419}
1420#[test]
1421fn bindgen_test_layout_dds_requested_deadline_missed_status() {
1422 assert_eq!(
1423 ::std::mem::size_of::<dds_requested_deadline_missed_status>(),
1424 16usize,
1425 concat!(
1426 "Size of: ",
1427 stringify!(dds_requested_deadline_missed_status)
1428 )
1429 );
1430 assert_eq!(
1431 ::std::mem::align_of::<dds_requested_deadline_missed_status>(),
1432 8usize,
1433 concat!(
1434 "Alignment of ",
1435 stringify!(dds_requested_deadline_missed_status)
1436 )
1437 );
1438 assert_eq!(
1439 unsafe {
1440 &(*(::std::ptr::null::<dds_requested_deadline_missed_status>())).total_count as *const _
1441 as usize
1442 },
1443 0usize,
1444 concat!(
1445 "Offset of field: ",
1446 stringify!(dds_requested_deadline_missed_status),
1447 "::",
1448 stringify!(total_count)
1449 )
1450 );
1451 assert_eq!(
1452 unsafe {
1453 &(*(::std::ptr::null::<dds_requested_deadline_missed_status>())).total_count_change
1454 as *const _ as usize
1455 },
1456 4usize,
1457 concat!(
1458 "Offset of field: ",
1459 stringify!(dds_requested_deadline_missed_status),
1460 "::",
1461 stringify!(total_count_change)
1462 )
1463 );
1464 assert_eq!(
1465 unsafe {
1466 &(*(::std::ptr::null::<dds_requested_deadline_missed_status>())).last_instance_handle
1467 as *const _ as usize
1468 },
1469 8usize,
1470 concat!(
1471 "Offset of field: ",
1472 stringify!(dds_requested_deadline_missed_status),
1473 "::",
1474 stringify!(last_instance_handle)
1475 )
1476 );
1477}
1478pub type dds_requested_deadline_missed_status_t = dds_requested_deadline_missed_status;
1479#[repr(C)]
1480#[derive(Debug, Default, Copy, Clone)]
1481pub struct dds_requested_incompatible_qos_status {
1482 pub total_count: u32,
1483 pub total_count_change: i32,
1484 pub last_policy_id: u32,
1485}
1486#[test]
1487fn bindgen_test_layout_dds_requested_incompatible_qos_status() {
1488 assert_eq!(
1489 ::std::mem::size_of::<dds_requested_incompatible_qos_status>(),
1490 12usize,
1491 concat!(
1492 "Size of: ",
1493 stringify!(dds_requested_incompatible_qos_status)
1494 )
1495 );
1496 assert_eq!(
1497 ::std::mem::align_of::<dds_requested_incompatible_qos_status>(),
1498 4usize,
1499 concat!(
1500 "Alignment of ",
1501 stringify!(dds_requested_incompatible_qos_status)
1502 )
1503 );
1504 assert_eq!(
1505 unsafe {
1506 &(*(::std::ptr::null::<dds_requested_incompatible_qos_status>())).total_count
1507 as *const _ as usize
1508 },
1509 0usize,
1510 concat!(
1511 "Offset of field: ",
1512 stringify!(dds_requested_incompatible_qos_status),
1513 "::",
1514 stringify!(total_count)
1515 )
1516 );
1517 assert_eq!(
1518 unsafe {
1519 &(*(::std::ptr::null::<dds_requested_incompatible_qos_status>())).total_count_change
1520 as *const _ as usize
1521 },
1522 4usize,
1523 concat!(
1524 "Offset of field: ",
1525 stringify!(dds_requested_incompatible_qos_status),
1526 "::",
1527 stringify!(total_count_change)
1528 )
1529 );
1530 assert_eq!(
1531 unsafe {
1532 &(*(::std::ptr::null::<dds_requested_incompatible_qos_status>())).last_policy_id
1533 as *const _ as usize
1534 },
1535 8usize,
1536 concat!(
1537 "Offset of field: ",
1538 stringify!(dds_requested_incompatible_qos_status),
1539 "::",
1540 stringify!(last_policy_id)
1541 )
1542 );
1543}
1544pub type dds_requested_incompatible_qos_status_t = dds_requested_incompatible_qos_status;
1545#[repr(C)]
1546#[derive(Debug, Default, Copy, Clone)]
1547pub struct dds_sample_lost_status {
1548 pub total_count: u32,
1549 pub total_count_change: i32,
1550}
1551#[test]
1552fn bindgen_test_layout_dds_sample_lost_status() {
1553 assert_eq!(
1554 ::std::mem::size_of::<dds_sample_lost_status>(),
1555 8usize,
1556 concat!("Size of: ", stringify!(dds_sample_lost_status))
1557 );
1558 assert_eq!(
1559 ::std::mem::align_of::<dds_sample_lost_status>(),
1560 4usize,
1561 concat!("Alignment of ", stringify!(dds_sample_lost_status))
1562 );
1563 assert_eq!(
1564 unsafe {
1565 &(*(::std::ptr::null::<dds_sample_lost_status>())).total_count as *const _ as usize
1566 },
1567 0usize,
1568 concat!(
1569 "Offset of field: ",
1570 stringify!(dds_sample_lost_status),
1571 "::",
1572 stringify!(total_count)
1573 )
1574 );
1575 assert_eq!(
1576 unsafe {
1577 &(*(::std::ptr::null::<dds_sample_lost_status>())).total_count_change as *const _
1578 as usize
1579 },
1580 4usize,
1581 concat!(
1582 "Offset of field: ",
1583 stringify!(dds_sample_lost_status),
1584 "::",
1585 stringify!(total_count_change)
1586 )
1587 );
1588}
1589pub type dds_sample_lost_status_t = dds_sample_lost_status;
1590#[repr(C)]
1591#[derive(Debug, Default, Copy, Clone)]
1592pub struct dds_inconsistent_topic_status {
1593 pub total_count: u32,
1594 pub total_count_change: i32,
1595}
1596#[test]
1597fn bindgen_test_layout_dds_inconsistent_topic_status() {
1598 assert_eq!(
1599 ::std::mem::size_of::<dds_inconsistent_topic_status>(),
1600 8usize,
1601 concat!("Size of: ", stringify!(dds_inconsistent_topic_status))
1602 );
1603 assert_eq!(
1604 ::std::mem::align_of::<dds_inconsistent_topic_status>(),
1605 4usize,
1606 concat!("Alignment of ", stringify!(dds_inconsistent_topic_status))
1607 );
1608 assert_eq!(
1609 unsafe {
1610 &(*(::std::ptr::null::<dds_inconsistent_topic_status>())).total_count as *const _
1611 as usize
1612 },
1613 0usize,
1614 concat!(
1615 "Offset of field: ",
1616 stringify!(dds_inconsistent_topic_status),
1617 "::",
1618 stringify!(total_count)
1619 )
1620 );
1621 assert_eq!(
1622 unsafe {
1623 &(*(::std::ptr::null::<dds_inconsistent_topic_status>())).total_count_change as *const _
1624 as usize
1625 },
1626 4usize,
1627 concat!(
1628 "Offset of field: ",
1629 stringify!(dds_inconsistent_topic_status),
1630 "::",
1631 stringify!(total_count_change)
1632 )
1633 );
1634}
1635pub type dds_inconsistent_topic_status_t = dds_inconsistent_topic_status;
1636extern "C" {
1637 pub fn dds_get_inconsistent_topic_status(
1638 topic: dds_entity_t,
1639 status: *mut dds_inconsistent_topic_status_t,
1640 ) -> dds_return_t;
1641}
1642extern "C" {
1643 pub fn dds_get_publication_matched_status(
1644 writer: dds_entity_t,
1645 status: *mut dds_publication_matched_status_t,
1646 ) -> dds_return_t;
1647}
1648extern "C" {
1649 pub fn dds_get_liveliness_lost_status(
1650 writer: dds_entity_t,
1651 status: *mut dds_liveliness_lost_status_t,
1652 ) -> dds_return_t;
1653}
1654extern "C" {
1655 pub fn dds_get_offered_deadline_missed_status(
1656 writer: dds_entity_t,
1657 status: *mut dds_offered_deadline_missed_status_t,
1658 ) -> dds_return_t;
1659}
1660extern "C" {
1661 pub fn dds_get_offered_incompatible_qos_status(
1662 writer: dds_entity_t,
1663 status: *mut dds_offered_incompatible_qos_status_t,
1664 ) -> dds_return_t;
1665}
1666extern "C" {
1667 pub fn dds_get_subscription_matched_status(
1668 reader: dds_entity_t,
1669 status: *mut dds_subscription_matched_status_t,
1670 ) -> dds_return_t;
1671}
1672extern "C" {
1673 pub fn dds_get_liveliness_changed_status(
1674 reader: dds_entity_t,
1675 status: *mut dds_liveliness_changed_status_t,
1676 ) -> dds_return_t;
1677}
1678extern "C" {
1679 pub fn dds_get_sample_rejected_status(
1680 reader: dds_entity_t,
1681 status: *mut dds_sample_rejected_status_t,
1682 ) -> dds_return_t;
1683}
1684extern "C" {
1685 pub fn dds_get_sample_lost_status(
1686 reader: dds_entity_t,
1687 status: *mut dds_sample_lost_status_t,
1688 ) -> dds_return_t;
1689}
1690extern "C" {
1691 pub fn dds_get_requested_deadline_missed_status(
1692 reader: dds_entity_t,
1693 status: *mut dds_requested_deadline_missed_status_t,
1694 ) -> dds_return_t;
1695}
1696extern "C" {
1697 pub fn dds_get_requested_incompatible_qos_status(
1698 reader: dds_entity_t,
1699 status: *mut dds_requested_incompatible_qos_status_t,
1700 ) -> dds_return_t;
1701}
1702pub type dds_on_inconsistent_topic_fn = ::std::option::Option<
1703 unsafe extern "C" fn(
1704 topic: dds_entity_t,
1705 status: dds_inconsistent_topic_status_t,
1706 arg: *mut ::std::os::raw::c_void,
1707 ),
1708>;
1709pub type dds_on_liveliness_lost_fn = ::std::option::Option<
1710 unsafe extern "C" fn(
1711 writer: dds_entity_t,
1712 status: dds_liveliness_lost_status_t,
1713 arg: *mut ::std::os::raw::c_void,
1714 ),
1715>;
1716pub type dds_on_offered_deadline_missed_fn = ::std::option::Option<
1717 unsafe extern "C" fn(
1718 writer: dds_entity_t,
1719 status: dds_offered_deadline_missed_status_t,
1720 arg: *mut ::std::os::raw::c_void,
1721 ),
1722>;
1723pub type dds_on_offered_incompatible_qos_fn = ::std::option::Option<
1724 unsafe extern "C" fn(
1725 writer: dds_entity_t,
1726 status: dds_offered_incompatible_qos_status_t,
1727 arg: *mut ::std::os::raw::c_void,
1728 ),
1729>;
1730pub type dds_on_data_on_readers_fn = ::std::option::Option<
1731 unsafe extern "C" fn(subscriber: dds_entity_t, arg: *mut ::std::os::raw::c_void),
1732>;
1733pub type dds_on_sample_lost_fn = ::std::option::Option<
1734 unsafe extern "C" fn(
1735 reader: dds_entity_t,
1736 status: dds_sample_lost_status_t,
1737 arg: *mut ::std::os::raw::c_void,
1738 ),
1739>;
1740pub type dds_on_data_available_fn = ::std::option::Option<
1741 unsafe extern "C" fn(reader: dds_entity_t, arg: *mut ::std::os::raw::c_void),
1742>;
1743pub type dds_on_sample_rejected_fn = ::std::option::Option<
1744 unsafe extern "C" fn(
1745 reader: dds_entity_t,
1746 status: dds_sample_rejected_status_t,
1747 arg: *mut ::std::os::raw::c_void,
1748 ),
1749>;
1750pub type dds_on_liveliness_changed_fn = ::std::option::Option<
1751 unsafe extern "C" fn(
1752 reader: dds_entity_t,
1753 status: dds_liveliness_changed_status_t,
1754 arg: *mut ::std::os::raw::c_void,
1755 ),
1756>;
1757pub type dds_on_requested_deadline_missed_fn = ::std::option::Option<
1758 unsafe extern "C" fn(
1759 reader: dds_entity_t,
1760 status: dds_requested_deadline_missed_status_t,
1761 arg: *mut ::std::os::raw::c_void,
1762 ),
1763>;
1764pub type dds_on_requested_incompatible_qos_fn = ::std::option::Option<
1765 unsafe extern "C" fn(
1766 reader: dds_entity_t,
1767 status: dds_requested_incompatible_qos_status_t,
1768 arg: *mut ::std::os::raw::c_void,
1769 ),
1770>;
1771pub type dds_on_publication_matched_fn = ::std::option::Option<
1772 unsafe extern "C" fn(
1773 writer: dds_entity_t,
1774 status: dds_publication_matched_status_t,
1775 arg: *mut ::std::os::raw::c_void,
1776 ),
1777>;
1778pub type dds_on_subscription_matched_fn = ::std::option::Option<
1779 unsafe extern "C" fn(
1780 reader: dds_entity_t,
1781 status: dds_subscription_matched_status_t,
1782 arg: *mut ::std::os::raw::c_void,
1783 ),
1784>;
1785#[repr(C)]
1786#[derive(Debug, Copy, Clone)]
1787pub struct dds_listener {
1788 _unused: [u8; 0],
1789}
1790pub type dds_listener_t = dds_listener;
1791extern "C" {
1792 pub fn dds_create_listener(arg: *mut ::std::os::raw::c_void) -> *mut dds_listener_t;
1793}
1794extern "C" {
1795 pub fn dds_delete_listener(listener: *mut dds_listener_t);
1796}
1797extern "C" {
1798 pub fn dds_reset_listener(listener: *mut dds_listener_t);
1799}
1800extern "C" {
1801 pub fn dds_copy_listener(dst: *mut dds_listener_t, src: *const dds_listener_t);
1802}
1803extern "C" {
1804 pub fn dds_merge_listener(dst: *mut dds_listener_t, src: *const dds_listener_t);
1805}
1806extern "C" {
1807 pub fn dds_lset_inconsistent_topic(
1808 listener: *mut dds_listener_t,
1809 callback: dds_on_inconsistent_topic_fn,
1810 );
1811}
1812extern "C" {
1813 pub fn dds_lset_liveliness_lost(
1814 listener: *mut dds_listener_t,
1815 callback: dds_on_liveliness_lost_fn,
1816 );
1817}
1818extern "C" {
1819 pub fn dds_lset_offered_deadline_missed(
1820 listener: *mut dds_listener_t,
1821 callback: dds_on_offered_deadline_missed_fn,
1822 );
1823}
1824extern "C" {
1825 pub fn dds_lset_offered_incompatible_qos(
1826 listener: *mut dds_listener_t,
1827 callback: dds_on_offered_incompatible_qos_fn,
1828 );
1829}
1830extern "C" {
1831 pub fn dds_lset_data_on_readers(
1832 listener: *mut dds_listener_t,
1833 callback: dds_on_data_on_readers_fn,
1834 );
1835}
1836extern "C" {
1837 pub fn dds_lset_sample_lost(listener: *mut dds_listener_t, callback: dds_on_sample_lost_fn);
1838}
1839extern "C" {
1840 pub fn dds_lset_data_available(
1841 listener: *mut dds_listener_t,
1842 callback: dds_on_data_available_fn,
1843 );
1844}
1845extern "C" {
1846 pub fn dds_lset_sample_rejected(
1847 listener: *mut dds_listener_t,
1848 callback: dds_on_sample_rejected_fn,
1849 );
1850}
1851extern "C" {
1852 pub fn dds_lset_liveliness_changed(
1853 listener: *mut dds_listener_t,
1854 callback: dds_on_liveliness_changed_fn,
1855 );
1856}
1857extern "C" {
1858 pub fn dds_lset_requested_deadline_missed(
1859 listener: *mut dds_listener_t,
1860 callback: dds_on_requested_deadline_missed_fn,
1861 );
1862}
1863extern "C" {
1864 pub fn dds_lset_requested_incompatible_qos(
1865 listener: *mut dds_listener_t,
1866 callback: dds_on_requested_incompatible_qos_fn,
1867 );
1868}
1869extern "C" {
1870 pub fn dds_lset_publication_matched(
1871 listener: *mut dds_listener_t,
1872 callback: dds_on_publication_matched_fn,
1873 );
1874}
1875extern "C" {
1876 pub fn dds_lset_subscription_matched(
1877 listener: *mut dds_listener_t,
1878 callback: dds_on_subscription_matched_fn,
1879 );
1880}
1881extern "C" {
1882 pub fn dds_lget_inconsistent_topic(
1883 listener: *const dds_listener_t,
1884 callback: *mut dds_on_inconsistent_topic_fn,
1885 );
1886}
1887extern "C" {
1888 pub fn dds_lget_liveliness_lost(
1889 listener: *const dds_listener_t,
1890 callback: *mut dds_on_liveliness_lost_fn,
1891 );
1892}
1893extern "C" {
1894 pub fn dds_lget_offered_deadline_missed(
1895 listener: *const dds_listener_t,
1896 callback: *mut dds_on_offered_deadline_missed_fn,
1897 );
1898}
1899extern "C" {
1900 pub fn dds_lget_offered_incompatible_qos(
1901 listener: *const dds_listener_t,
1902 callback: *mut dds_on_offered_incompatible_qos_fn,
1903 );
1904}
1905extern "C" {
1906 pub fn dds_lget_data_on_readers(
1907 listener: *const dds_listener_t,
1908 callback: *mut dds_on_data_on_readers_fn,
1909 );
1910}
1911extern "C" {
1912 pub fn dds_lget_sample_lost(
1913 listener: *const dds_listener_t,
1914 callback: *mut dds_on_sample_lost_fn,
1915 );
1916}
1917extern "C" {
1918 pub fn dds_lget_data_available(
1919 listener: *const dds_listener_t,
1920 callback: *mut dds_on_data_available_fn,
1921 );
1922}
1923extern "C" {
1924 pub fn dds_lget_sample_rejected(
1925 listener: *const dds_listener_t,
1926 callback: *mut dds_on_sample_rejected_fn,
1927 );
1928}
1929extern "C" {
1930 pub fn dds_lget_liveliness_changed(
1931 listener: *const dds_listener_t,
1932 callback: *mut dds_on_liveliness_changed_fn,
1933 );
1934}
1935extern "C" {
1936 pub fn dds_lget_requested_deadline_missed(
1937 listener: *const dds_listener_t,
1938 callback: *mut dds_on_requested_deadline_missed_fn,
1939 );
1940}
1941extern "C" {
1942 pub fn dds_lget_requested_incompatible_qos(
1943 listener: *const dds_listener_t,
1944 callback: *mut dds_on_requested_incompatible_qos_fn,
1945 );
1946}
1947extern "C" {
1948 pub fn dds_lget_publication_matched(
1949 listener: *const dds_listener_t,
1950 callback: *mut dds_on_publication_matched_fn,
1951 );
1952}
1953extern "C" {
1954 pub fn dds_lget_subscription_matched(
1955 listener: *const dds_listener_t,
1956 callback: *mut dds_on_subscription_matched_fn,
1957 );
1958}
1959#[repr(C)]
1960#[derive(Debug, Copy, Clone)]
1961pub struct ddsi_typeid {
1962 _unused: [u8; 0],
1963}
1964#[repr(C)]
1965#[derive(Debug, Copy, Clone)]
1966pub struct ddsi_typeinfo {
1967 _unused: [u8; 0],
1968}
1969pub type dds_typeinfo_t = ddsi_typeinfo;
1970#[repr(C)]
1971#[derive(Debug, Copy, Clone)]
1972pub struct dds_rhc {
1973 _unused: [u8; 0],
1974}
1975#[repr(C)]
1976#[derive(Debug, Copy, Clone)]
1977pub struct ddsi_plist {
1978 _unused: [u8; 0],
1979}
1980#[repr(C)]
1981#[derive(Debug, Copy, Clone)]
1982pub struct ddsi_sertopic {
1983 _unused: [u8; 0],
1984}
1985pub const dds_status_id_DDS_INCONSISTENT_TOPIC_STATUS_ID: dds_status_id = 0;
1986pub const dds_status_id_DDS_OFFERED_DEADLINE_MISSED_STATUS_ID: dds_status_id = 1;
1987pub const dds_status_id_DDS_REQUESTED_DEADLINE_MISSED_STATUS_ID: dds_status_id = 2;
1988pub const dds_status_id_DDS_OFFERED_INCOMPATIBLE_QOS_STATUS_ID: dds_status_id = 3;
1989pub const dds_status_id_DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS_ID: dds_status_id = 4;
1990pub const dds_status_id_DDS_SAMPLE_LOST_STATUS_ID: dds_status_id = 5;
1991pub const dds_status_id_DDS_SAMPLE_REJECTED_STATUS_ID: dds_status_id = 6;
1992pub const dds_status_id_DDS_DATA_ON_READERS_STATUS_ID: dds_status_id = 7;
1993pub const dds_status_id_DDS_DATA_AVAILABLE_STATUS_ID: dds_status_id = 8;
1994pub const dds_status_id_DDS_LIVELINESS_LOST_STATUS_ID: dds_status_id = 9;
1995pub const dds_status_id_DDS_LIVELINESS_CHANGED_STATUS_ID: dds_status_id = 10;
1996pub const dds_status_id_DDS_PUBLICATION_MATCHED_STATUS_ID: dds_status_id = 11;
1997pub const dds_status_id_DDS_SUBSCRIPTION_MATCHED_STATUS_ID: dds_status_id = 12;
1998pub type dds_status_id = ::std::os::raw::c_uint;
1999pub use self::dds_status_id as dds_status_id_t;
2000pub const dds_sample_state_DDS_SST_READ: dds_sample_state = 1;
2001pub const dds_sample_state_DDS_SST_NOT_READ: dds_sample_state = 2;
2002pub type dds_sample_state = ::std::os::raw::c_uint;
2003pub use self::dds_sample_state as dds_sample_state_t;
2004pub const dds_view_state_DDS_VST_NEW: dds_view_state = 4;
2005pub const dds_view_state_DDS_VST_OLD: dds_view_state = 8;
2006pub type dds_view_state = ::std::os::raw::c_uint;
2007pub use self::dds_view_state as dds_view_state_t;
2008pub const dds_instance_state_DDS_IST_ALIVE: dds_instance_state = 16;
2009pub const dds_instance_state_DDS_IST_NOT_ALIVE_DISPOSED: dds_instance_state = 32;
2010pub const dds_instance_state_DDS_IST_NOT_ALIVE_NO_WRITERS: dds_instance_state = 64;
2011pub type dds_instance_state = ::std::os::raw::c_uint;
2012pub use self::dds_instance_state as dds_instance_state_t;
2013#[repr(C)]
2014#[derive(Debug, Copy, Clone)]
2015pub struct dds_sample_info {
2016 pub sample_state: dds_sample_state_t,
2017 pub view_state: dds_view_state_t,
2018 pub instance_state: dds_instance_state_t,
2019 pub valid_data: bool,
2020 pub source_timestamp: dds_time_t,
2021 pub instance_handle: dds_instance_handle_t,
2022 pub publication_handle: dds_instance_handle_t,
2023 pub disposed_generation_count: u32,
2024 pub no_writers_generation_count: u32,
2025 pub sample_rank: u32,
2026 pub generation_rank: u32,
2027 pub absolute_generation_rank: u32,
2028}
2029#[test]
2030fn bindgen_test_layout_dds_sample_info() {
2031 assert_eq!(
2032 ::std::mem::size_of::<dds_sample_info>(),
2033 64usize,
2034 concat!("Size of: ", stringify!(dds_sample_info))
2035 );
2036 assert_eq!(
2037 ::std::mem::align_of::<dds_sample_info>(),
2038 8usize,
2039 concat!("Alignment of ", stringify!(dds_sample_info))
2040 );
2041 assert_eq!(
2042 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).sample_state as *const _ as usize },
2043 0usize,
2044 concat!(
2045 "Offset of field: ",
2046 stringify!(dds_sample_info),
2047 "::",
2048 stringify!(sample_state)
2049 )
2050 );
2051 assert_eq!(
2052 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).view_state as *const _ as usize },
2053 4usize,
2054 concat!(
2055 "Offset of field: ",
2056 stringify!(dds_sample_info),
2057 "::",
2058 stringify!(view_state)
2059 )
2060 );
2061 assert_eq!(
2062 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).instance_state as *const _ as usize },
2063 8usize,
2064 concat!(
2065 "Offset of field: ",
2066 stringify!(dds_sample_info),
2067 "::",
2068 stringify!(instance_state)
2069 )
2070 );
2071 assert_eq!(
2072 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).valid_data as *const _ as usize },
2073 12usize,
2074 concat!(
2075 "Offset of field: ",
2076 stringify!(dds_sample_info),
2077 "::",
2078 stringify!(valid_data)
2079 )
2080 );
2081 assert_eq!(
2082 unsafe {
2083 &(*(::std::ptr::null::<dds_sample_info>())).source_timestamp as *const _ as usize
2084 },
2085 16usize,
2086 concat!(
2087 "Offset of field: ",
2088 stringify!(dds_sample_info),
2089 "::",
2090 stringify!(source_timestamp)
2091 )
2092 );
2093 assert_eq!(
2094 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).instance_handle as *const _ as usize },
2095 24usize,
2096 concat!(
2097 "Offset of field: ",
2098 stringify!(dds_sample_info),
2099 "::",
2100 stringify!(instance_handle)
2101 )
2102 );
2103 assert_eq!(
2104 unsafe {
2105 &(*(::std::ptr::null::<dds_sample_info>())).publication_handle as *const _ as usize
2106 },
2107 32usize,
2108 concat!(
2109 "Offset of field: ",
2110 stringify!(dds_sample_info),
2111 "::",
2112 stringify!(publication_handle)
2113 )
2114 );
2115 assert_eq!(
2116 unsafe {
2117 &(*(::std::ptr::null::<dds_sample_info>())).disposed_generation_count as *const _
2118 as usize
2119 },
2120 40usize,
2121 concat!(
2122 "Offset of field: ",
2123 stringify!(dds_sample_info),
2124 "::",
2125 stringify!(disposed_generation_count)
2126 )
2127 );
2128 assert_eq!(
2129 unsafe {
2130 &(*(::std::ptr::null::<dds_sample_info>())).no_writers_generation_count as *const _
2131 as usize
2132 },
2133 44usize,
2134 concat!(
2135 "Offset of field: ",
2136 stringify!(dds_sample_info),
2137 "::",
2138 stringify!(no_writers_generation_count)
2139 )
2140 );
2141 assert_eq!(
2142 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).sample_rank as *const _ as usize },
2143 48usize,
2144 concat!(
2145 "Offset of field: ",
2146 stringify!(dds_sample_info),
2147 "::",
2148 stringify!(sample_rank)
2149 )
2150 );
2151 assert_eq!(
2152 unsafe { &(*(::std::ptr::null::<dds_sample_info>())).generation_rank as *const _ as usize },
2153 52usize,
2154 concat!(
2155 "Offset of field: ",
2156 stringify!(dds_sample_info),
2157 "::",
2158 stringify!(generation_rank)
2159 )
2160 );
2161 assert_eq!(
2162 unsafe {
2163 &(*(::std::ptr::null::<dds_sample_info>())).absolute_generation_rank as *const _
2164 as usize
2165 },
2166 56usize,
2167 concat!(
2168 "Offset of field: ",
2169 stringify!(dds_sample_info),
2170 "::",
2171 stringify!(absolute_generation_rank)
2172 )
2173 );
2174}
2175impl Default for dds_sample_info {
2176 fn default() -> Self {
2177 unsafe { ::std::mem::zeroed() }
2178 }
2179}
2180pub type dds_sample_info_t = dds_sample_info;
2181#[repr(C)]
2182#[derive(Debug, Default, Copy, Clone)]
2183pub struct dds_builtintopic_guid {
2184 pub v: [u8; 16usize],
2185}
2186#[test]
2187fn bindgen_test_layout_dds_builtintopic_guid() {
2188 assert_eq!(
2189 ::std::mem::size_of::<dds_builtintopic_guid>(),
2190 16usize,
2191 concat!("Size of: ", stringify!(dds_builtintopic_guid))
2192 );
2193 assert_eq!(
2194 ::std::mem::align_of::<dds_builtintopic_guid>(),
2195 1usize,
2196 concat!("Alignment of ", stringify!(dds_builtintopic_guid))
2197 );
2198 assert_eq!(
2199 unsafe { &(*(::std::ptr::null::<dds_builtintopic_guid>())).v as *const _ as usize },
2200 0usize,
2201 concat!(
2202 "Offset of field: ",
2203 stringify!(dds_builtintopic_guid),
2204 "::",
2205 stringify!(v)
2206 )
2207 );
2208}
2209pub type dds_guid_t = dds_builtintopic_guid;
2210#[repr(C)]
2211#[derive(Debug, Copy, Clone)]
2212pub struct dds_builtintopic_endpoint {
2213 pub key: dds_guid_t,
2214 pub participant_key: dds_guid_t,
2215 pub participant_instance_handle: dds_instance_handle_t,
2216 pub topic_name: *mut ::std::os::raw::c_char,
2217 pub type_name: *mut ::std::os::raw::c_char,
2218 pub qos: *mut dds_qos_t,
2219}
2220#[test]
2221fn bindgen_test_layout_dds_builtintopic_endpoint() {
2222 assert_eq!(
2223 ::std::mem::size_of::<dds_builtintopic_endpoint>(),
2224 64usize,
2225 concat!("Size of: ", stringify!(dds_builtintopic_endpoint))
2226 );
2227 assert_eq!(
2228 ::std::mem::align_of::<dds_builtintopic_endpoint>(),
2229 8usize,
2230 concat!("Alignment of ", stringify!(dds_builtintopic_endpoint))
2231 );
2232 assert_eq!(
2233 unsafe { &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).key as *const _ as usize },
2234 0usize,
2235 concat!(
2236 "Offset of field: ",
2237 stringify!(dds_builtintopic_endpoint),
2238 "::",
2239 stringify!(key)
2240 )
2241 );
2242 assert_eq!(
2243 unsafe {
2244 &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).participant_key as *const _
2245 as usize
2246 },
2247 16usize,
2248 concat!(
2249 "Offset of field: ",
2250 stringify!(dds_builtintopic_endpoint),
2251 "::",
2252 stringify!(participant_key)
2253 )
2254 );
2255 assert_eq!(
2256 unsafe {
2257 &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).participant_instance_handle
2258 as *const _ as usize
2259 },
2260 32usize,
2261 concat!(
2262 "Offset of field: ",
2263 stringify!(dds_builtintopic_endpoint),
2264 "::",
2265 stringify!(participant_instance_handle)
2266 )
2267 );
2268 assert_eq!(
2269 unsafe {
2270 &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).topic_name as *const _ as usize
2271 },
2272 40usize,
2273 concat!(
2274 "Offset of field: ",
2275 stringify!(dds_builtintopic_endpoint),
2276 "::",
2277 stringify!(topic_name)
2278 )
2279 );
2280 assert_eq!(
2281 unsafe {
2282 &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).type_name as *const _ as usize
2283 },
2284 48usize,
2285 concat!(
2286 "Offset of field: ",
2287 stringify!(dds_builtintopic_endpoint),
2288 "::",
2289 stringify!(type_name)
2290 )
2291 );
2292 assert_eq!(
2293 unsafe { &(*(::std::ptr::null::<dds_builtintopic_endpoint>())).qos as *const _ as usize },
2294 56usize,
2295 concat!(
2296 "Offset of field: ",
2297 stringify!(dds_builtintopic_endpoint),
2298 "::",
2299 stringify!(qos)
2300 )
2301 );
2302}
2303impl Default for dds_builtintopic_endpoint {
2304 fn default() -> Self {
2305 unsafe { ::std::mem::zeroed() }
2306 }
2307}
2308pub type dds_builtintopic_endpoint_t = dds_builtintopic_endpoint;
2309extern "C" {
2310 pub fn dds_enable(entity: dds_entity_t) -> dds_return_t;
2311}
2312extern "C" {
2313 pub fn dds_delete(entity: dds_entity_t) -> dds_return_t;
2314}
2315extern "C" {
2316 pub fn dds_get_publisher(writer: dds_entity_t) -> dds_entity_t;
2317}
2318extern "C" {
2319 pub fn dds_get_subscriber(entity: dds_entity_t) -> dds_entity_t;
2320}
2321extern "C" {
2322 pub fn dds_get_datareader(entity: dds_entity_t) -> dds_entity_t;
2323}
2324extern "C" {
2325 pub fn dds_get_mask(condition: dds_entity_t, mask: *mut u32) -> dds_return_t;
2326}
2327extern "C" {
2328 pub fn dds_get_instance_handle(
2329 entity: dds_entity_t,
2330 ihdl: *mut dds_instance_handle_t,
2331 ) -> dds_return_t;
2332}
2333extern "C" {
2334 pub fn dds_read_status(entity: dds_entity_t, status: *mut u32, mask: u32) -> dds_return_t;
2335}
2336extern "C" {
2337 pub fn dds_take_status(entity: dds_entity_t, status: *mut u32, mask: u32) -> dds_return_t;
2338}
2339extern "C" {
2340 pub fn dds_get_status_changes(entity: dds_entity_t, status: *mut u32) -> dds_return_t;
2341}
2342extern "C" {
2343 pub fn dds_get_status_mask(entity: dds_entity_t, mask: *mut u32) -> dds_return_t;
2344}
2345extern "C" {
2346 pub fn dds_get_enabled_status(entity: dds_entity_t, mask: *mut u32) -> dds_return_t;
2347}
2348extern "C" {
2349 pub fn dds_set_status_mask(entity: dds_entity_t, mask: u32) -> dds_return_t;
2350}
2351extern "C" {
2352 pub fn dds_set_enabled_status(entity: dds_entity_t, mask: u32) -> dds_return_t;
2353}
2354extern "C" {
2355 pub fn dds_get_qos(entity: dds_entity_t, qos: *mut dds_qos_t) -> dds_return_t;
2356}
2357extern "C" {
2358 pub fn dds_set_qos(entity: dds_entity_t, qos: *const dds_qos_t) -> dds_return_t;
2359}
2360extern "C" {
2361 pub fn dds_get_listener(entity: dds_entity_t, listener: *mut dds_listener_t) -> dds_return_t;
2362}
2363extern "C" {
2364 pub fn dds_set_listener(entity: dds_entity_t, listener: *const dds_listener_t) -> dds_return_t;
2365}
2366extern "C" {
2367 pub fn dds_create_participant(
2368 domain: dds_domainid_t,
2369 qos: *const dds_qos_t,
2370 listener: *const dds_listener_t,
2371 ) -> dds_entity_t;
2372}
2373extern "C" {
2374 pub fn dds_create_domain(
2375 domain: dds_domainid_t,
2376 config: *const ::std::os::raw::c_char,
2377 ) -> dds_entity_t;
2378}
2379extern "C" {
2380 pub fn dds_get_parent(entity: dds_entity_t) -> dds_entity_t;
2381}
2382extern "C" {
2383 pub fn dds_get_participant(entity: dds_entity_t) -> dds_entity_t;
2384}
2385extern "C" {
2386 pub fn dds_get_children(
2387 entity: dds_entity_t,
2388 children: *mut dds_entity_t,
2389 size: size_t,
2390 ) -> dds_return_t;
2391}
2392extern "C" {
2393 pub fn dds_get_domainid(entity: dds_entity_t, id: *mut dds_domainid_t) -> dds_return_t;
2394}
2395extern "C" {
2396 pub fn dds_lookup_participant(
2397 domain_id: dds_domainid_t,
2398 participants: *mut dds_entity_t,
2399 size: size_t,
2400 ) -> dds_return_t;
2401}
2402extern "C" {
2403 pub fn dds_create_topic(
2404 participant: dds_entity_t,
2405 descriptor: *const dds_topic_descriptor_t,
2406 name: *const ::std::os::raw::c_char,
2407 qos: *const dds_qos_t,
2408 listener: *const dds_listener_t,
2409 ) -> dds_entity_t;
2410}
2411extern "C" {
2412 pub fn dds_create_topic_sertype(
2413 participant: dds_entity_t,
2414 name: *const ::std::os::raw::c_char,
2415 sertype: *mut *mut ddsi_sertype,
2416 qos: *const dds_qos_t,
2417 listener: *const dds_listener_t,
2418 sedp_plist: *const ddsi_plist,
2419 ) -> dds_entity_t;
2420}
2421extern "C" {
2422 pub fn dds_create_topic_arbitrary(
2423 participant: dds_entity_t,
2424 sertopic: *mut ddsi_sertopic,
2425 qos: *const dds_qos_t,
2426 listener: *const dds_listener_t,
2427 sedp_plist: *const ddsi_plist,
2428 ) -> dds_entity_t;
2429}
2430extern "C" {
2431 pub fn dds_find_topic(
2432 scope: dds_find_scope_t,
2433 participant: dds_entity_t,
2434 name: *const ::std::os::raw::c_char,
2435 type_info: *const dds_typeinfo_t,
2436 timeout: dds_duration_t,
2437 ) -> dds_entity_t;
2438}
2439extern "C" {
2440 pub fn dds_get_name(
2441 topic: dds_entity_t,
2442 name: *mut ::std::os::raw::c_char,
2443 size: size_t,
2444 ) -> dds_return_t;
2445}
2446extern "C" {
2447 pub fn dds_get_type_name(
2448 topic: dds_entity_t,
2449 name: *mut ::std::os::raw::c_char,
2450 size: size_t,
2451 ) -> dds_return_t;
2452}
2453pub type dds_topic_filter_sample_fn =
2454 ::std::option::Option<unsafe extern "C" fn(sample: *const ::std::os::raw::c_void) -> bool>;
2455pub type dds_topic_filter_fn = dds_topic_filter_sample_fn;
2456extern "C" {
2457 pub fn dds_set_topic_filter(topic: dds_entity_t, filter: dds_topic_filter_fn);
2458}
2459extern "C" {
2460 pub fn dds_get_topic_filter(topic: dds_entity_t) -> dds_topic_filter_fn;
2461}
2462extern "C" {
2463 pub fn dds_create_subscriber(
2464 participant: dds_entity_t,
2465 qos: *const dds_qos_t,
2466 listener: *const dds_listener_t,
2467 ) -> dds_entity_t;
2468}
2469extern "C" {
2470 pub fn dds_create_publisher(
2471 participant: dds_entity_t,
2472 qos: *const dds_qos_t,
2473 listener: *const dds_listener_t,
2474 ) -> dds_entity_t;
2475}
2476extern "C" {
2477 pub fn dds_suspend(publisher: dds_entity_t) -> dds_return_t;
2478}
2479extern "C" {
2480 pub fn dds_resume(publisher: dds_entity_t) -> dds_return_t;
2481}
2482extern "C" {
2483 pub fn dds_wait_for_acks(
2484 publisher_or_writer: dds_entity_t,
2485 timeout: dds_duration_t,
2486 ) -> dds_return_t;
2487}
2488extern "C" {
2489 pub fn dds_create_reader(
2490 participant_or_subscriber: dds_entity_t,
2491 topic: dds_entity_t,
2492 qos: *const dds_qos_t,
2493 listener: *const dds_listener_t,
2494 ) -> dds_entity_t;
2495}
2496extern "C" {
2497 pub fn dds_create_reader_rhc(
2498 participant_or_subscriber: dds_entity_t,
2499 topic: dds_entity_t,
2500 qos: *const dds_qos_t,
2501 listener: *const dds_listener_t,
2502 rhc: *mut dds_rhc,
2503 ) -> dds_entity_t;
2504}
2505extern "C" {
2506 pub fn dds_reader_wait_for_historical_data(
2507 reader: dds_entity_t,
2508 max_wait: dds_duration_t,
2509 ) -> dds_return_t;
2510}
2511extern "C" {
2512 pub fn dds_create_writer(
2513 participant_or_publisher: dds_entity_t,
2514 topic: dds_entity_t,
2515 qos: *const dds_qos_t,
2516 listener: *const dds_listener_t,
2517 ) -> dds_entity_t;
2518}
2519extern "C" {
2520 pub fn dds_register_instance(
2521 writer: dds_entity_t,
2522 handle: *mut dds_instance_handle_t,
2523 data: *const ::std::os::raw::c_void,
2524 ) -> dds_return_t;
2525}
2526extern "C" {
2527 pub fn dds_unregister_instance(
2528 writer: dds_entity_t,
2529 data: *const ::std::os::raw::c_void,
2530 ) -> dds_return_t;
2531}
2532extern "C" {
2533 pub fn dds_unregister_instance_ih(
2534 writer: dds_entity_t,
2535 handle: dds_instance_handle_t,
2536 ) -> dds_return_t;
2537}
2538extern "C" {
2539 pub fn dds_unregister_instance_ts(
2540 writer: dds_entity_t,
2541 data: *const ::std::os::raw::c_void,
2542 timestamp: dds_time_t,
2543 ) -> dds_return_t;
2544}
2545extern "C" {
2546 pub fn dds_unregister_instance_ih_ts(
2547 writer: dds_entity_t,
2548 handle: dds_instance_handle_t,
2549 timestamp: dds_time_t,
2550 ) -> dds_return_t;
2551}
2552extern "C" {
2553 pub fn dds_writedispose(
2554 writer: dds_entity_t,
2555 data: *const ::std::os::raw::c_void,
2556 ) -> dds_return_t;
2557}
2558extern "C" {
2559 pub fn dds_writedispose_ts(
2560 writer: dds_entity_t,
2561 data: *const ::std::os::raw::c_void,
2562 timestamp: dds_time_t,
2563 ) -> dds_return_t;
2564}
2565extern "C" {
2566 pub fn dds_dispose(writer: dds_entity_t, data: *const ::std::os::raw::c_void) -> dds_return_t;
2567}
2568extern "C" {
2569 pub fn dds_dispose_ts(
2570 writer: dds_entity_t,
2571 data: *const ::std::os::raw::c_void,
2572 timestamp: dds_time_t,
2573 ) -> dds_return_t;
2574}
2575extern "C" {
2576 pub fn dds_dispose_ih(writer: dds_entity_t, handle: dds_instance_handle_t) -> dds_return_t;
2577}
2578extern "C" {
2579 pub fn dds_dispose_ih_ts(
2580 writer: dds_entity_t,
2581 handle: dds_instance_handle_t,
2582 timestamp: dds_time_t,
2583 ) -> dds_return_t;
2584}
2585extern "C" {
2586 pub fn dds_write(writer: dds_entity_t, data: *const ::std::os::raw::c_void) -> dds_return_t;
2587}
2588extern "C" {
2589 pub fn dds_write_flush(writer: dds_entity_t);
2590}
2591extern "C" {
2592 pub fn dds_writecdr(writer: dds_entity_t, serdata: *mut ddsi_serdata) -> dds_return_t;
2593}
2594extern "C" {
2595 pub fn dds_write_ts(
2596 writer: dds_entity_t,
2597 data: *const ::std::os::raw::c_void,
2598 timestamp: dds_time_t,
2599 ) -> dds_return_t;
2600}
2601extern "C" {
2602 pub fn dds_create_readcondition(reader: dds_entity_t, mask: u32) -> dds_entity_t;
2603}
2604pub type dds_querycondition_filter_fn =
2605 ::std::option::Option<unsafe extern "C" fn(sample: *const ::std::os::raw::c_void) -> bool>;
2606extern "C" {
2607 pub fn dds_create_querycondition(
2608 reader: dds_entity_t,
2609 mask: u32,
2610 filter: dds_querycondition_filter_fn,
2611 ) -> dds_entity_t;
2612}
2613extern "C" {
2614 pub fn dds_create_guardcondition(participant: dds_entity_t) -> dds_entity_t;
2615}
2616extern "C" {
2617 pub fn dds_set_guardcondition(guardcond: dds_entity_t, triggered: bool) -> dds_return_t;
2618}
2619extern "C" {
2620 pub fn dds_read_guardcondition(guardcond: dds_entity_t, triggered: *mut bool) -> dds_return_t;
2621}
2622extern "C" {
2623 pub fn dds_take_guardcondition(guardcond: dds_entity_t, triggered: *mut bool) -> dds_return_t;
2624}
2625pub type dds_attach_t = isize;
2626extern "C" {
2627 pub fn dds_create_waitset(participant: dds_entity_t) -> dds_entity_t;
2628}
2629extern "C" {
2630 pub fn dds_waitset_get_entities(
2631 waitset: dds_entity_t,
2632 entities: *mut dds_entity_t,
2633 size: size_t,
2634 ) -> dds_return_t;
2635}
2636extern "C" {
2637 pub fn dds_waitset_attach(
2638 waitset: dds_entity_t,
2639 entity: dds_entity_t,
2640 x: dds_attach_t,
2641 ) -> dds_return_t;
2642}
2643extern "C" {
2644 pub fn dds_waitset_detach(waitset: dds_entity_t, entity: dds_entity_t) -> dds_return_t;
2645}
2646extern "C" {
2647 pub fn dds_waitset_set_trigger(waitset: dds_entity_t, trigger: bool) -> dds_return_t;
2648}
2649extern "C" {
2650 pub fn dds_waitset_wait(
2651 waitset: dds_entity_t,
2652 xs: *mut dds_attach_t,
2653 nxs: size_t,
2654 reltimeout: dds_duration_t,
2655 ) -> dds_return_t;
2656}
2657extern "C" {
2658 pub fn dds_waitset_wait_until(
2659 waitset: dds_entity_t,
2660 xs: *mut dds_attach_t,
2661 nxs: size_t,
2662 abstimeout: dds_time_t,
2663 ) -> dds_return_t;
2664}
2665extern "C" {
2666 pub fn dds_read(
2667 reader_or_condition: dds_entity_t,
2668 buf: *mut *mut ::std::os::raw::c_void,
2669 si: *mut dds_sample_info_t,
2670 bufsz: size_t,
2671 maxs: u32,
2672 ) -> dds_return_t;
2673}
2674extern "C" {
2675 pub fn dds_read_wl(
2676 reader_or_condition: dds_entity_t,
2677 buf: *mut *mut ::std::os::raw::c_void,
2678 si: *mut dds_sample_info_t,
2679 maxs: u32,
2680 ) -> dds_return_t;
2681}
2682extern "C" {
2683 pub fn dds_read_mask(
2684 reader_or_condition: dds_entity_t,
2685 buf: *mut *mut ::std::os::raw::c_void,
2686 si: *mut dds_sample_info_t,
2687 bufsz: size_t,
2688 maxs: u32,
2689 mask: u32,
2690 ) -> dds_return_t;
2691}
2692extern "C" {
2693 pub fn dds_read_mask_wl(
2694 reader_or_condition: dds_entity_t,
2695 buf: *mut *mut ::std::os::raw::c_void,
2696 si: *mut dds_sample_info_t,
2697 maxs: u32,
2698 mask: u32,
2699 ) -> dds_return_t;
2700}
2701extern "C" {
2702 pub fn dds_read_instance(
2703 reader_or_condition: dds_entity_t,
2704 buf: *mut *mut ::std::os::raw::c_void,
2705 si: *mut dds_sample_info_t,
2706 bufsz: size_t,
2707 maxs: u32,
2708 handle: dds_instance_handle_t,
2709 ) -> dds_return_t;
2710}
2711extern "C" {
2712 pub fn dds_read_instance_wl(
2713 reader_or_condition: dds_entity_t,
2714 buf: *mut *mut ::std::os::raw::c_void,
2715 si: *mut dds_sample_info_t,
2716 maxs: u32,
2717 handle: dds_instance_handle_t,
2718 ) -> dds_return_t;
2719}
2720extern "C" {
2721 pub fn dds_read_instance_mask(
2722 reader_or_condition: dds_entity_t,
2723 buf: *mut *mut ::std::os::raw::c_void,
2724 si: *mut dds_sample_info_t,
2725 bufsz: size_t,
2726 maxs: u32,
2727 handle: dds_instance_handle_t,
2728 mask: u32,
2729 ) -> dds_return_t;
2730}
2731extern "C" {
2732 pub fn dds_read_instance_mask_wl(
2733 reader_or_condition: dds_entity_t,
2734 buf: *mut *mut ::std::os::raw::c_void,
2735 si: *mut dds_sample_info_t,
2736 maxs: u32,
2737 handle: dds_instance_handle_t,
2738 mask: u32,
2739 ) -> dds_return_t;
2740}
2741extern "C" {
2742 pub fn dds_take(
2743 reader_or_condition: dds_entity_t,
2744 buf: *mut *mut ::std::os::raw::c_void,
2745 si: *mut dds_sample_info_t,
2746 bufsz: size_t,
2747 maxs: u32,
2748 ) -> dds_return_t;
2749}
2750extern "C" {
2751 pub fn dds_take_wl(
2752 reader_or_condition: dds_entity_t,
2753 buf: *mut *mut ::std::os::raw::c_void,
2754 si: *mut dds_sample_info_t,
2755 maxs: u32,
2756 ) -> dds_return_t;
2757}
2758extern "C" {
2759 pub fn dds_take_mask(
2760 reader_or_condition: dds_entity_t,
2761 buf: *mut *mut ::std::os::raw::c_void,
2762 si: *mut dds_sample_info_t,
2763 bufsz: size_t,
2764 maxs: u32,
2765 mask: u32,
2766 ) -> dds_return_t;
2767}
2768extern "C" {
2769 pub fn dds_take_mask_wl(
2770 reader_or_condition: dds_entity_t,
2771 buf: *mut *mut ::std::os::raw::c_void,
2772 si: *mut dds_sample_info_t,
2773 maxs: u32,
2774 mask: u32,
2775 ) -> dds_return_t;
2776}
2777extern "C" {
2778 pub fn dds_take_instance(
2779 reader_or_condition: dds_entity_t,
2780 buf: *mut *mut ::std::os::raw::c_void,
2781 si: *mut dds_sample_info_t,
2782 bufsz: size_t,
2783 maxs: u32,
2784 handle: dds_instance_handle_t,
2785 ) -> dds_return_t;
2786}
2787extern "C" {
2788 pub fn dds_take_instance_wl(
2789 reader_or_condition: dds_entity_t,
2790 buf: *mut *mut ::std::os::raw::c_void,
2791 si: *mut dds_sample_info_t,
2792 maxs: u32,
2793 handle: dds_instance_handle_t,
2794 ) -> dds_return_t;
2795}
2796extern "C" {
2797 pub fn dds_take_instance_mask(
2798 reader_or_condition: dds_entity_t,
2799 buf: *mut *mut ::std::os::raw::c_void,
2800 si: *mut dds_sample_info_t,
2801 bufsz: size_t,
2802 maxs: u32,
2803 handle: dds_instance_handle_t,
2804 mask: u32,
2805 ) -> dds_return_t;
2806}
2807extern "C" {
2808 pub fn dds_take_instance_mask_wl(
2809 reader_or_condition: dds_entity_t,
2810 buf: *mut *mut ::std::os::raw::c_void,
2811 si: *mut dds_sample_info_t,
2812 maxs: u32,
2813 handle: dds_instance_handle_t,
2814 mask: u32,
2815 ) -> dds_return_t;
2816}
2817extern "C" {
2818 pub fn dds_take_next(
2819 reader: dds_entity_t,
2820 buf: *mut *mut ::std::os::raw::c_void,
2821 si: *mut dds_sample_info_t,
2822 ) -> dds_return_t;
2823}
2824extern "C" {
2825 pub fn dds_take_next_wl(
2826 reader: dds_entity_t,
2827 buf: *mut *mut ::std::os::raw::c_void,
2828 si: *mut dds_sample_info_t,
2829 ) -> dds_return_t;
2830}
2831extern "C" {
2832 pub fn dds_read_next(
2833 reader: dds_entity_t,
2834 buf: *mut *mut ::std::os::raw::c_void,
2835 si: *mut dds_sample_info_t,
2836 ) -> dds_return_t;
2837}
2838extern "C" {
2839 pub fn dds_read_next_wl(
2840 reader: dds_entity_t,
2841 buf: *mut *mut ::std::os::raw::c_void,
2842 si: *mut dds_sample_info_t,
2843 ) -> dds_return_t;
2844}
2845extern "C" {
2846 pub fn dds_return_loan(
2847 entity: dds_entity_t,
2848 buf: *mut *mut ::std::os::raw::c_void,
2849 bufsz: i32,
2850 ) -> dds_return_t;
2851}
2852extern "C" {
2853 pub fn dds_lookup_instance(
2854 entity: dds_entity_t,
2855 data: *const ::std::os::raw::c_void,
2856 ) -> dds_instance_handle_t;
2857}
2858extern "C" {
2859 pub fn dds_instance_get_key(
2860 entity: dds_entity_t,
2861 inst: dds_instance_handle_t,
2862 data: *mut ::std::os::raw::c_void,
2863 ) -> dds_return_t;
2864}
2865extern "C" {
2866 pub fn dds_begin_coherent(entity: dds_entity_t) -> dds_return_t;
2867}
2868extern "C" {
2869 pub fn dds_end_coherent(entity: dds_entity_t) -> dds_return_t;
2870}
2871extern "C" {
2872 pub fn dds_notify_readers(subscriber: dds_entity_t) -> dds_return_t;
2873}
2874extern "C" {
2875 pub fn dds_triggered(entity: dds_entity_t) -> dds_return_t;
2876}
2877extern "C" {
2878 pub fn dds_get_topic(entity: dds_entity_t) -> dds_entity_t;
2879}
2880extern "C" {
2881 pub fn dds_get_matched_subscriptions(
2882 writer: dds_entity_t,
2883 rds: *mut dds_instance_handle_t,
2884 nrds: size_t,
2885 ) -> dds_return_t;
2886}
2887extern "C" {
2888 pub fn dds_get_matched_subscription_data(
2889 writer: dds_entity_t,
2890 ih: dds_instance_handle_t,
2891 ) -> *mut dds_builtintopic_endpoint_t;
2892}
2893extern "C" {
2894 pub fn dds_get_matched_publications(
2895 reader: dds_entity_t,
2896 wrs: *mut dds_instance_handle_t,
2897 nwrs: size_t,
2898 ) -> dds_return_t;
2899}
2900extern "C" {
2901 pub fn dds_get_matched_publication_data(
2902 reader: dds_entity_t,
2903 ih: dds_instance_handle_t,
2904 ) -> *mut dds_builtintopic_endpoint_t;
2905}
2906extern "C" {
2907 pub fn dds_assert_liveliness(entity: dds_entity_t) -> dds_return_t;
2908}
2909#[repr(C)]
2910#[derive(Debug, Copy, Clone)]
2911pub struct iovec {
2912 pub iov_base: *mut ::std::os::raw::c_void,
2913 pub iov_len: size_t,
2914}
2915#[test]
2916fn bindgen_test_layout_iovec() {
2917 assert_eq!(
2918 ::std::mem::size_of::<iovec>(),
2919 16usize,
2920 concat!("Size of: ", stringify!(iovec))
2921 );
2922 assert_eq!(
2923 ::std::mem::align_of::<iovec>(),
2924 8usize,
2925 concat!("Alignment of ", stringify!(iovec))
2926 );
2927 assert_eq!(
2928 unsafe { &(*(::std::ptr::null::<iovec>())).iov_base as *const _ as usize },
2929 0usize,
2930 concat!(
2931 "Offset of field: ",
2932 stringify!(iovec),
2933 "::",
2934 stringify!(iov_base)
2935 )
2936 );
2937 assert_eq!(
2938 unsafe { &(*(::std::ptr::null::<iovec>())).iov_len as *const _ as usize },
2939 8usize,
2940 concat!(
2941 "Offset of field: ",
2942 stringify!(iovec),
2943 "::",
2944 stringify!(iov_len)
2945 )
2946 );
2947}
2948impl Default for iovec {
2949 fn default() -> Self {
2950 unsafe { ::std::mem::zeroed() }
2951 }
2952}
2953pub type ddsrt_iovec_t = iovec;
2954pub type ddsrt_msg_iovlen_t = size_t;
2955#[repr(C)]
2956#[derive(Debug, Default, Copy, Clone)]
2957pub struct ddsrt_atomic_uint32_t {
2958 pub v: u32,
2959}
2960#[test]
2961fn bindgen_test_layout_ddsrt_atomic_uint32_t() {
2962 assert_eq!(
2963 ::std::mem::size_of::<ddsrt_atomic_uint32_t>(),
2964 4usize,
2965 concat!("Size of: ", stringify!(ddsrt_atomic_uint32_t))
2966 );
2967 assert_eq!(
2968 ::std::mem::align_of::<ddsrt_atomic_uint32_t>(),
2969 4usize,
2970 concat!("Alignment of ", stringify!(ddsrt_atomic_uint32_t))
2971 );
2972 assert_eq!(
2973 unsafe { &(*(::std::ptr::null::<ddsrt_atomic_uint32_t>())).v as *const _ as usize },
2974 0usize,
2975 concat!(
2976 "Offset of field: ",
2977 stringify!(ddsrt_atomic_uint32_t),
2978 "::",
2979 stringify!(v)
2980 )
2981 );
2982}
2983#[repr(C)]
2984#[derive(Debug, Default, Copy, Clone)]
2985pub struct ddsrt_atomic_uintptr_t {
2986 pub v: usize,
2987}
2988#[test]
2989fn bindgen_test_layout_ddsrt_atomic_uintptr_t() {
2990 assert_eq!(
2991 ::std::mem::size_of::<ddsrt_atomic_uintptr_t>(),
2992 8usize,
2993 concat!("Size of: ", stringify!(ddsrt_atomic_uintptr_t))
2994 );
2995 assert_eq!(
2996 ::std::mem::align_of::<ddsrt_atomic_uintptr_t>(),
2997 8usize,
2998 concat!("Alignment of ", stringify!(ddsrt_atomic_uintptr_t))
2999 );
3000 assert_eq!(
3001 unsafe { &(*(::std::ptr::null::<ddsrt_atomic_uintptr_t>())).v as *const _ as usize },
3002 0usize,
3003 concat!(
3004 "Offset of field: ",
3005 stringify!(ddsrt_atomic_uintptr_t),
3006 "::",
3007 stringify!(v)
3008 )
3009 );
3010}
3011pub type ddsrt_atomic_voidp_t = ddsrt_atomic_uintptr_t;
3012#[repr(C)]
3013#[derive(Copy, Clone)]
3014pub union ddsi_guid_prefix {
3015 pub s: [::std::os::raw::c_uchar; 12usize],
3016 pub u: [u32; 3usize],
3017 _bindgen_union_align: [u32; 3usize],
3018}
3019#[test]
3020fn bindgen_test_layout_ddsi_guid_prefix() {
3021 assert_eq!(
3022 ::std::mem::size_of::<ddsi_guid_prefix>(),
3023 12usize,
3024 concat!("Size of: ", stringify!(ddsi_guid_prefix))
3025 );
3026 assert_eq!(
3027 ::std::mem::align_of::<ddsi_guid_prefix>(),
3028 4usize,
3029 concat!("Alignment of ", stringify!(ddsi_guid_prefix))
3030 );
3031 assert_eq!(
3032 unsafe { &(*(::std::ptr::null::<ddsi_guid_prefix>())).s as *const _ as usize },
3033 0usize,
3034 concat!(
3035 "Offset of field: ",
3036 stringify!(ddsi_guid_prefix),
3037 "::",
3038 stringify!(s)
3039 )
3040 );
3041 assert_eq!(
3042 unsafe { &(*(::std::ptr::null::<ddsi_guid_prefix>())).u as *const _ as usize },
3043 0usize,
3044 concat!(
3045 "Offset of field: ",
3046 stringify!(ddsi_guid_prefix),
3047 "::",
3048 stringify!(u)
3049 )
3050 );
3051}
3052impl Default for ddsi_guid_prefix {
3053 fn default() -> Self {
3054 unsafe { ::std::mem::zeroed() }
3055 }
3056}
3057pub type ddsi_guid_prefix_t = ddsi_guid_prefix;
3058#[repr(C)]
3059#[derive(Copy, Clone)]
3060pub union ddsi_entityid {
3061 pub u: u32,
3062 _bindgen_union_align: u32,
3063}
3064#[test]
3065fn bindgen_test_layout_ddsi_entityid() {
3066 assert_eq!(
3067 ::std::mem::size_of::<ddsi_entityid>(),
3068 4usize,
3069 concat!("Size of: ", stringify!(ddsi_entityid))
3070 );
3071 assert_eq!(
3072 ::std::mem::align_of::<ddsi_entityid>(),
3073 4usize,
3074 concat!("Alignment of ", stringify!(ddsi_entityid))
3075 );
3076 assert_eq!(
3077 unsafe { &(*(::std::ptr::null::<ddsi_entityid>())).u as *const _ as usize },
3078 0usize,
3079 concat!(
3080 "Offset of field: ",
3081 stringify!(ddsi_entityid),
3082 "::",
3083 stringify!(u)
3084 )
3085 );
3086}
3087impl Default for ddsi_entityid {
3088 fn default() -> Self {
3089 unsafe { ::std::mem::zeroed() }
3090 }
3091}
3092pub type ddsi_entityid_t = ddsi_entityid;
3093#[repr(C)]
3094#[derive(Copy, Clone)]
3095pub struct ddsi_guid {
3096 pub prefix: ddsi_guid_prefix_t,
3097 pub entityid: ddsi_entityid_t,
3098}
3099#[test]
3100fn bindgen_test_layout_ddsi_guid() {
3101 assert_eq!(
3102 ::std::mem::size_of::<ddsi_guid>(),
3103 16usize,
3104 concat!("Size of: ", stringify!(ddsi_guid))
3105 );
3106 assert_eq!(
3107 ::std::mem::align_of::<ddsi_guid>(),
3108 4usize,
3109 concat!("Alignment of ", stringify!(ddsi_guid))
3110 );
3111 assert_eq!(
3112 unsafe { &(*(::std::ptr::null::<ddsi_guid>())).prefix as *const _ as usize },
3113 0usize,
3114 concat!(
3115 "Offset of field: ",
3116 stringify!(ddsi_guid),
3117 "::",
3118 stringify!(prefix)
3119 )
3120 );
3121 assert_eq!(
3122 unsafe { &(*(::std::ptr::null::<ddsi_guid>())).entityid as *const _ as usize },
3123 12usize,
3124 concat!(
3125 "Offset of field: ",
3126 stringify!(ddsi_guid),
3127 "::",
3128 stringify!(entityid)
3129 )
3130 );
3131}
3132impl Default for ddsi_guid {
3133 fn default() -> Self {
3134 unsafe { ::std::mem::zeroed() }
3135 }
3136}
3137#[repr(C)]
3138#[derive(Debug, Copy, Clone)]
3139pub struct ddsi_octetseq {
3140 pub length: u32,
3141 pub value: *mut ::std::os::raw::c_uchar,
3142}
3143#[test]
3144fn bindgen_test_layout_ddsi_octetseq() {
3145 assert_eq!(
3146 ::std::mem::size_of::<ddsi_octetseq>(),
3147 16usize,
3148 concat!("Size of: ", stringify!(ddsi_octetseq))
3149 );
3150 assert_eq!(
3151 ::std::mem::align_of::<ddsi_octetseq>(),
3152 8usize,
3153 concat!("Alignment of ", stringify!(ddsi_octetseq))
3154 );
3155 assert_eq!(
3156 unsafe { &(*(::std::ptr::null::<ddsi_octetseq>())).length as *const _ as usize },
3157 0usize,
3158 concat!(
3159 "Offset of field: ",
3160 stringify!(ddsi_octetseq),
3161 "::",
3162 stringify!(length)
3163 )
3164 );
3165 assert_eq!(
3166 unsafe { &(*(::std::ptr::null::<ddsi_octetseq>())).value as *const _ as usize },
3167 8usize,
3168 concat!(
3169 "Offset of field: ",
3170 stringify!(ddsi_octetseq),
3171 "::",
3172 stringify!(value)
3173 )
3174 );
3175}
3176impl Default for ddsi_octetseq {
3177 fn default() -> Self {
3178 unsafe { ::std::mem::zeroed() }
3179 }
3180}
3181pub type ddsi_octetseq_t = ddsi_octetseq;
3182pub type dds_userdata_qospolicy_t = ddsi_octetseq_t;
3183pub type dds_topicdata_qospolicy_t = ddsi_octetseq_t;
3184pub type dds_groupdata_qospolicy_t = ddsi_octetseq_t;
3185#[repr(C)]
3186#[derive(Debug, Copy, Clone)]
3187pub struct dds_property {
3188 pub propagate: ::std::os::raw::c_uchar,
3189 pub name: *mut ::std::os::raw::c_char,
3190 pub value: *mut ::std::os::raw::c_char,
3191}
3192#[test]
3193fn bindgen_test_layout_dds_property() {
3194 assert_eq!(
3195 ::std::mem::size_of::<dds_property>(),
3196 24usize,
3197 concat!("Size of: ", stringify!(dds_property))
3198 );
3199 assert_eq!(
3200 ::std::mem::align_of::<dds_property>(),
3201 8usize,
3202 concat!("Alignment of ", stringify!(dds_property))
3203 );
3204 assert_eq!(
3205 unsafe { &(*(::std::ptr::null::<dds_property>())).propagate as *const _ as usize },
3206 0usize,
3207 concat!(
3208 "Offset of field: ",
3209 stringify!(dds_property),
3210 "::",
3211 stringify!(propagate)
3212 )
3213 );
3214 assert_eq!(
3215 unsafe { &(*(::std::ptr::null::<dds_property>())).name as *const _ as usize },
3216 8usize,
3217 concat!(
3218 "Offset of field: ",
3219 stringify!(dds_property),
3220 "::",
3221 stringify!(name)
3222 )
3223 );
3224 assert_eq!(
3225 unsafe { &(*(::std::ptr::null::<dds_property>())).value as *const _ as usize },
3226 16usize,
3227 concat!(
3228 "Offset of field: ",
3229 stringify!(dds_property),
3230 "::",
3231 stringify!(value)
3232 )
3233 );
3234}
3235impl Default for dds_property {
3236 fn default() -> Self {
3237 unsafe { ::std::mem::zeroed() }
3238 }
3239}
3240pub type dds_property_t = dds_property;
3241#[repr(C)]
3242#[derive(Debug, Copy, Clone)]
3243pub struct dds_propertyseq {
3244 pub n: u32,
3245 pub props: *mut dds_property_t,
3246}
3247#[test]
3248fn bindgen_test_layout_dds_propertyseq() {
3249 assert_eq!(
3250 ::std::mem::size_of::<dds_propertyseq>(),
3251 16usize,
3252 concat!("Size of: ", stringify!(dds_propertyseq))
3253 );
3254 assert_eq!(
3255 ::std::mem::align_of::<dds_propertyseq>(),
3256 8usize,
3257 concat!("Alignment of ", stringify!(dds_propertyseq))
3258 );
3259 assert_eq!(
3260 unsafe { &(*(::std::ptr::null::<dds_propertyseq>())).n as *const _ as usize },
3261 0usize,
3262 concat!(
3263 "Offset of field: ",
3264 stringify!(dds_propertyseq),
3265 "::",
3266 stringify!(n)
3267 )
3268 );
3269 assert_eq!(
3270 unsafe { &(*(::std::ptr::null::<dds_propertyseq>())).props as *const _ as usize },
3271 8usize,
3272 concat!(
3273 "Offset of field: ",
3274 stringify!(dds_propertyseq),
3275 "::",
3276 stringify!(props)
3277 )
3278 );
3279}
3280impl Default for dds_propertyseq {
3281 fn default() -> Self {
3282 unsafe { ::std::mem::zeroed() }
3283 }
3284}
3285pub type dds_propertyseq_t = dds_propertyseq;
3286#[repr(C)]
3287#[derive(Debug, Copy, Clone)]
3288pub struct dds_binaryproperty {
3289 pub propagate: ::std::os::raw::c_uchar,
3290 pub name: *mut ::std::os::raw::c_char,
3291 pub value: ddsi_octetseq_t,
3292}
3293#[test]
3294fn bindgen_test_layout_dds_binaryproperty() {
3295 assert_eq!(
3296 ::std::mem::size_of::<dds_binaryproperty>(),
3297 32usize,
3298 concat!("Size of: ", stringify!(dds_binaryproperty))
3299 );
3300 assert_eq!(
3301 ::std::mem::align_of::<dds_binaryproperty>(),
3302 8usize,
3303 concat!("Alignment of ", stringify!(dds_binaryproperty))
3304 );
3305 assert_eq!(
3306 unsafe { &(*(::std::ptr::null::<dds_binaryproperty>())).propagate as *const _ as usize },
3307 0usize,
3308 concat!(
3309 "Offset of field: ",
3310 stringify!(dds_binaryproperty),
3311 "::",
3312 stringify!(propagate)
3313 )
3314 );
3315 assert_eq!(
3316 unsafe { &(*(::std::ptr::null::<dds_binaryproperty>())).name as *const _ as usize },
3317 8usize,
3318 concat!(
3319 "Offset of field: ",
3320 stringify!(dds_binaryproperty),
3321 "::",
3322 stringify!(name)
3323 )
3324 );
3325 assert_eq!(
3326 unsafe { &(*(::std::ptr::null::<dds_binaryproperty>())).value as *const _ as usize },
3327 16usize,
3328 concat!(
3329 "Offset of field: ",
3330 stringify!(dds_binaryproperty),
3331 "::",
3332 stringify!(value)
3333 )
3334 );
3335}
3336impl Default for dds_binaryproperty {
3337 fn default() -> Self {
3338 unsafe { ::std::mem::zeroed() }
3339 }
3340}
3341pub type dds_binaryproperty_t = dds_binaryproperty;
3342#[repr(C)]
3343#[derive(Debug, Copy, Clone)]
3344pub struct dds_binarypropertyseq {
3345 pub n: u32,
3346 pub props: *mut dds_binaryproperty_t,
3347}
3348#[test]
3349fn bindgen_test_layout_dds_binarypropertyseq() {
3350 assert_eq!(
3351 ::std::mem::size_of::<dds_binarypropertyseq>(),
3352 16usize,
3353 concat!("Size of: ", stringify!(dds_binarypropertyseq))
3354 );
3355 assert_eq!(
3356 ::std::mem::align_of::<dds_binarypropertyseq>(),
3357 8usize,
3358 concat!("Alignment of ", stringify!(dds_binarypropertyseq))
3359 );
3360 assert_eq!(
3361 unsafe { &(*(::std::ptr::null::<dds_binarypropertyseq>())).n as *const _ as usize },
3362 0usize,
3363 concat!(
3364 "Offset of field: ",
3365 stringify!(dds_binarypropertyseq),
3366 "::",
3367 stringify!(n)
3368 )
3369 );
3370 assert_eq!(
3371 unsafe { &(*(::std::ptr::null::<dds_binarypropertyseq>())).props as *const _ as usize },
3372 8usize,
3373 concat!(
3374 "Offset of field: ",
3375 stringify!(dds_binarypropertyseq),
3376 "::",
3377 stringify!(props)
3378 )
3379 );
3380}
3381impl Default for dds_binarypropertyseq {
3382 fn default() -> Self {
3383 unsafe { ::std::mem::zeroed() }
3384 }
3385}
3386pub type dds_binarypropertyseq_t = dds_binarypropertyseq;
3387#[repr(C)]
3388#[derive(Debug, Copy, Clone)]
3389pub struct dds_property_qospolicy {
3390 pub value: dds_propertyseq_t,
3391 pub binary_value: dds_binarypropertyseq_t,
3392}
3393#[test]
3394fn bindgen_test_layout_dds_property_qospolicy() {
3395 assert_eq!(
3396 ::std::mem::size_of::<dds_property_qospolicy>(),
3397 32usize,
3398 concat!("Size of: ", stringify!(dds_property_qospolicy))
3399 );
3400 assert_eq!(
3401 ::std::mem::align_of::<dds_property_qospolicy>(),
3402 8usize,
3403 concat!("Alignment of ", stringify!(dds_property_qospolicy))
3404 );
3405 assert_eq!(
3406 unsafe { &(*(::std::ptr::null::<dds_property_qospolicy>())).value as *const _ as usize },
3407 0usize,
3408 concat!(
3409 "Offset of field: ",
3410 stringify!(dds_property_qospolicy),
3411 "::",
3412 stringify!(value)
3413 )
3414 );
3415 assert_eq!(
3416 unsafe {
3417 &(*(::std::ptr::null::<dds_property_qospolicy>())).binary_value as *const _ as usize
3418 },
3419 16usize,
3420 concat!(
3421 "Offset of field: ",
3422 stringify!(dds_property_qospolicy),
3423 "::",
3424 stringify!(binary_value)
3425 )
3426 );
3427}
3428impl Default for dds_property_qospolicy {
3429 fn default() -> Self {
3430 unsafe { ::std::mem::zeroed() }
3431 }
3432}
3433pub type dds_property_qospolicy_t = dds_property_qospolicy;
3434#[repr(C)]
3435#[derive(Debug, Copy, Clone)]
3436pub struct dds_durability_qospolicy {
3437 pub kind: dds_durability_kind_t,
3438}
3439#[test]
3440fn bindgen_test_layout_dds_durability_qospolicy() {
3441 assert_eq!(
3442 ::std::mem::size_of::<dds_durability_qospolicy>(),
3443 4usize,
3444 concat!("Size of: ", stringify!(dds_durability_qospolicy))
3445 );
3446 assert_eq!(
3447 ::std::mem::align_of::<dds_durability_qospolicy>(),
3448 4usize,
3449 concat!("Alignment of ", stringify!(dds_durability_qospolicy))
3450 );
3451 assert_eq!(
3452 unsafe { &(*(::std::ptr::null::<dds_durability_qospolicy>())).kind as *const _ as usize },
3453 0usize,
3454 concat!(
3455 "Offset of field: ",
3456 stringify!(dds_durability_qospolicy),
3457 "::",
3458 stringify!(kind)
3459 )
3460 );
3461}
3462impl Default for dds_durability_qospolicy {
3463 fn default() -> Self {
3464 unsafe { ::std::mem::zeroed() }
3465 }
3466}
3467pub type dds_durability_qospolicy_t = dds_durability_qospolicy;
3468#[repr(C)]
3469#[derive(Debug, Copy, Clone)]
3470pub struct dds_history_qospolicy {
3471 pub kind: dds_history_kind_t,
3472 pub depth: i32,
3473}
3474#[test]
3475fn bindgen_test_layout_dds_history_qospolicy() {
3476 assert_eq!(
3477 ::std::mem::size_of::<dds_history_qospolicy>(),
3478 8usize,
3479 concat!("Size of: ", stringify!(dds_history_qospolicy))
3480 );
3481 assert_eq!(
3482 ::std::mem::align_of::<dds_history_qospolicy>(),
3483 4usize,
3484 concat!("Alignment of ", stringify!(dds_history_qospolicy))
3485 );
3486 assert_eq!(
3487 unsafe { &(*(::std::ptr::null::<dds_history_qospolicy>())).kind as *const _ as usize },
3488 0usize,
3489 concat!(
3490 "Offset of field: ",
3491 stringify!(dds_history_qospolicy),
3492 "::",
3493 stringify!(kind)
3494 )
3495 );
3496 assert_eq!(
3497 unsafe { &(*(::std::ptr::null::<dds_history_qospolicy>())).depth as *const _ as usize },
3498 4usize,
3499 concat!(
3500 "Offset of field: ",
3501 stringify!(dds_history_qospolicy),
3502 "::",
3503 stringify!(depth)
3504 )
3505 );
3506}
3507impl Default for dds_history_qospolicy {
3508 fn default() -> Self {
3509 unsafe { ::std::mem::zeroed() }
3510 }
3511}
3512pub type dds_history_qospolicy_t = dds_history_qospolicy;
3513#[repr(C)]
3514#[derive(Debug, Default, Copy, Clone)]
3515pub struct dds_resource_limits_qospolicy {
3516 pub max_samples: i32,
3517 pub max_instances: i32,
3518 pub max_samples_per_instance: i32,
3519}
3520#[test]
3521fn bindgen_test_layout_dds_resource_limits_qospolicy() {
3522 assert_eq!(
3523 ::std::mem::size_of::<dds_resource_limits_qospolicy>(),
3524 12usize,
3525 concat!("Size of: ", stringify!(dds_resource_limits_qospolicy))
3526 );
3527 assert_eq!(
3528 ::std::mem::align_of::<dds_resource_limits_qospolicy>(),
3529 4usize,
3530 concat!("Alignment of ", stringify!(dds_resource_limits_qospolicy))
3531 );
3532 assert_eq!(
3533 unsafe {
3534 &(*(::std::ptr::null::<dds_resource_limits_qospolicy>())).max_samples as *const _
3535 as usize
3536 },
3537 0usize,
3538 concat!(
3539 "Offset of field: ",
3540 stringify!(dds_resource_limits_qospolicy),
3541 "::",
3542 stringify!(max_samples)
3543 )
3544 );
3545 assert_eq!(
3546 unsafe {
3547 &(*(::std::ptr::null::<dds_resource_limits_qospolicy>())).max_instances as *const _
3548 as usize
3549 },
3550 4usize,
3551 concat!(
3552 "Offset of field: ",
3553 stringify!(dds_resource_limits_qospolicy),
3554 "::",
3555 stringify!(max_instances)
3556 )
3557 );
3558 assert_eq!(
3559 unsafe {
3560 &(*(::std::ptr::null::<dds_resource_limits_qospolicy>())).max_samples_per_instance
3561 as *const _ as usize
3562 },
3563 8usize,
3564 concat!(
3565 "Offset of field: ",
3566 stringify!(dds_resource_limits_qospolicy),
3567 "::",
3568 stringify!(max_samples_per_instance)
3569 )
3570 );
3571}
3572pub type dds_resource_limits_qospolicy_t = dds_resource_limits_qospolicy;
3573#[repr(C)]
3574#[derive(Debug, Copy, Clone)]
3575pub struct dds_durability_service_qospolicy {
3576 pub service_cleanup_delay: dds_duration_t,
3577 pub history: dds_history_qospolicy_t,
3578 pub resource_limits: dds_resource_limits_qospolicy_t,
3579}
3580#[test]
3581fn bindgen_test_layout_dds_durability_service_qospolicy() {
3582 assert_eq!(
3583 ::std::mem::size_of::<dds_durability_service_qospolicy>(),
3584 32usize,
3585 concat!("Size of: ", stringify!(dds_durability_service_qospolicy))
3586 );
3587 assert_eq!(
3588 ::std::mem::align_of::<dds_durability_service_qospolicy>(),
3589 8usize,
3590 concat!(
3591 "Alignment of ",
3592 stringify!(dds_durability_service_qospolicy)
3593 )
3594 );
3595 assert_eq!(
3596 unsafe {
3597 &(*(::std::ptr::null::<dds_durability_service_qospolicy>())).service_cleanup_delay
3598 as *const _ as usize
3599 },
3600 0usize,
3601 concat!(
3602 "Offset of field: ",
3603 stringify!(dds_durability_service_qospolicy),
3604 "::",
3605 stringify!(service_cleanup_delay)
3606 )
3607 );
3608 assert_eq!(
3609 unsafe {
3610 &(*(::std::ptr::null::<dds_durability_service_qospolicy>())).history as *const _
3611 as usize
3612 },
3613 8usize,
3614 concat!(
3615 "Offset of field: ",
3616 stringify!(dds_durability_service_qospolicy),
3617 "::",
3618 stringify!(history)
3619 )
3620 );
3621 assert_eq!(
3622 unsafe {
3623 &(*(::std::ptr::null::<dds_durability_service_qospolicy>())).resource_limits as *const _
3624 as usize
3625 },
3626 16usize,
3627 concat!(
3628 "Offset of field: ",
3629 stringify!(dds_durability_service_qospolicy),
3630 "::",
3631 stringify!(resource_limits)
3632 )
3633 );
3634}
3635impl Default for dds_durability_service_qospolicy {
3636 fn default() -> Self {
3637 unsafe { ::std::mem::zeroed() }
3638 }
3639}
3640pub type dds_durability_service_qospolicy_t = dds_durability_service_qospolicy;
3641#[repr(C)]
3642#[derive(Debug, Copy, Clone)]
3643pub struct dds_presentation_qospolicy {
3644 pub access_scope: dds_presentation_access_scope_kind_t,
3645 pub coherent_access: ::std::os::raw::c_uchar,
3646 pub ordered_access: ::std::os::raw::c_uchar,
3647}
3648#[test]
3649fn bindgen_test_layout_dds_presentation_qospolicy() {
3650 assert_eq!(
3651 ::std::mem::size_of::<dds_presentation_qospolicy>(),
3652 8usize,
3653 concat!("Size of: ", stringify!(dds_presentation_qospolicy))
3654 );
3655 assert_eq!(
3656 ::std::mem::align_of::<dds_presentation_qospolicy>(),
3657 4usize,
3658 concat!("Alignment of ", stringify!(dds_presentation_qospolicy))
3659 );
3660 assert_eq!(
3661 unsafe {
3662 &(*(::std::ptr::null::<dds_presentation_qospolicy>())).access_scope as *const _ as usize
3663 },
3664 0usize,
3665 concat!(
3666 "Offset of field: ",
3667 stringify!(dds_presentation_qospolicy),
3668 "::",
3669 stringify!(access_scope)
3670 )
3671 );
3672 assert_eq!(
3673 unsafe {
3674 &(*(::std::ptr::null::<dds_presentation_qospolicy>())).coherent_access as *const _
3675 as usize
3676 },
3677 4usize,
3678 concat!(
3679 "Offset of field: ",
3680 stringify!(dds_presentation_qospolicy),
3681 "::",
3682 stringify!(coherent_access)
3683 )
3684 );
3685 assert_eq!(
3686 unsafe {
3687 &(*(::std::ptr::null::<dds_presentation_qospolicy>())).ordered_access as *const _
3688 as usize
3689 },
3690 5usize,
3691 concat!(
3692 "Offset of field: ",
3693 stringify!(dds_presentation_qospolicy),
3694 "::",
3695 stringify!(ordered_access)
3696 )
3697 );
3698}
3699impl Default for dds_presentation_qospolicy {
3700 fn default() -> Self {
3701 unsafe { ::std::mem::zeroed() }
3702 }
3703}
3704pub type dds_presentation_qospolicy_t = dds_presentation_qospolicy;
3705#[repr(C)]
3706#[derive(Debug, Default, Copy, Clone)]
3707pub struct dds_deadline_qospolicy {
3708 pub deadline: dds_duration_t,
3709}
3710#[test]
3711fn bindgen_test_layout_dds_deadline_qospolicy() {
3712 assert_eq!(
3713 ::std::mem::size_of::<dds_deadline_qospolicy>(),
3714 8usize,
3715 concat!("Size of: ", stringify!(dds_deadline_qospolicy))
3716 );
3717 assert_eq!(
3718 ::std::mem::align_of::<dds_deadline_qospolicy>(),
3719 8usize,
3720 concat!("Alignment of ", stringify!(dds_deadline_qospolicy))
3721 );
3722 assert_eq!(
3723 unsafe { &(*(::std::ptr::null::<dds_deadline_qospolicy>())).deadline as *const _ as usize },
3724 0usize,
3725 concat!(
3726 "Offset of field: ",
3727 stringify!(dds_deadline_qospolicy),
3728 "::",
3729 stringify!(deadline)
3730 )
3731 );
3732}
3733pub type dds_deadline_qospolicy_t = dds_deadline_qospolicy;
3734#[repr(C)]
3735#[derive(Debug, Default, Copy, Clone)]
3736pub struct dds_latency_budget_qospolicy {
3737 pub duration: dds_duration_t,
3738}
3739#[test]
3740fn bindgen_test_layout_dds_latency_budget_qospolicy() {
3741 assert_eq!(
3742 ::std::mem::size_of::<dds_latency_budget_qospolicy>(),
3743 8usize,
3744 concat!("Size of: ", stringify!(dds_latency_budget_qospolicy))
3745 );
3746 assert_eq!(
3747 ::std::mem::align_of::<dds_latency_budget_qospolicy>(),
3748 8usize,
3749 concat!("Alignment of ", stringify!(dds_latency_budget_qospolicy))
3750 );
3751 assert_eq!(
3752 unsafe {
3753 &(*(::std::ptr::null::<dds_latency_budget_qospolicy>())).duration as *const _ as usize
3754 },
3755 0usize,
3756 concat!(
3757 "Offset of field: ",
3758 stringify!(dds_latency_budget_qospolicy),
3759 "::",
3760 stringify!(duration)
3761 )
3762 );
3763}
3764pub type dds_latency_budget_qospolicy_t = dds_latency_budget_qospolicy;
3765#[repr(C)]
3766#[derive(Debug, Copy, Clone)]
3767pub struct dds_ownership_qospolicy {
3768 pub kind: dds_ownership_kind_t,
3769}
3770#[test]
3771fn bindgen_test_layout_dds_ownership_qospolicy() {
3772 assert_eq!(
3773 ::std::mem::size_of::<dds_ownership_qospolicy>(),
3774 4usize,
3775 concat!("Size of: ", stringify!(dds_ownership_qospolicy))
3776 );
3777 assert_eq!(
3778 ::std::mem::align_of::<dds_ownership_qospolicy>(),
3779 4usize,
3780 concat!("Alignment of ", stringify!(dds_ownership_qospolicy))
3781 );
3782 assert_eq!(
3783 unsafe { &(*(::std::ptr::null::<dds_ownership_qospolicy>())).kind as *const _ as usize },
3784 0usize,
3785 concat!(
3786 "Offset of field: ",
3787 stringify!(dds_ownership_qospolicy),
3788 "::",
3789 stringify!(kind)
3790 )
3791 );
3792}
3793impl Default for dds_ownership_qospolicy {
3794 fn default() -> Self {
3795 unsafe { ::std::mem::zeroed() }
3796 }
3797}
3798pub type dds_ownership_qospolicy_t = dds_ownership_qospolicy;
3799#[repr(C)]
3800#[derive(Debug, Default, Copy, Clone)]
3801pub struct dds_ownership_strength_qospolicy {
3802 pub value: i32,
3803}
3804#[test]
3805fn bindgen_test_layout_dds_ownership_strength_qospolicy() {
3806 assert_eq!(
3807 ::std::mem::size_of::<dds_ownership_strength_qospolicy>(),
3808 4usize,
3809 concat!("Size of: ", stringify!(dds_ownership_strength_qospolicy))
3810 );
3811 assert_eq!(
3812 ::std::mem::align_of::<dds_ownership_strength_qospolicy>(),
3813 4usize,
3814 concat!(
3815 "Alignment of ",
3816 stringify!(dds_ownership_strength_qospolicy)
3817 )
3818 );
3819 assert_eq!(
3820 unsafe {
3821 &(*(::std::ptr::null::<dds_ownership_strength_qospolicy>())).value as *const _ as usize
3822 },
3823 0usize,
3824 concat!(
3825 "Offset of field: ",
3826 stringify!(dds_ownership_strength_qospolicy),
3827 "::",
3828 stringify!(value)
3829 )
3830 );
3831}
3832pub type dds_ownership_strength_qospolicy_t = dds_ownership_strength_qospolicy;
3833#[repr(C)]
3834#[derive(Debug, Copy, Clone)]
3835pub struct dds_liveliness_qospolicy {
3836 pub kind: dds_liveliness_kind_t,
3837 pub lease_duration: dds_duration_t,
3838}
3839#[test]
3840fn bindgen_test_layout_dds_liveliness_qospolicy() {
3841 assert_eq!(
3842 ::std::mem::size_of::<dds_liveliness_qospolicy>(),
3843 16usize,
3844 concat!("Size of: ", stringify!(dds_liveliness_qospolicy))
3845 );
3846 assert_eq!(
3847 ::std::mem::align_of::<dds_liveliness_qospolicy>(),
3848 8usize,
3849 concat!("Alignment of ", stringify!(dds_liveliness_qospolicy))
3850 );
3851 assert_eq!(
3852 unsafe { &(*(::std::ptr::null::<dds_liveliness_qospolicy>())).kind as *const _ as usize },
3853 0usize,
3854 concat!(
3855 "Offset of field: ",
3856 stringify!(dds_liveliness_qospolicy),
3857 "::",
3858 stringify!(kind)
3859 )
3860 );
3861 assert_eq!(
3862 unsafe {
3863 &(*(::std::ptr::null::<dds_liveliness_qospolicy>())).lease_duration as *const _ as usize
3864 },
3865 8usize,
3866 concat!(
3867 "Offset of field: ",
3868 stringify!(dds_liveliness_qospolicy),
3869 "::",
3870 stringify!(lease_duration)
3871 )
3872 );
3873}
3874impl Default for dds_liveliness_qospolicy {
3875 fn default() -> Self {
3876 unsafe { ::std::mem::zeroed() }
3877 }
3878}
3879pub type dds_liveliness_qospolicy_t = dds_liveliness_qospolicy;
3880#[repr(C)]
3881#[derive(Debug, Default, Copy, Clone)]
3882pub struct dds_time_based_filter_qospolicy {
3883 pub minimum_separation: dds_duration_t,
3884}
3885#[test]
3886fn bindgen_test_layout_dds_time_based_filter_qospolicy() {
3887 assert_eq!(
3888 ::std::mem::size_of::<dds_time_based_filter_qospolicy>(),
3889 8usize,
3890 concat!("Size of: ", stringify!(dds_time_based_filter_qospolicy))
3891 );
3892 assert_eq!(
3893 ::std::mem::align_of::<dds_time_based_filter_qospolicy>(),
3894 8usize,
3895 concat!("Alignment of ", stringify!(dds_time_based_filter_qospolicy))
3896 );
3897 assert_eq!(
3898 unsafe {
3899 &(*(::std::ptr::null::<dds_time_based_filter_qospolicy>())).minimum_separation
3900 as *const _ as usize
3901 },
3902 0usize,
3903 concat!(
3904 "Offset of field: ",
3905 stringify!(dds_time_based_filter_qospolicy),
3906 "::",
3907 stringify!(minimum_separation)
3908 )
3909 );
3910}
3911pub type dds_time_based_filter_qospolicy_t = dds_time_based_filter_qospolicy;
3912#[repr(C)]
3913#[derive(Debug, Copy, Clone)]
3914pub struct ddsi_stringseq {
3915 pub n: u32,
3916 pub strs: *mut *mut ::std::os::raw::c_char,
3917}
3918#[test]
3919fn bindgen_test_layout_ddsi_stringseq() {
3920 assert_eq!(
3921 ::std::mem::size_of::<ddsi_stringseq>(),
3922 16usize,
3923 concat!("Size of: ", stringify!(ddsi_stringseq))
3924 );
3925 assert_eq!(
3926 ::std::mem::align_of::<ddsi_stringseq>(),
3927 8usize,
3928 concat!("Alignment of ", stringify!(ddsi_stringseq))
3929 );
3930 assert_eq!(
3931 unsafe { &(*(::std::ptr::null::<ddsi_stringseq>())).n as *const _ as usize },
3932 0usize,
3933 concat!(
3934 "Offset of field: ",
3935 stringify!(ddsi_stringseq),
3936 "::",
3937 stringify!(n)
3938 )
3939 );
3940 assert_eq!(
3941 unsafe { &(*(::std::ptr::null::<ddsi_stringseq>())).strs as *const _ as usize },
3942 8usize,
3943 concat!(
3944 "Offset of field: ",
3945 stringify!(ddsi_stringseq),
3946 "::",
3947 stringify!(strs)
3948 )
3949 );
3950}
3951impl Default for ddsi_stringseq {
3952 fn default() -> Self {
3953 unsafe { ::std::mem::zeroed() }
3954 }
3955}
3956pub type ddsi_stringseq_t = ddsi_stringseq;
3957pub type dds_partition_qospolicy_t = ddsi_stringseq_t;
3958#[repr(C)]
3959#[derive(Debug, Copy, Clone)]
3960pub struct dds_reliability_qospolicy {
3961 pub kind: dds_reliability_kind_t,
3962 pub max_blocking_time: dds_duration_t,
3963}
3964#[test]
3965fn bindgen_test_layout_dds_reliability_qospolicy() {
3966 assert_eq!(
3967 ::std::mem::size_of::<dds_reliability_qospolicy>(),
3968 16usize,
3969 concat!("Size of: ", stringify!(dds_reliability_qospolicy))
3970 );
3971 assert_eq!(
3972 ::std::mem::align_of::<dds_reliability_qospolicy>(),
3973 8usize,
3974 concat!("Alignment of ", stringify!(dds_reliability_qospolicy))
3975 );
3976 assert_eq!(
3977 unsafe { &(*(::std::ptr::null::<dds_reliability_qospolicy>())).kind as *const _ as usize },
3978 0usize,
3979 concat!(
3980 "Offset of field: ",
3981 stringify!(dds_reliability_qospolicy),
3982 "::",
3983 stringify!(kind)
3984 )
3985 );
3986 assert_eq!(
3987 unsafe {
3988 &(*(::std::ptr::null::<dds_reliability_qospolicy>())).max_blocking_time as *const _
3989 as usize
3990 },
3991 8usize,
3992 concat!(
3993 "Offset of field: ",
3994 stringify!(dds_reliability_qospolicy),
3995 "::",
3996 stringify!(max_blocking_time)
3997 )
3998 );
3999}
4000impl Default for dds_reliability_qospolicy {
4001 fn default() -> Self {
4002 unsafe { ::std::mem::zeroed() }
4003 }
4004}
4005pub type dds_reliability_qospolicy_t = dds_reliability_qospolicy;
4006#[repr(C)]
4007#[derive(Debug, Default, Copy, Clone)]
4008pub struct dds_transport_priority_qospolicy {
4009 pub value: i32,
4010}
4011#[test]
4012fn bindgen_test_layout_dds_transport_priority_qospolicy() {
4013 assert_eq!(
4014 ::std::mem::size_of::<dds_transport_priority_qospolicy>(),
4015 4usize,
4016 concat!("Size of: ", stringify!(dds_transport_priority_qospolicy))
4017 );
4018 assert_eq!(
4019 ::std::mem::align_of::<dds_transport_priority_qospolicy>(),
4020 4usize,
4021 concat!(
4022 "Alignment of ",
4023 stringify!(dds_transport_priority_qospolicy)
4024 )
4025 );
4026 assert_eq!(
4027 unsafe {
4028 &(*(::std::ptr::null::<dds_transport_priority_qospolicy>())).value as *const _ as usize
4029 },
4030 0usize,
4031 concat!(
4032 "Offset of field: ",
4033 stringify!(dds_transport_priority_qospolicy),
4034 "::",
4035 stringify!(value)
4036 )
4037 );
4038}
4039pub type dds_transport_priority_qospolicy_t = dds_transport_priority_qospolicy;
4040#[repr(C)]
4041#[derive(Debug, Default, Copy, Clone)]
4042pub struct dds_lifespan_qospolicy {
4043 pub duration: dds_duration_t,
4044}
4045#[test]
4046fn bindgen_test_layout_dds_lifespan_qospolicy() {
4047 assert_eq!(
4048 ::std::mem::size_of::<dds_lifespan_qospolicy>(),
4049 8usize,
4050 concat!("Size of: ", stringify!(dds_lifespan_qospolicy))
4051 );
4052 assert_eq!(
4053 ::std::mem::align_of::<dds_lifespan_qospolicy>(),
4054 8usize,
4055 concat!("Alignment of ", stringify!(dds_lifespan_qospolicy))
4056 );
4057 assert_eq!(
4058 unsafe { &(*(::std::ptr::null::<dds_lifespan_qospolicy>())).duration as *const _ as usize },
4059 0usize,
4060 concat!(
4061 "Offset of field: ",
4062 stringify!(dds_lifespan_qospolicy),
4063 "::",
4064 stringify!(duration)
4065 )
4066 );
4067}
4068pub type dds_lifespan_qospolicy_t = dds_lifespan_qospolicy;
4069#[repr(C)]
4070#[derive(Debug, Copy, Clone)]
4071pub struct dds_destination_order_qospolicy {
4072 pub kind: dds_destination_order_kind_t,
4073}
4074#[test]
4075fn bindgen_test_layout_dds_destination_order_qospolicy() {
4076 assert_eq!(
4077 ::std::mem::size_of::<dds_destination_order_qospolicy>(),
4078 4usize,
4079 concat!("Size of: ", stringify!(dds_destination_order_qospolicy))
4080 );
4081 assert_eq!(
4082 ::std::mem::align_of::<dds_destination_order_qospolicy>(),
4083 4usize,
4084 concat!("Alignment of ", stringify!(dds_destination_order_qospolicy))
4085 );
4086 assert_eq!(
4087 unsafe {
4088 &(*(::std::ptr::null::<dds_destination_order_qospolicy>())).kind as *const _ as usize
4089 },
4090 0usize,
4091 concat!(
4092 "Offset of field: ",
4093 stringify!(dds_destination_order_qospolicy),
4094 "::",
4095 stringify!(kind)
4096 )
4097 );
4098}
4099impl Default for dds_destination_order_qospolicy {
4100 fn default() -> Self {
4101 unsafe { ::std::mem::zeroed() }
4102 }
4103}
4104pub type dds_destination_order_qospolicy_t = dds_destination_order_qospolicy;
4105#[repr(C)]
4106#[derive(Debug, Default, Copy, Clone)]
4107pub struct dds_entity_factory_qospolicy {
4108 pub autoenable_created_entities: ::std::os::raw::c_uchar,
4109}
4110#[test]
4111fn bindgen_test_layout_dds_entity_factory_qospolicy() {
4112 assert_eq!(
4113 ::std::mem::size_of::<dds_entity_factory_qospolicy>(),
4114 1usize,
4115 concat!("Size of: ", stringify!(dds_entity_factory_qospolicy))
4116 );
4117 assert_eq!(
4118 ::std::mem::align_of::<dds_entity_factory_qospolicy>(),
4119 1usize,
4120 concat!("Alignment of ", stringify!(dds_entity_factory_qospolicy))
4121 );
4122 assert_eq!(
4123 unsafe {
4124 &(*(::std::ptr::null::<dds_entity_factory_qospolicy>())).autoenable_created_entities
4125 as *const _ as usize
4126 },
4127 0usize,
4128 concat!(
4129 "Offset of field: ",
4130 stringify!(dds_entity_factory_qospolicy),
4131 "::",
4132 stringify!(autoenable_created_entities)
4133 )
4134 );
4135}
4136pub type dds_entity_factory_qospolicy_t = dds_entity_factory_qospolicy;
4137#[repr(C)]
4138#[derive(Debug, Default, Copy, Clone)]
4139pub struct dds_writer_data_lifecycle_qospolicy {
4140 pub autodispose_unregistered_instances: ::std::os::raw::c_uchar,
4141}
4142#[test]
4143fn bindgen_test_layout_dds_writer_data_lifecycle_qospolicy() {
4144 assert_eq!(
4145 ::std::mem::size_of::<dds_writer_data_lifecycle_qospolicy>(),
4146 1usize,
4147 concat!("Size of: ", stringify!(dds_writer_data_lifecycle_qospolicy))
4148 );
4149 assert_eq!(
4150 ::std::mem::align_of::<dds_writer_data_lifecycle_qospolicy>(),
4151 1usize,
4152 concat!(
4153 "Alignment of ",
4154 stringify!(dds_writer_data_lifecycle_qospolicy)
4155 )
4156 );
4157 assert_eq!(
4158 unsafe {
4159 &(*(::std::ptr::null::<dds_writer_data_lifecycle_qospolicy>()))
4160 .autodispose_unregistered_instances as *const _ as usize
4161 },
4162 0usize,
4163 concat!(
4164 "Offset of field: ",
4165 stringify!(dds_writer_data_lifecycle_qospolicy),
4166 "::",
4167 stringify!(autodispose_unregistered_instances)
4168 )
4169 );
4170}
4171pub type dds_writer_data_lifecycle_qospolicy_t = dds_writer_data_lifecycle_qospolicy;
4172#[repr(C)]
4173#[derive(Debug, Default, Copy, Clone)]
4174pub struct dds_reader_data_lifecycle_qospolicy {
4175 pub autopurge_nowriter_samples_delay: dds_duration_t,
4176 pub autopurge_disposed_samples_delay: dds_duration_t,
4177}
4178#[test]
4179fn bindgen_test_layout_dds_reader_data_lifecycle_qospolicy() {
4180 assert_eq!(
4181 ::std::mem::size_of::<dds_reader_data_lifecycle_qospolicy>(),
4182 16usize,
4183 concat!("Size of: ", stringify!(dds_reader_data_lifecycle_qospolicy))
4184 );
4185 assert_eq!(
4186 ::std::mem::align_of::<dds_reader_data_lifecycle_qospolicy>(),
4187 8usize,
4188 concat!(
4189 "Alignment of ",
4190 stringify!(dds_reader_data_lifecycle_qospolicy)
4191 )
4192 );
4193 assert_eq!(
4194 unsafe {
4195 &(*(::std::ptr::null::<dds_reader_data_lifecycle_qospolicy>()))
4196 .autopurge_nowriter_samples_delay as *const _ as usize
4197 },
4198 0usize,
4199 concat!(
4200 "Offset of field: ",
4201 stringify!(dds_reader_data_lifecycle_qospolicy),
4202 "::",
4203 stringify!(autopurge_nowriter_samples_delay)
4204 )
4205 );
4206 assert_eq!(
4207 unsafe {
4208 &(*(::std::ptr::null::<dds_reader_data_lifecycle_qospolicy>()))
4209 .autopurge_disposed_samples_delay as *const _ as usize
4210 },
4211 8usize,
4212 concat!(
4213 "Offset of field: ",
4214 stringify!(dds_reader_data_lifecycle_qospolicy),
4215 "::",
4216 stringify!(autopurge_disposed_samples_delay)
4217 )
4218 );
4219}
4220pub type dds_reader_data_lifecycle_qospolicy_t = dds_reader_data_lifecycle_qospolicy;
4221#[repr(C)]
4222#[derive(Debug, Copy, Clone)]
4223pub struct dds_subscription_keys_qospolicy {
4224 pub use_key_list: ::std::os::raw::c_uchar,
4225 pub key_list: ddsi_stringseq_t,
4226}
4227#[test]
4228fn bindgen_test_layout_dds_subscription_keys_qospolicy() {
4229 assert_eq!(
4230 ::std::mem::size_of::<dds_subscription_keys_qospolicy>(),
4231 24usize,
4232 concat!("Size of: ", stringify!(dds_subscription_keys_qospolicy))
4233 );
4234 assert_eq!(
4235 ::std::mem::align_of::<dds_subscription_keys_qospolicy>(),
4236 8usize,
4237 concat!("Alignment of ", stringify!(dds_subscription_keys_qospolicy))
4238 );
4239 assert_eq!(
4240 unsafe {
4241 &(*(::std::ptr::null::<dds_subscription_keys_qospolicy>())).use_key_list as *const _
4242 as usize
4243 },
4244 0usize,
4245 concat!(
4246 "Offset of field: ",
4247 stringify!(dds_subscription_keys_qospolicy),
4248 "::",
4249 stringify!(use_key_list)
4250 )
4251 );
4252 assert_eq!(
4253 unsafe {
4254 &(*(::std::ptr::null::<dds_subscription_keys_qospolicy>())).key_list as *const _
4255 as usize
4256 },
4257 8usize,
4258 concat!(
4259 "Offset of field: ",
4260 stringify!(dds_subscription_keys_qospolicy),
4261 "::",
4262 stringify!(key_list)
4263 )
4264 );
4265}
4266impl Default for dds_subscription_keys_qospolicy {
4267 fn default() -> Self {
4268 unsafe { ::std::mem::zeroed() }
4269 }
4270}
4271pub type dds_subscription_keys_qospolicy_t = dds_subscription_keys_qospolicy;
4272#[repr(C)]
4273#[derive(Debug, Default, Copy, Clone)]
4274pub struct dds_reader_lifespan_qospolicy {
4275 pub use_lifespan: ::std::os::raw::c_uchar,
4276 pub duration: dds_duration_t,
4277}
4278#[test]
4279fn bindgen_test_layout_dds_reader_lifespan_qospolicy() {
4280 assert_eq!(
4281 ::std::mem::size_of::<dds_reader_lifespan_qospolicy>(),
4282 16usize,
4283 concat!("Size of: ", stringify!(dds_reader_lifespan_qospolicy))
4284 );
4285 assert_eq!(
4286 ::std::mem::align_of::<dds_reader_lifespan_qospolicy>(),
4287 8usize,
4288 concat!("Alignment of ", stringify!(dds_reader_lifespan_qospolicy))
4289 );
4290 assert_eq!(
4291 unsafe {
4292 &(*(::std::ptr::null::<dds_reader_lifespan_qospolicy>())).use_lifespan as *const _
4293 as usize
4294 },
4295 0usize,
4296 concat!(
4297 "Offset of field: ",
4298 stringify!(dds_reader_lifespan_qospolicy),
4299 "::",
4300 stringify!(use_lifespan)
4301 )
4302 );
4303 assert_eq!(
4304 unsafe {
4305 &(*(::std::ptr::null::<dds_reader_lifespan_qospolicy>())).duration as *const _ as usize
4306 },
4307 8usize,
4308 concat!(
4309 "Offset of field: ",
4310 stringify!(dds_reader_lifespan_qospolicy),
4311 "::",
4312 stringify!(duration)
4313 )
4314 );
4315}
4316pub type dds_reader_lifespan_qospolicy_t = dds_reader_lifespan_qospolicy;
4317#[repr(C)]
4318#[derive(Debug, Copy, Clone)]
4319pub struct dds_ignorelocal_qospolicy {
4320 pub value: dds_ignorelocal_kind_t,
4321}
4322#[test]
4323fn bindgen_test_layout_dds_ignorelocal_qospolicy() {
4324 assert_eq!(
4325 ::std::mem::size_of::<dds_ignorelocal_qospolicy>(),
4326 4usize,
4327 concat!("Size of: ", stringify!(dds_ignorelocal_qospolicy))
4328 );
4329 assert_eq!(
4330 ::std::mem::align_of::<dds_ignorelocal_qospolicy>(),
4331 4usize,
4332 concat!("Alignment of ", stringify!(dds_ignorelocal_qospolicy))
4333 );
4334 assert_eq!(
4335 unsafe { &(*(::std::ptr::null::<dds_ignorelocal_qospolicy>())).value as *const _ as usize },
4336 0usize,
4337 concat!(
4338 "Offset of field: ",
4339 stringify!(dds_ignorelocal_qospolicy),
4340 "::",
4341 stringify!(value)
4342 )
4343 );
4344}
4345impl Default for dds_ignorelocal_qospolicy {
4346 fn default() -> Self {
4347 unsafe { ::std::mem::zeroed() }
4348 }
4349}
4350pub type dds_ignorelocal_qospolicy_t = dds_ignorelocal_qospolicy;
4351#[repr(C)]
4352#[derive(Debug, Copy, Clone)]
4353pub struct dds_type_consistency_enforcement_qospolicy {
4354 pub kind: dds_type_consistency_kind_t,
4355 pub ignore_sequence_bounds: bool,
4356 pub ignore_string_bounds: bool,
4357 pub ignore_member_names: bool,
4358 pub prevent_type_widening: bool,
4359 pub force_type_validation: bool,
4360}
4361#[test]
4362fn bindgen_test_layout_dds_type_consistency_enforcement_qospolicy() {
4363 assert_eq!(
4364 ::std::mem::size_of::<dds_type_consistency_enforcement_qospolicy>(),
4365 12usize,
4366 concat!(
4367 "Size of: ",
4368 stringify!(dds_type_consistency_enforcement_qospolicy)
4369 )
4370 );
4371 assert_eq!(
4372 ::std::mem::align_of::<dds_type_consistency_enforcement_qospolicy>(),
4373 4usize,
4374 concat!(
4375 "Alignment of ",
4376 stringify!(dds_type_consistency_enforcement_qospolicy)
4377 )
4378 );
4379 assert_eq!(
4380 unsafe {
4381 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>())).kind as *const _
4382 as usize
4383 },
4384 0usize,
4385 concat!(
4386 "Offset of field: ",
4387 stringify!(dds_type_consistency_enforcement_qospolicy),
4388 "::",
4389 stringify!(kind)
4390 )
4391 );
4392 assert_eq!(
4393 unsafe {
4394 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>()))
4395 .ignore_sequence_bounds as *const _ as usize
4396 },
4397 4usize,
4398 concat!(
4399 "Offset of field: ",
4400 stringify!(dds_type_consistency_enforcement_qospolicy),
4401 "::",
4402 stringify!(ignore_sequence_bounds)
4403 )
4404 );
4405 assert_eq!(
4406 unsafe {
4407 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>()))
4408 .ignore_string_bounds as *const _ as usize
4409 },
4410 5usize,
4411 concat!(
4412 "Offset of field: ",
4413 stringify!(dds_type_consistency_enforcement_qospolicy),
4414 "::",
4415 stringify!(ignore_string_bounds)
4416 )
4417 );
4418 assert_eq!(
4419 unsafe {
4420 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>()))
4421 .ignore_member_names as *const _ as usize
4422 },
4423 6usize,
4424 concat!(
4425 "Offset of field: ",
4426 stringify!(dds_type_consistency_enforcement_qospolicy),
4427 "::",
4428 stringify!(ignore_member_names)
4429 )
4430 );
4431 assert_eq!(
4432 unsafe {
4433 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>()))
4434 .prevent_type_widening as *const _ as usize
4435 },
4436 7usize,
4437 concat!(
4438 "Offset of field: ",
4439 stringify!(dds_type_consistency_enforcement_qospolicy),
4440 "::",
4441 stringify!(prevent_type_widening)
4442 )
4443 );
4444 assert_eq!(
4445 unsafe {
4446 &(*(::std::ptr::null::<dds_type_consistency_enforcement_qospolicy>()))
4447 .force_type_validation as *const _ as usize
4448 },
4449 8usize,
4450 concat!(
4451 "Offset of field: ",
4452 stringify!(dds_type_consistency_enforcement_qospolicy),
4453 "::",
4454 stringify!(force_type_validation)
4455 )
4456 );
4457}
4458impl Default for dds_type_consistency_enforcement_qospolicy {
4459 fn default() -> Self {
4460 unsafe { ::std::mem::zeroed() }
4461 }
4462}
4463pub type dds_type_consistency_enforcement_qospolicy_t = dds_type_consistency_enforcement_qospolicy;
4464pub type dds_locator_mask_t = u32;
4465#[repr(C)]
4466#[derive(Debug, Copy, Clone)]
4467pub struct dds_data_representation_id_seq {
4468 pub n: u32,
4469 pub ids: *mut dds_data_representation_id_t,
4470}
4471#[test]
4472fn bindgen_test_layout_dds_data_representation_id_seq() {
4473 assert_eq!(
4474 ::std::mem::size_of::<dds_data_representation_id_seq>(),
4475 16usize,
4476 concat!("Size of: ", stringify!(dds_data_representation_id_seq))
4477 );
4478 assert_eq!(
4479 ::std::mem::align_of::<dds_data_representation_id_seq>(),
4480 8usize,
4481 concat!("Alignment of ", stringify!(dds_data_representation_id_seq))
4482 );
4483 assert_eq!(
4484 unsafe {
4485 &(*(::std::ptr::null::<dds_data_representation_id_seq>())).n as *const _ as usize
4486 },
4487 0usize,
4488 concat!(
4489 "Offset of field: ",
4490 stringify!(dds_data_representation_id_seq),
4491 "::",
4492 stringify!(n)
4493 )
4494 );
4495 assert_eq!(
4496 unsafe {
4497 &(*(::std::ptr::null::<dds_data_representation_id_seq>())).ids as *const _ as usize
4498 },
4499 8usize,
4500 concat!(
4501 "Offset of field: ",
4502 stringify!(dds_data_representation_id_seq),
4503 "::",
4504 stringify!(ids)
4505 )
4506 );
4507}
4508impl Default for dds_data_representation_id_seq {
4509 fn default() -> Self {
4510 unsafe { ::std::mem::zeroed() }
4511 }
4512}
4513pub type dds_data_representation_id_seq_t = dds_data_representation_id_seq;
4514#[repr(C)]
4515#[derive(Debug, Copy, Clone)]
4516pub struct dds_data_representation_qospolicy {
4517 pub value: dds_data_representation_id_seq_t,
4518}
4519#[test]
4520fn bindgen_test_layout_dds_data_representation_qospolicy() {
4521 assert_eq!(
4522 ::std::mem::size_of::<dds_data_representation_qospolicy>(),
4523 16usize,
4524 concat!("Size of: ", stringify!(dds_data_representation_qospolicy))
4525 );
4526 assert_eq!(
4527 ::std::mem::align_of::<dds_data_representation_qospolicy>(),
4528 8usize,
4529 concat!(
4530 "Alignment of ",
4531 stringify!(dds_data_representation_qospolicy)
4532 )
4533 );
4534 assert_eq!(
4535 unsafe {
4536 &(*(::std::ptr::null::<dds_data_representation_qospolicy>())).value as *const _ as usize
4537 },
4538 0usize,
4539 concat!(
4540 "Offset of field: ",
4541 stringify!(dds_data_representation_qospolicy),
4542 "::",
4543 stringify!(value)
4544 )
4545 );
4546}
4547impl Default for dds_data_representation_qospolicy {
4548 fn default() -> Self {
4549 unsafe { ::std::mem::zeroed() }
4550 }
4551}
4552pub type dds_data_representation_qospolicy_t = dds_data_representation_qospolicy;
4553#[repr(C)]
4554#[derive(Debug, Copy, Clone)]
4555pub struct dds_qos {
4556 pub present: u64,
4557 pub aliased: u64,
4558 pub topic_name: *mut ::std::os::raw::c_char,
4559 pub type_name: *mut ::std::os::raw::c_char,
4560 pub entity_name: *mut ::std::os::raw::c_char,
4561 pub type_information: *mut ddsi_typeinfo,
4562 pub presentation: dds_presentation_qospolicy_t,
4563 pub partition: dds_partition_qospolicy_t,
4564 pub group_data: dds_groupdata_qospolicy_t,
4565 pub entity_factory: dds_entity_factory_qospolicy_t,
4566 pub topic_data: dds_topicdata_qospolicy_t,
4567 pub durability: dds_durability_qospolicy_t,
4568 pub durability_service: dds_durability_service_qospolicy_t,
4569 pub deadline: dds_deadline_qospolicy_t,
4570 pub latency_budget: dds_latency_budget_qospolicy_t,
4571 pub liveliness: dds_liveliness_qospolicy_t,
4572 pub reliability: dds_reliability_qospolicy_t,
4573 pub destination_order: dds_destination_order_qospolicy_t,
4574 pub history: dds_history_qospolicy_t,
4575 pub resource_limits: dds_resource_limits_qospolicy_t,
4576 pub transport_priority: dds_transport_priority_qospolicy_t,
4577 pub lifespan: dds_lifespan_qospolicy_t,
4578 pub user_data: dds_userdata_qospolicy_t,
4579 pub ownership: dds_ownership_qospolicy_t,
4580 pub ownership_strength: dds_ownership_strength_qospolicy_t,
4581 pub time_based_filter: dds_time_based_filter_qospolicy_t,
4582 pub writer_data_lifecycle: dds_writer_data_lifecycle_qospolicy_t,
4583 pub reader_data_lifecycle: dds_reader_data_lifecycle_qospolicy_t,
4584 pub subscription_keys: dds_subscription_keys_qospolicy_t,
4585 pub reader_lifespan: dds_reader_lifespan_qospolicy_t,
4586 pub ignorelocal: dds_ignorelocal_qospolicy_t,
4587 pub property: dds_property_qospolicy_t,
4588 pub type_consistency: dds_type_consistency_enforcement_qospolicy_t,
4589 pub ignore_locator_type: dds_locator_mask_t,
4590 pub data_representation: dds_data_representation_qospolicy_t,
4591}
4592#[test]
4593fn bindgen_test_layout_dds_qos() {
4594 assert_eq!(
4595 ::std::mem::size_of::<dds_qos>(),
4596 408usize,
4597 concat!("Size of: ", stringify!(dds_qos))
4598 );
4599 assert_eq!(
4600 ::std::mem::align_of::<dds_qos>(),
4601 8usize,
4602 concat!("Alignment of ", stringify!(dds_qos))
4603 );
4604 assert_eq!(
4605 unsafe { &(*(::std::ptr::null::<dds_qos>())).present as *const _ as usize },
4606 0usize,
4607 concat!(
4608 "Offset of field: ",
4609 stringify!(dds_qos),
4610 "::",
4611 stringify!(present)
4612 )
4613 );
4614 assert_eq!(
4615 unsafe { &(*(::std::ptr::null::<dds_qos>())).aliased as *const _ as usize },
4616 8usize,
4617 concat!(
4618 "Offset of field: ",
4619 stringify!(dds_qos),
4620 "::",
4621 stringify!(aliased)
4622 )
4623 );
4624 assert_eq!(
4625 unsafe { &(*(::std::ptr::null::<dds_qos>())).topic_name as *const _ as usize },
4626 16usize,
4627 concat!(
4628 "Offset of field: ",
4629 stringify!(dds_qos),
4630 "::",
4631 stringify!(topic_name)
4632 )
4633 );
4634 assert_eq!(
4635 unsafe { &(*(::std::ptr::null::<dds_qos>())).type_name as *const _ as usize },
4636 24usize,
4637 concat!(
4638 "Offset of field: ",
4639 stringify!(dds_qos),
4640 "::",
4641 stringify!(type_name)
4642 )
4643 );
4644 assert_eq!(
4645 unsafe { &(*(::std::ptr::null::<dds_qos>())).entity_name as *const _ as usize },
4646 32usize,
4647 concat!(
4648 "Offset of field: ",
4649 stringify!(dds_qos),
4650 "::",
4651 stringify!(entity_name)
4652 )
4653 );
4654 assert_eq!(
4655 unsafe { &(*(::std::ptr::null::<dds_qos>())).type_information as *const _ as usize },
4656 40usize,
4657 concat!(
4658 "Offset of field: ",
4659 stringify!(dds_qos),
4660 "::",
4661 stringify!(type_information)
4662 )
4663 );
4664 assert_eq!(
4665 unsafe { &(*(::std::ptr::null::<dds_qos>())).presentation as *const _ as usize },
4666 48usize,
4667 concat!(
4668 "Offset of field: ",
4669 stringify!(dds_qos),
4670 "::",
4671 stringify!(presentation)
4672 )
4673 );
4674 assert_eq!(
4675 unsafe { &(*(::std::ptr::null::<dds_qos>())).partition as *const _ as usize },
4676 56usize,
4677 concat!(
4678 "Offset of field: ",
4679 stringify!(dds_qos),
4680 "::",
4681 stringify!(partition)
4682 )
4683 );
4684 assert_eq!(
4685 unsafe { &(*(::std::ptr::null::<dds_qos>())).group_data as *const _ as usize },
4686 72usize,
4687 concat!(
4688 "Offset of field: ",
4689 stringify!(dds_qos),
4690 "::",
4691 stringify!(group_data)
4692 )
4693 );
4694 assert_eq!(
4695 unsafe { &(*(::std::ptr::null::<dds_qos>())).entity_factory as *const _ as usize },
4696 88usize,
4697 concat!(
4698 "Offset of field: ",
4699 stringify!(dds_qos),
4700 "::",
4701 stringify!(entity_factory)
4702 )
4703 );
4704 assert_eq!(
4705 unsafe { &(*(::std::ptr::null::<dds_qos>())).topic_data as *const _ as usize },
4706 96usize,
4707 concat!(
4708 "Offset of field: ",
4709 stringify!(dds_qos),
4710 "::",
4711 stringify!(topic_data)
4712 )
4713 );
4714 assert_eq!(
4715 unsafe { &(*(::std::ptr::null::<dds_qos>())).durability as *const _ as usize },
4716 112usize,
4717 concat!(
4718 "Offset of field: ",
4719 stringify!(dds_qos),
4720 "::",
4721 stringify!(durability)
4722 )
4723 );
4724 assert_eq!(
4725 unsafe { &(*(::std::ptr::null::<dds_qos>())).durability_service as *const _ as usize },
4726 120usize,
4727 concat!(
4728 "Offset of field: ",
4729 stringify!(dds_qos),
4730 "::",
4731 stringify!(durability_service)
4732 )
4733 );
4734 assert_eq!(
4735 unsafe { &(*(::std::ptr::null::<dds_qos>())).deadline as *const _ as usize },
4736 152usize,
4737 concat!(
4738 "Offset of field: ",
4739 stringify!(dds_qos),
4740 "::",
4741 stringify!(deadline)
4742 )
4743 );
4744 assert_eq!(
4745 unsafe { &(*(::std::ptr::null::<dds_qos>())).latency_budget as *const _ as usize },
4746 160usize,
4747 concat!(
4748 "Offset of field: ",
4749 stringify!(dds_qos),
4750 "::",
4751 stringify!(latency_budget)
4752 )
4753 );
4754 assert_eq!(
4755 unsafe { &(*(::std::ptr::null::<dds_qos>())).liveliness as *const _ as usize },
4756 168usize,
4757 concat!(
4758 "Offset of field: ",
4759 stringify!(dds_qos),
4760 "::",
4761 stringify!(liveliness)
4762 )
4763 );
4764 assert_eq!(
4765 unsafe { &(*(::std::ptr::null::<dds_qos>())).reliability as *const _ as usize },
4766 184usize,
4767 concat!(
4768 "Offset of field: ",
4769 stringify!(dds_qos),
4770 "::",
4771 stringify!(reliability)
4772 )
4773 );
4774 assert_eq!(
4775 unsafe { &(*(::std::ptr::null::<dds_qos>())).destination_order as *const _ as usize },
4776 200usize,
4777 concat!(
4778 "Offset of field: ",
4779 stringify!(dds_qos),
4780 "::",
4781 stringify!(destination_order)
4782 )
4783 );
4784 assert_eq!(
4785 unsafe { &(*(::std::ptr::null::<dds_qos>())).history as *const _ as usize },
4786 204usize,
4787 concat!(
4788 "Offset of field: ",
4789 stringify!(dds_qos),
4790 "::",
4791 stringify!(history)
4792 )
4793 );
4794 assert_eq!(
4795 unsafe { &(*(::std::ptr::null::<dds_qos>())).resource_limits as *const _ as usize },
4796 212usize,
4797 concat!(
4798 "Offset of field: ",
4799 stringify!(dds_qos),
4800 "::",
4801 stringify!(resource_limits)
4802 )
4803 );
4804 assert_eq!(
4805 unsafe { &(*(::std::ptr::null::<dds_qos>())).transport_priority as *const _ as usize },
4806 224usize,
4807 concat!(
4808 "Offset of field: ",
4809 stringify!(dds_qos),
4810 "::",
4811 stringify!(transport_priority)
4812 )
4813 );
4814 assert_eq!(
4815 unsafe { &(*(::std::ptr::null::<dds_qos>())).lifespan as *const _ as usize },
4816 232usize,
4817 concat!(
4818 "Offset of field: ",
4819 stringify!(dds_qos),
4820 "::",
4821 stringify!(lifespan)
4822 )
4823 );
4824 assert_eq!(
4825 unsafe { &(*(::std::ptr::null::<dds_qos>())).user_data as *const _ as usize },
4826 240usize,
4827 concat!(
4828 "Offset of field: ",
4829 stringify!(dds_qos),
4830 "::",
4831 stringify!(user_data)
4832 )
4833 );
4834 assert_eq!(
4835 unsafe { &(*(::std::ptr::null::<dds_qos>())).ownership as *const _ as usize },
4836 256usize,
4837 concat!(
4838 "Offset of field: ",
4839 stringify!(dds_qos),
4840 "::",
4841 stringify!(ownership)
4842 )
4843 );
4844 assert_eq!(
4845 unsafe { &(*(::std::ptr::null::<dds_qos>())).ownership_strength as *const _ as usize },
4846 260usize,
4847 concat!(
4848 "Offset of field: ",
4849 stringify!(dds_qos),
4850 "::",
4851 stringify!(ownership_strength)
4852 )
4853 );
4854 assert_eq!(
4855 unsafe { &(*(::std::ptr::null::<dds_qos>())).time_based_filter as *const _ as usize },
4856 264usize,
4857 concat!(
4858 "Offset of field: ",
4859 stringify!(dds_qos),
4860 "::",
4861 stringify!(time_based_filter)
4862 )
4863 );
4864 assert_eq!(
4865 unsafe { &(*(::std::ptr::null::<dds_qos>())).writer_data_lifecycle as *const _ as usize },
4866 272usize,
4867 concat!(
4868 "Offset of field: ",
4869 stringify!(dds_qos),
4870 "::",
4871 stringify!(writer_data_lifecycle)
4872 )
4873 );
4874 assert_eq!(
4875 unsafe { &(*(::std::ptr::null::<dds_qos>())).reader_data_lifecycle as *const _ as usize },
4876 280usize,
4877 concat!(
4878 "Offset of field: ",
4879 stringify!(dds_qos),
4880 "::",
4881 stringify!(reader_data_lifecycle)
4882 )
4883 );
4884 assert_eq!(
4885 unsafe { &(*(::std::ptr::null::<dds_qos>())).subscription_keys as *const _ as usize },
4886 296usize,
4887 concat!(
4888 "Offset of field: ",
4889 stringify!(dds_qos),
4890 "::",
4891 stringify!(subscription_keys)
4892 )
4893 );
4894 assert_eq!(
4895 unsafe { &(*(::std::ptr::null::<dds_qos>())).reader_lifespan as *const _ as usize },
4896 320usize,
4897 concat!(
4898 "Offset of field: ",
4899 stringify!(dds_qos),
4900 "::",
4901 stringify!(reader_lifespan)
4902 )
4903 );
4904 assert_eq!(
4905 unsafe { &(*(::std::ptr::null::<dds_qos>())).ignorelocal as *const _ as usize },
4906 336usize,
4907 concat!(
4908 "Offset of field: ",
4909 stringify!(dds_qos),
4910 "::",
4911 stringify!(ignorelocal)
4912 )
4913 );
4914 assert_eq!(
4915 unsafe { &(*(::std::ptr::null::<dds_qos>())).property as *const _ as usize },
4916 344usize,
4917 concat!(
4918 "Offset of field: ",
4919 stringify!(dds_qos),
4920 "::",
4921 stringify!(property)
4922 )
4923 );
4924 assert_eq!(
4925 unsafe { &(*(::std::ptr::null::<dds_qos>())).type_consistency as *const _ as usize },
4926 376usize,
4927 concat!(
4928 "Offset of field: ",
4929 stringify!(dds_qos),
4930 "::",
4931 stringify!(type_consistency)
4932 )
4933 );
4934 assert_eq!(
4935 unsafe { &(*(::std::ptr::null::<dds_qos>())).ignore_locator_type as *const _ as usize },
4936 388usize,
4937 concat!(
4938 "Offset of field: ",
4939 stringify!(dds_qos),
4940 "::",
4941 stringify!(ignore_locator_type)
4942 )
4943 );
4944 assert_eq!(
4945 unsafe { &(*(::std::ptr::null::<dds_qos>())).data_representation as *const _ as usize },
4946 392usize,
4947 concat!(
4948 "Offset of field: ",
4949 stringify!(dds_qos),
4950 "::",
4951 stringify!(data_representation)
4952 )
4953 );
4954}
4955impl Default for dds_qos {
4956 fn default() -> Self {
4957 unsafe { ::std::mem::zeroed() }
4958 }
4959}
4960pub type ddsi_typeid_t = ddsi_typeid;
4961pub type ddsi_typeinfo_t = ddsi_typeinfo;
4962#[repr(C)]
4963#[derive(Debug, Copy, Clone)]
4964pub struct ddsi_typemap {
4965 _unused: [u8; 0],
4966}
4967pub type ddsi_typemap_t = ddsi_typemap;
4968pub const ddsi_typeid_kind_DDSI_TYPEID_KIND_MINIMAL: ddsi_typeid_kind = 0;
4969pub const ddsi_typeid_kind_DDSI_TYPEID_KIND_COMPLETE: ddsi_typeid_kind = 1;
4970pub const ddsi_typeid_kind_DDSI_TYPEID_KIND_PLAIN_COLLECTION_MINIMAL: ddsi_typeid_kind = 2;
4971pub const ddsi_typeid_kind_DDSI_TYPEID_KIND_PLAIN_COLLECTION_COMPLETE: ddsi_typeid_kind = 3;
4972pub const ddsi_typeid_kind_DDSI_TYPEID_KIND_FULLY_DESCRIPTIVE: ddsi_typeid_kind = 4;
4973pub type ddsi_typeid_kind = ::std::os::raw::c_uint;
4974pub use self::ddsi_typeid_kind as ddsi_typeid_kind_t;
4975#[repr(C)]
4976#[derive(Debug, Copy, Clone)]
4977pub struct ddsi_sertype {
4978 pub ops: *const ddsi_sertype_ops,
4979 pub serdata_ops: *const ddsi_serdata_ops,
4980 pub serdata_basehash: u32,
4981 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
4982 pub allowed_data_representation: u32,
4983 pub type_name: *mut ::std::os::raw::c_char,
4984 pub gv: ddsrt_atomic_voidp_t,
4985 pub flags_refc: ddsrt_atomic_uint32_t,
4986 pub base_sertype: *const ddsi_sertype,
4987 pub wrapped_sertopic: *mut ::std::os::raw::c_void,
4988 pub iox_size: u32,
4989}
4990#[test]
4991fn bindgen_test_layout_ddsi_sertype() {
4992 assert_eq!(
4993 ::std::mem::size_of::<ddsi_sertype>(),
4994 80usize,
4995 concat!("Size of: ", stringify!(ddsi_sertype))
4996 );
4997 assert_eq!(
4998 ::std::mem::align_of::<ddsi_sertype>(),
4999 8usize,
5000 concat!("Alignment of ", stringify!(ddsi_sertype))
5001 );
5002 assert_eq!(
5003 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).ops as *const _ as usize },
5004 0usize,
5005 concat!(
5006 "Offset of field: ",
5007 stringify!(ddsi_sertype),
5008 "::",
5009 stringify!(ops)
5010 )
5011 );
5012 assert_eq!(
5013 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).serdata_ops as *const _ as usize },
5014 8usize,
5015 concat!(
5016 "Offset of field: ",
5017 stringify!(ddsi_sertype),
5018 "::",
5019 stringify!(serdata_ops)
5020 )
5021 );
5022 assert_eq!(
5023 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).serdata_basehash as *const _ as usize },
5024 16usize,
5025 concat!(
5026 "Offset of field: ",
5027 stringify!(ddsi_sertype),
5028 "::",
5029 stringify!(serdata_basehash)
5030 )
5031 );
5032 assert_eq!(
5033 unsafe {
5034 &(*(::std::ptr::null::<ddsi_sertype>())).allowed_data_representation as *const _
5035 as usize
5036 },
5037 24usize,
5038 concat!(
5039 "Offset of field: ",
5040 stringify!(ddsi_sertype),
5041 "::",
5042 stringify!(allowed_data_representation)
5043 )
5044 );
5045 assert_eq!(
5046 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).type_name as *const _ as usize },
5047 32usize,
5048 concat!(
5049 "Offset of field: ",
5050 stringify!(ddsi_sertype),
5051 "::",
5052 stringify!(type_name)
5053 )
5054 );
5055 assert_eq!(
5056 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).gv as *const _ as usize },
5057 40usize,
5058 concat!(
5059 "Offset of field: ",
5060 stringify!(ddsi_sertype),
5061 "::",
5062 stringify!(gv)
5063 )
5064 );
5065 assert_eq!(
5066 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).flags_refc as *const _ as usize },
5067 48usize,
5068 concat!(
5069 "Offset of field: ",
5070 stringify!(ddsi_sertype),
5071 "::",
5072 stringify!(flags_refc)
5073 )
5074 );
5075 assert_eq!(
5076 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).base_sertype as *const _ as usize },
5077 56usize,
5078 concat!(
5079 "Offset of field: ",
5080 stringify!(ddsi_sertype),
5081 "::",
5082 stringify!(base_sertype)
5083 )
5084 );
5085 assert_eq!(
5086 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).wrapped_sertopic as *const _ as usize },
5087 64usize,
5088 concat!(
5089 "Offset of field: ",
5090 stringify!(ddsi_sertype),
5091 "::",
5092 stringify!(wrapped_sertopic)
5093 )
5094 );
5095 assert_eq!(
5096 unsafe { &(*(::std::ptr::null::<ddsi_sertype>())).iox_size as *const _ as usize },
5097 72usize,
5098 concat!(
5099 "Offset of field: ",
5100 stringify!(ddsi_sertype),
5101 "::",
5102 stringify!(iox_size)
5103 )
5104 );
5105}
5106impl Default for ddsi_sertype {
5107 fn default() -> Self {
5108 unsafe { ::std::mem::zeroed() }
5109 }
5110}
5111impl ddsi_sertype {
5112 #[inline]
5113 pub fn typekind_no_key(&self) -> u32 {
5114 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5115 }
5116 #[inline]
5117 pub fn set_typekind_no_key(&mut self, val: u32) {
5118 unsafe {
5119 let val: u32 = ::std::mem::transmute(val);
5120 self._bitfield_1.set(0usize, 1u8, val as u64)
5121 }
5122 }
5123 #[inline]
5124 pub fn request_keyhash(&self) -> u32 {
5125 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5126 }
5127 #[inline]
5128 pub fn set_request_keyhash(&mut self, val: u32) {
5129 unsafe {
5130 let val: u32 = ::std::mem::transmute(val);
5131 self._bitfield_1.set(1usize, 1u8, val as u64)
5132 }
5133 }
5134 #[inline]
5135 pub fn fixed_size(&self) -> u32 {
5136 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5137 }
5138 #[inline]
5139 pub fn set_fixed_size(&mut self, val: u32) {
5140 unsafe {
5141 let val: u32 = ::std::mem::transmute(val);
5142 self._bitfield_1.set(2usize, 1u8, val as u64)
5143 }
5144 }
5145 #[inline]
5146 pub fn new_bitfield_1(
5147 typekind_no_key: u32,
5148 request_keyhash: u32,
5149 fixed_size: u32,
5150 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
5151 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
5152 Default::default();
5153 __bindgen_bitfield_unit.set(0usize, 1u8, {
5154 let typekind_no_key: u32 = unsafe { ::std::mem::transmute(typekind_no_key) };
5155 typekind_no_key as u64
5156 });
5157 __bindgen_bitfield_unit.set(1usize, 1u8, {
5158 let request_keyhash: u32 = unsafe { ::std::mem::transmute(request_keyhash) };
5159 request_keyhash as u64
5160 });
5161 __bindgen_bitfield_unit.set(2usize, 1u8, {
5162 let fixed_size: u32 = unsafe { ::std::mem::transmute(fixed_size) };
5163 fixed_size as u64
5164 });
5165 __bindgen_bitfield_unit
5166 }
5167}
5168pub type ddsi_sertype_equal_t = ::std::option::Option<
5169 unsafe extern "C" fn(a: *const ddsi_sertype, b: *const ddsi_sertype) -> bool,
5170>;
5171pub type ddsi_sertype_hash_t =
5172 ::std::option::Option<unsafe extern "C" fn(tp: *const ddsi_sertype) -> u32>;
5173pub type ddsi_sertype_free_t = ::std::option::Option<unsafe extern "C" fn(tp: *mut ddsi_sertype)>;
5174pub type ddsi_sertype_zero_samples_t = ::std::option::Option<
5175 unsafe extern "C" fn(
5176 d: *const ddsi_sertype,
5177 samples: *mut ::std::os::raw::c_void,
5178 count: size_t,
5179 ),
5180>;
5181pub type ddsi_sertype_realloc_samples_t = ::std::option::Option<
5182 unsafe extern "C" fn(
5183 ptrs: *mut *mut ::std::os::raw::c_void,
5184 d: *const ddsi_sertype,
5185 old: *mut ::std::os::raw::c_void,
5186 oldcount: size_t,
5187 count: size_t,
5188 ),
5189>;
5190pub type ddsi_sertype_free_samples_t = ::std::option::Option<
5191 unsafe extern "C" fn(
5192 d: *const ddsi_sertype,
5193 ptrs: *mut *mut ::std::os::raw::c_void,
5194 count: size_t,
5195 op: dds_free_op_t,
5196 ),
5197>;
5198pub type ddsi_sertype_typeid_t = ::std::option::Option<
5199 unsafe extern "C" fn(tp: *const ddsi_sertype, kind: ddsi_typeid_kind_t) -> *mut ddsi_typeid_t,
5200>;
5201pub type ddsi_sertype_get_serialized_size_t = ::std::option::Option<
5202 unsafe extern "C" fn(d: *const ddsi_sertype, sample: *const ::std::os::raw::c_void) -> size_t,
5203>;
5204pub type ddsi_sertype_serialize_into_t = ::std::option::Option<
5205 unsafe extern "C" fn(
5206 d: *const ddsi_sertype,
5207 sample: *const ::std::os::raw::c_void,
5208 dst_buffer: *mut ::std::os::raw::c_void,
5209 dst_size: size_t,
5210 ) -> bool,
5211>;
5212pub type ddsi_sertype_typemap_t =
5213 ::std::option::Option<unsafe extern "C" fn(tp: *const ddsi_sertype) -> *mut ddsi_typemap_t>;
5214pub type ddsi_sertype_typeinfo_t =
5215 ::std::option::Option<unsafe extern "C" fn(tp: *const ddsi_sertype) -> *mut ddsi_typeinfo_t>;
5216pub type ddsi_sertype_derive_t = ::std::option::Option<
5217 unsafe extern "C" fn(
5218 sertype: *const ddsi_sertype,
5219 data_representation: dds_data_representation_id_t,
5220 tce_qos: dds_type_consistency_enforcement_qospolicy_t,
5221 ) -> *mut ddsi_sertype,
5222>;
5223#[repr(C)]
5224#[derive(Debug, Copy, Clone)]
5225pub struct ddsi_sertype_v0 {
5226 _unused: [u8; 0],
5227}
5228pub type ddsi_sertype_v0_t =
5229 ::std::option::Option<unsafe extern "C" fn(dummy: *mut ddsi_sertype_v0)>;
5230extern "C" {
5231 pub fn ddsi_sertype_v0(dummy: *mut ddsi_sertype_v0);
5232}
5233#[repr(C)]
5234#[derive(Debug, Copy, Clone)]
5235pub struct ddsi_sertype_ops {
5236 pub version: ddsi_sertype_v0_t,
5237 pub arg: *mut ::std::os::raw::c_void,
5238 pub free: ddsi_sertype_free_t,
5239 pub zero_samples: ddsi_sertype_zero_samples_t,
5240 pub realloc_samples: ddsi_sertype_realloc_samples_t,
5241 pub free_samples: ddsi_sertype_free_samples_t,
5242 pub equal: ddsi_sertype_equal_t,
5243 pub hash: ddsi_sertype_hash_t,
5244 pub type_id: ddsi_sertype_typeid_t,
5245 pub type_map: ddsi_sertype_typemap_t,
5246 pub type_info: ddsi_sertype_typeinfo_t,
5247 pub derive_sertype: ddsi_sertype_derive_t,
5248 pub get_serialized_size: ddsi_sertype_get_serialized_size_t,
5249 pub serialize_into: ddsi_sertype_serialize_into_t,
5250}
5251#[test]
5252fn bindgen_test_layout_ddsi_sertype_ops() {
5253 assert_eq!(
5254 ::std::mem::size_of::<ddsi_sertype_ops>(),
5255 112usize,
5256 concat!("Size of: ", stringify!(ddsi_sertype_ops))
5257 );
5258 assert_eq!(
5259 ::std::mem::align_of::<ddsi_sertype_ops>(),
5260 8usize,
5261 concat!("Alignment of ", stringify!(ddsi_sertype_ops))
5262 );
5263 assert_eq!(
5264 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).version as *const _ as usize },
5265 0usize,
5266 concat!(
5267 "Offset of field: ",
5268 stringify!(ddsi_sertype_ops),
5269 "::",
5270 stringify!(version)
5271 )
5272 );
5273 assert_eq!(
5274 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).arg as *const _ as usize },
5275 8usize,
5276 concat!(
5277 "Offset of field: ",
5278 stringify!(ddsi_sertype_ops),
5279 "::",
5280 stringify!(arg)
5281 )
5282 );
5283 assert_eq!(
5284 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).free as *const _ as usize },
5285 16usize,
5286 concat!(
5287 "Offset of field: ",
5288 stringify!(ddsi_sertype_ops),
5289 "::",
5290 stringify!(free)
5291 )
5292 );
5293 assert_eq!(
5294 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).zero_samples as *const _ as usize },
5295 24usize,
5296 concat!(
5297 "Offset of field: ",
5298 stringify!(ddsi_sertype_ops),
5299 "::",
5300 stringify!(zero_samples)
5301 )
5302 );
5303 assert_eq!(
5304 unsafe {
5305 &(*(::std::ptr::null::<ddsi_sertype_ops>())).realloc_samples as *const _ as usize
5306 },
5307 32usize,
5308 concat!(
5309 "Offset of field: ",
5310 stringify!(ddsi_sertype_ops),
5311 "::",
5312 stringify!(realloc_samples)
5313 )
5314 );
5315 assert_eq!(
5316 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).free_samples as *const _ as usize },
5317 40usize,
5318 concat!(
5319 "Offset of field: ",
5320 stringify!(ddsi_sertype_ops),
5321 "::",
5322 stringify!(free_samples)
5323 )
5324 );
5325 assert_eq!(
5326 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).equal as *const _ as usize },
5327 48usize,
5328 concat!(
5329 "Offset of field: ",
5330 stringify!(ddsi_sertype_ops),
5331 "::",
5332 stringify!(equal)
5333 )
5334 );
5335 assert_eq!(
5336 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).hash as *const _ as usize },
5337 56usize,
5338 concat!(
5339 "Offset of field: ",
5340 stringify!(ddsi_sertype_ops),
5341 "::",
5342 stringify!(hash)
5343 )
5344 );
5345 assert_eq!(
5346 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).type_id as *const _ as usize },
5347 64usize,
5348 concat!(
5349 "Offset of field: ",
5350 stringify!(ddsi_sertype_ops),
5351 "::",
5352 stringify!(type_id)
5353 )
5354 );
5355 assert_eq!(
5356 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).type_map as *const _ as usize },
5357 72usize,
5358 concat!(
5359 "Offset of field: ",
5360 stringify!(ddsi_sertype_ops),
5361 "::",
5362 stringify!(type_map)
5363 )
5364 );
5365 assert_eq!(
5366 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).type_info as *const _ as usize },
5367 80usize,
5368 concat!(
5369 "Offset of field: ",
5370 stringify!(ddsi_sertype_ops),
5371 "::",
5372 stringify!(type_info)
5373 )
5374 );
5375 assert_eq!(
5376 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).derive_sertype as *const _ as usize },
5377 88usize,
5378 concat!(
5379 "Offset of field: ",
5380 stringify!(ddsi_sertype_ops),
5381 "::",
5382 stringify!(derive_sertype)
5383 )
5384 );
5385 assert_eq!(
5386 unsafe {
5387 &(*(::std::ptr::null::<ddsi_sertype_ops>())).get_serialized_size as *const _ as usize
5388 },
5389 96usize,
5390 concat!(
5391 "Offset of field: ",
5392 stringify!(ddsi_sertype_ops),
5393 "::",
5394 stringify!(get_serialized_size)
5395 )
5396 );
5397 assert_eq!(
5398 unsafe { &(*(::std::ptr::null::<ddsi_sertype_ops>())).serialize_into as *const _ as usize },
5399 104usize,
5400 concat!(
5401 "Offset of field: ",
5402 stringify!(ddsi_sertype_ops),
5403 "::",
5404 stringify!(serialize_into)
5405 )
5406 );
5407}
5408impl Default for ddsi_sertype_ops {
5409 fn default() -> Self {
5410 unsafe { ::std::mem::zeroed() }
5411 }
5412}
5413extern "C" {
5414 pub fn ddsi_sertype_init(
5415 tp: *mut ddsi_sertype,
5416 type_name: *const ::std::os::raw::c_char,
5417 sertype_ops: *const ddsi_sertype_ops,
5418 serdata_ops: *const ddsi_serdata_ops,
5419 topickind_no_key: bool,
5420 );
5421}
5422extern "C" {
5423 pub fn ddsi_sertype_fini(tp: *mut ddsi_sertype);
5424}
5425#[repr(C)]
5426#[derive(Debug, Default, Copy, Clone)]
5427pub struct ddsi_keyhash {
5428 pub value: [::std::os::raw::c_uchar; 16usize],
5429}
5430#[test]
5431fn bindgen_test_layout_ddsi_keyhash() {
5432 assert_eq!(
5433 ::std::mem::size_of::<ddsi_keyhash>(),
5434 16usize,
5435 concat!("Size of: ", stringify!(ddsi_keyhash))
5436 );
5437 assert_eq!(
5438 ::std::mem::align_of::<ddsi_keyhash>(),
5439 1usize,
5440 concat!("Alignment of ", stringify!(ddsi_keyhash))
5441 );
5442 assert_eq!(
5443 unsafe { &(*(::std::ptr::null::<ddsi_keyhash>())).value as *const _ as usize },
5444 0usize,
5445 concat!(
5446 "Offset of field: ",
5447 stringify!(ddsi_keyhash),
5448 "::",
5449 stringify!(value)
5450 )
5451 );
5452}
5453pub type ddsi_keyhash_t = ddsi_keyhash;
5454pub const ddsi_serdata_kind_SDK_EMPTY: ddsi_serdata_kind = 0;
5455pub const ddsi_serdata_kind_SDK_KEY: ddsi_serdata_kind = 1;
5456pub const ddsi_serdata_kind_SDK_DATA: ddsi_serdata_kind = 2;
5457pub type ddsi_serdata_kind = ::std::os::raw::c_uint;
5458#[repr(C)]
5459#[derive(Debug, Copy, Clone)]
5460pub struct ddsi_serdata {
5461 pub ops: *const ddsi_serdata_ops,
5462 pub hash: u32,
5463 pub refc: ddsrt_atomic_uint32_t,
5464 pub kind: ddsi_serdata_kind,
5465 pub type_: *const ddsi_sertype,
5466 pub timestamp: ddsrt_wctime_t,
5467 pub statusinfo: u32,
5468 pub twrite: ddsrt_mtime_t,
5469 pub iox_chunk: *mut ::std::os::raw::c_void,
5470 pub iox_subscriber: *mut ::std::os::raw::c_void,
5471}
5472#[test]
5473fn bindgen_test_layout_ddsi_serdata() {
5474 assert_eq!(
5475 ::std::mem::size_of::<ddsi_serdata>(),
5476 72usize,
5477 concat!("Size of: ", stringify!(ddsi_serdata))
5478 );
5479 assert_eq!(
5480 ::std::mem::align_of::<ddsi_serdata>(),
5481 8usize,
5482 concat!("Alignment of ", stringify!(ddsi_serdata))
5483 );
5484 assert_eq!(
5485 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).ops as *const _ as usize },
5486 0usize,
5487 concat!(
5488 "Offset of field: ",
5489 stringify!(ddsi_serdata),
5490 "::",
5491 stringify!(ops)
5492 )
5493 );
5494 assert_eq!(
5495 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).hash as *const _ as usize },
5496 8usize,
5497 concat!(
5498 "Offset of field: ",
5499 stringify!(ddsi_serdata),
5500 "::",
5501 stringify!(hash)
5502 )
5503 );
5504 assert_eq!(
5505 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).refc as *const _ as usize },
5506 12usize,
5507 concat!(
5508 "Offset of field: ",
5509 stringify!(ddsi_serdata),
5510 "::",
5511 stringify!(refc)
5512 )
5513 );
5514 assert_eq!(
5515 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).kind as *const _ as usize },
5516 16usize,
5517 concat!(
5518 "Offset of field: ",
5519 stringify!(ddsi_serdata),
5520 "::",
5521 stringify!(kind)
5522 )
5523 );
5524 assert_eq!(
5525 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).type_ as *const _ as usize },
5526 24usize,
5527 concat!(
5528 "Offset of field: ",
5529 stringify!(ddsi_serdata),
5530 "::",
5531 stringify!(type_)
5532 )
5533 );
5534 assert_eq!(
5535 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).timestamp as *const _ as usize },
5536 32usize,
5537 concat!(
5538 "Offset of field: ",
5539 stringify!(ddsi_serdata),
5540 "::",
5541 stringify!(timestamp)
5542 )
5543 );
5544 assert_eq!(
5545 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).statusinfo as *const _ as usize },
5546 40usize,
5547 concat!(
5548 "Offset of field: ",
5549 stringify!(ddsi_serdata),
5550 "::",
5551 stringify!(statusinfo)
5552 )
5553 );
5554 assert_eq!(
5555 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).twrite as *const _ as usize },
5556 48usize,
5557 concat!(
5558 "Offset of field: ",
5559 stringify!(ddsi_serdata),
5560 "::",
5561 stringify!(twrite)
5562 )
5563 );
5564 assert_eq!(
5565 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).iox_chunk as *const _ as usize },
5566 56usize,
5567 concat!(
5568 "Offset of field: ",
5569 stringify!(ddsi_serdata),
5570 "::",
5571 stringify!(iox_chunk)
5572 )
5573 );
5574 assert_eq!(
5575 unsafe { &(*(::std::ptr::null::<ddsi_serdata>())).iox_subscriber as *const _ as usize },
5576 64usize,
5577 concat!(
5578 "Offset of field: ",
5579 stringify!(ddsi_serdata),
5580 "::",
5581 stringify!(iox_subscriber)
5582 )
5583 );
5584}
5585impl Default for ddsi_serdata {
5586 fn default() -> Self {
5587 unsafe { ::std::mem::zeroed() }
5588 }
5589}
5590pub type ddsi_serdata_size_t =
5591 ::std::option::Option<unsafe extern "C" fn(d: *const ddsi_serdata) -> u32>;
5592pub type ddsi_serdata_free_t = ::std::option::Option<unsafe extern "C" fn(d: *mut ddsi_serdata)>;
5593pub type ddsi_serdata_from_ser_t = ::std::option::Option<
5594 unsafe extern "C" fn(
5595 type_: *const ddsi_sertype,
5596 kind: ddsi_serdata_kind,
5597 fragchain: *const nn_rdata,
5598 size: size_t,
5599 ) -> *mut ddsi_serdata,
5600>;
5601pub type ddsi_serdata_from_ser_iov_t = ::std::option::Option<
5602 unsafe extern "C" fn(
5603 type_: *const ddsi_sertype,
5604 kind: ddsi_serdata_kind,
5605 niov: ddsrt_msg_iovlen_t,
5606 iov: *const ddsrt_iovec_t,
5607 size: size_t,
5608 ) -> *mut ddsi_serdata,
5609>;
5610pub type ddsi_serdata_from_keyhash_t = ::std::option::Option<
5611 unsafe extern "C" fn(
5612 type_: *const ddsi_sertype,
5613 keyhash: *const ddsi_keyhash,
5614 ) -> *mut ddsi_serdata,
5615>;
5616pub type ddsi_serdata_from_sample_t = ::std::option::Option<
5617 unsafe extern "C" fn(
5618 type_: *const ddsi_sertype,
5619 kind: ddsi_serdata_kind,
5620 sample: *const ::std::os::raw::c_void,
5621 ) -> *mut ddsi_serdata,
5622>;
5623pub type ddsi_serdata_to_untyped_t =
5624 ::std::option::Option<unsafe extern "C" fn(d: *const ddsi_serdata) -> *mut ddsi_serdata>;
5625pub type ddsi_serdata_to_ser_t = ::std::option::Option<
5626 unsafe extern "C" fn(
5627 d: *const ddsi_serdata,
5628 off: size_t,
5629 sz: size_t,
5630 buf: *mut ::std::os::raw::c_void,
5631 ),
5632>;
5633pub type ddsi_serdata_to_ser_ref_t = ::std::option::Option<
5634 unsafe extern "C" fn(
5635 d: *const ddsi_serdata,
5636 off: size_t,
5637 sz: size_t,
5638 ref_: *mut ddsrt_iovec_t,
5639 ) -> *mut ddsi_serdata,
5640>;
5641pub type ddsi_serdata_to_ser_unref_t =
5642 ::std::option::Option<unsafe extern "C" fn(d: *mut ddsi_serdata, ref_: *const ddsrt_iovec_t)>;
5643pub type ddsi_serdata_to_sample_t = ::std::option::Option<
5644 unsafe extern "C" fn(
5645 d: *const ddsi_serdata,
5646 sample: *mut ::std::os::raw::c_void,
5647 bufptr: *mut *mut ::std::os::raw::c_void,
5648 buflim: *mut ::std::os::raw::c_void,
5649 ) -> bool,
5650>;
5651pub type ddsi_serdata_untyped_to_sample_t = ::std::option::Option<
5652 unsafe extern "C" fn(
5653 type_: *const ddsi_sertype,
5654 d: *const ddsi_serdata,
5655 sample: *mut ::std::os::raw::c_void,
5656 bufptr: *mut *mut ::std::os::raw::c_void,
5657 buflim: *mut ::std::os::raw::c_void,
5658 ) -> bool,
5659>;
5660pub type ddsi_serdata_eqkey_t = ::std::option::Option<
5661 unsafe extern "C" fn(a: *const ddsi_serdata, b: *const ddsi_serdata) -> bool,
5662>;
5663pub type ddsi_serdata_print_t = ::std::option::Option<
5664 unsafe extern "C" fn(
5665 type_: *const ddsi_sertype,
5666 d: *const ddsi_serdata,
5667 buf: *mut ::std::os::raw::c_char,
5668 size: size_t,
5669 ) -> size_t,
5670>;
5671pub type ddsi_serdata_get_keyhash_t = ::std::option::Option<
5672 unsafe extern "C" fn(d: *const ddsi_serdata, buf: *mut ddsi_keyhash, force_md5: bool),
5673>;
5674pub type ddsi_serdata_iox_size_t =
5675 ::std::option::Option<unsafe extern "C" fn(d: *const ddsi_serdata) -> u32>;
5676pub type ddsi_serdata_from_iox_t = ::std::option::Option<
5677 unsafe extern "C" fn(
5678 type_: *const ddsi_sertype,
5679 kind: ddsi_serdata_kind,
5680 sub: *mut ::std::os::raw::c_void,
5681 buffer: *mut ::std::os::raw::c_void,
5682 ) -> *mut ddsi_serdata,
5683>;
5684#[repr(C)]
5685#[derive(Debug, Default, Copy, Clone)]
5686pub struct ddsi_serdata_ops {
5687 pub eqkey: ddsi_serdata_eqkey_t,
5688 pub get_size: ddsi_serdata_size_t,
5689 pub from_ser: ddsi_serdata_from_ser_t,
5690 pub from_ser_iov: ddsi_serdata_from_ser_iov_t,
5691 pub from_keyhash: ddsi_serdata_from_keyhash_t,
5692 pub from_sample: ddsi_serdata_from_sample_t,
5693 pub to_ser: ddsi_serdata_to_ser_t,
5694 pub to_ser_ref: ddsi_serdata_to_ser_ref_t,
5695 pub to_ser_unref: ddsi_serdata_to_ser_unref_t,
5696 pub to_sample: ddsi_serdata_to_sample_t,
5697 pub to_untyped: ddsi_serdata_to_untyped_t,
5698 pub untyped_to_sample: ddsi_serdata_untyped_to_sample_t,
5699 pub free: ddsi_serdata_free_t,
5700 pub print: ddsi_serdata_print_t,
5701 pub get_keyhash: ddsi_serdata_get_keyhash_t,
5702 pub get_sample_size: ddsi_serdata_iox_size_t,
5703 pub from_iox_buffer: ddsi_serdata_from_iox_t,
5704}
5705#[test]
5706fn bindgen_test_layout_ddsi_serdata_ops() {
5707 assert_eq!(
5708 ::std::mem::size_of::<ddsi_serdata_ops>(),
5709 136usize,
5710 concat!("Size of: ", stringify!(ddsi_serdata_ops))
5711 );
5712 assert_eq!(
5713 ::std::mem::align_of::<ddsi_serdata_ops>(),
5714 8usize,
5715 concat!("Alignment of ", stringify!(ddsi_serdata_ops))
5716 );
5717 assert_eq!(
5718 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).eqkey as *const _ as usize },
5719 0usize,
5720 concat!(
5721 "Offset of field: ",
5722 stringify!(ddsi_serdata_ops),
5723 "::",
5724 stringify!(eqkey)
5725 )
5726 );
5727 assert_eq!(
5728 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).get_size as *const _ as usize },
5729 8usize,
5730 concat!(
5731 "Offset of field: ",
5732 stringify!(ddsi_serdata_ops),
5733 "::",
5734 stringify!(get_size)
5735 )
5736 );
5737 assert_eq!(
5738 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).from_ser as *const _ as usize },
5739 16usize,
5740 concat!(
5741 "Offset of field: ",
5742 stringify!(ddsi_serdata_ops),
5743 "::",
5744 stringify!(from_ser)
5745 )
5746 );
5747 assert_eq!(
5748 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).from_ser_iov as *const _ as usize },
5749 24usize,
5750 concat!(
5751 "Offset of field: ",
5752 stringify!(ddsi_serdata_ops),
5753 "::",
5754 stringify!(from_ser_iov)
5755 )
5756 );
5757 assert_eq!(
5758 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).from_keyhash as *const _ as usize },
5759 32usize,
5760 concat!(
5761 "Offset of field: ",
5762 stringify!(ddsi_serdata_ops),
5763 "::",
5764 stringify!(from_keyhash)
5765 )
5766 );
5767 assert_eq!(
5768 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).from_sample as *const _ as usize },
5769 40usize,
5770 concat!(
5771 "Offset of field: ",
5772 stringify!(ddsi_serdata_ops),
5773 "::",
5774 stringify!(from_sample)
5775 )
5776 );
5777 assert_eq!(
5778 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).to_ser as *const _ as usize },
5779 48usize,
5780 concat!(
5781 "Offset of field: ",
5782 stringify!(ddsi_serdata_ops),
5783 "::",
5784 stringify!(to_ser)
5785 )
5786 );
5787 assert_eq!(
5788 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).to_ser_ref as *const _ as usize },
5789 56usize,
5790 concat!(
5791 "Offset of field: ",
5792 stringify!(ddsi_serdata_ops),
5793 "::",
5794 stringify!(to_ser_ref)
5795 )
5796 );
5797 assert_eq!(
5798 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).to_ser_unref as *const _ as usize },
5799 64usize,
5800 concat!(
5801 "Offset of field: ",
5802 stringify!(ddsi_serdata_ops),
5803 "::",
5804 stringify!(to_ser_unref)
5805 )
5806 );
5807 assert_eq!(
5808 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).to_sample as *const _ as usize },
5809 72usize,
5810 concat!(
5811 "Offset of field: ",
5812 stringify!(ddsi_serdata_ops),
5813 "::",
5814 stringify!(to_sample)
5815 )
5816 );
5817 assert_eq!(
5818 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).to_untyped as *const _ as usize },
5819 80usize,
5820 concat!(
5821 "Offset of field: ",
5822 stringify!(ddsi_serdata_ops),
5823 "::",
5824 stringify!(to_untyped)
5825 )
5826 );
5827 assert_eq!(
5828 unsafe {
5829 &(*(::std::ptr::null::<ddsi_serdata_ops>())).untyped_to_sample as *const _ as usize
5830 },
5831 88usize,
5832 concat!(
5833 "Offset of field: ",
5834 stringify!(ddsi_serdata_ops),
5835 "::",
5836 stringify!(untyped_to_sample)
5837 )
5838 );
5839 assert_eq!(
5840 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).free as *const _ as usize },
5841 96usize,
5842 concat!(
5843 "Offset of field: ",
5844 stringify!(ddsi_serdata_ops),
5845 "::",
5846 stringify!(free)
5847 )
5848 );
5849 assert_eq!(
5850 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).print as *const _ as usize },
5851 104usize,
5852 concat!(
5853 "Offset of field: ",
5854 stringify!(ddsi_serdata_ops),
5855 "::",
5856 stringify!(print)
5857 )
5858 );
5859 assert_eq!(
5860 unsafe { &(*(::std::ptr::null::<ddsi_serdata_ops>())).get_keyhash as *const _ as usize },
5861 112usize,
5862 concat!(
5863 "Offset of field: ",
5864 stringify!(ddsi_serdata_ops),
5865 "::",
5866 stringify!(get_keyhash)
5867 )
5868 );
5869 assert_eq!(
5870 unsafe {
5871 &(*(::std::ptr::null::<ddsi_serdata_ops>())).get_sample_size as *const _ as usize
5872 },
5873 120usize,
5874 concat!(
5875 "Offset of field: ",
5876 stringify!(ddsi_serdata_ops),
5877 "::",
5878 stringify!(get_sample_size)
5879 )
5880 );
5881 assert_eq!(
5882 unsafe {
5883 &(*(::std::ptr::null::<ddsi_serdata_ops>())).from_iox_buffer as *const _ as usize
5884 },
5885 128usize,
5886 concat!(
5887 "Offset of field: ",
5888 stringify!(ddsi_serdata_ops),
5889 "::",
5890 stringify!(from_iox_buffer)
5891 )
5892 );
5893}
5894extern "C" {
5895 pub fn ddsi_serdata_init(
5896 d: *mut ddsi_serdata,
5897 type_: *const ddsi_sertype,
5898 kind: ddsi_serdata_kind,
5899 );
5900}
5901#[repr(C)]
5902#[derive(Debug, Copy, Clone)]
5903pub struct nn_rbuf {
5904 _unused: [u8; 0],
5905}
5906#[repr(C)]
5907#[derive(Copy, Clone)]
5908pub struct nn_rmsg_chunk {
5909 pub rbuf: *mut nn_rbuf,
5910 pub next: *mut nn_rmsg_chunk,
5911 pub u: nn_rmsg_chunk__bindgen_ty_1,
5912}
5913#[repr(C)]
5914#[derive(Copy, Clone)]
5915pub union nn_rmsg_chunk__bindgen_ty_1 {
5916 pub size: u32,
5917 pub l: i64,
5918 pub d: f64,
5919 pub p: *mut ::std::os::raw::c_void,
5920 _bindgen_union_align: u64,
5921}
5922#[test]
5923fn bindgen_test_layout_nn_rmsg_chunk__bindgen_ty_1() {
5924 assert_eq!(
5925 ::std::mem::size_of::<nn_rmsg_chunk__bindgen_ty_1>(),
5926 8usize,
5927 concat!("Size of: ", stringify!(nn_rmsg_chunk__bindgen_ty_1))
5928 );
5929 assert_eq!(
5930 ::std::mem::align_of::<nn_rmsg_chunk__bindgen_ty_1>(),
5931 8usize,
5932 concat!("Alignment of ", stringify!(nn_rmsg_chunk__bindgen_ty_1))
5933 );
5934 assert_eq!(
5935 unsafe {
5936 &(*(::std::ptr::null::<nn_rmsg_chunk__bindgen_ty_1>())).size as *const _ as usize
5937 },
5938 0usize,
5939 concat!(
5940 "Offset of field: ",
5941 stringify!(nn_rmsg_chunk__bindgen_ty_1),
5942 "::",
5943 stringify!(size)
5944 )
5945 );
5946 assert_eq!(
5947 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk__bindgen_ty_1>())).l as *const _ as usize },
5948 0usize,
5949 concat!(
5950 "Offset of field: ",
5951 stringify!(nn_rmsg_chunk__bindgen_ty_1),
5952 "::",
5953 stringify!(l)
5954 )
5955 );
5956 assert_eq!(
5957 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk__bindgen_ty_1>())).d as *const _ as usize },
5958 0usize,
5959 concat!(
5960 "Offset of field: ",
5961 stringify!(nn_rmsg_chunk__bindgen_ty_1),
5962 "::",
5963 stringify!(d)
5964 )
5965 );
5966 assert_eq!(
5967 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk__bindgen_ty_1>())).p as *const _ as usize },
5968 0usize,
5969 concat!(
5970 "Offset of field: ",
5971 stringify!(nn_rmsg_chunk__bindgen_ty_1),
5972 "::",
5973 stringify!(p)
5974 )
5975 );
5976}
5977impl Default for nn_rmsg_chunk__bindgen_ty_1 {
5978 fn default() -> Self {
5979 unsafe { ::std::mem::zeroed() }
5980 }
5981}
5982#[test]
5983fn bindgen_test_layout_nn_rmsg_chunk() {
5984 assert_eq!(
5985 ::std::mem::size_of::<nn_rmsg_chunk>(),
5986 24usize,
5987 concat!("Size of: ", stringify!(nn_rmsg_chunk))
5988 );
5989 assert_eq!(
5990 ::std::mem::align_of::<nn_rmsg_chunk>(),
5991 8usize,
5992 concat!("Alignment of ", stringify!(nn_rmsg_chunk))
5993 );
5994 assert_eq!(
5995 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk>())).rbuf as *const _ as usize },
5996 0usize,
5997 concat!(
5998 "Offset of field: ",
5999 stringify!(nn_rmsg_chunk),
6000 "::",
6001 stringify!(rbuf)
6002 )
6003 );
6004 assert_eq!(
6005 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk>())).next as *const _ as usize },
6006 8usize,
6007 concat!(
6008 "Offset of field: ",
6009 stringify!(nn_rmsg_chunk),
6010 "::",
6011 stringify!(next)
6012 )
6013 );
6014 assert_eq!(
6015 unsafe { &(*(::std::ptr::null::<nn_rmsg_chunk>())).u as *const _ as usize },
6016 16usize,
6017 concat!(
6018 "Offset of field: ",
6019 stringify!(nn_rmsg_chunk),
6020 "::",
6021 stringify!(u)
6022 )
6023 );
6024}
6025impl Default for nn_rmsg_chunk {
6026 fn default() -> Self {
6027 unsafe { ::std::mem::zeroed() }
6028 }
6029}
6030#[repr(C)]
6031#[derive(Copy, Clone)]
6032pub struct nn_rmsg {
6033 pub refcount: ddsrt_atomic_uint32_t,
6034 pub lastchunk: *mut nn_rmsg_chunk,
6035 pub trace: bool,
6036 pub chunk: nn_rmsg_chunk,
6037}
6038#[test]
6039fn bindgen_test_layout_nn_rmsg() {
6040 assert_eq!(
6041 ::std::mem::size_of::<nn_rmsg>(),
6042 48usize,
6043 concat!("Size of: ", stringify!(nn_rmsg))
6044 );
6045 assert_eq!(
6046 ::std::mem::align_of::<nn_rmsg>(),
6047 8usize,
6048 concat!("Alignment of ", stringify!(nn_rmsg))
6049 );
6050 assert_eq!(
6051 unsafe { &(*(::std::ptr::null::<nn_rmsg>())).refcount as *const _ as usize },
6052 0usize,
6053 concat!(
6054 "Offset of field: ",
6055 stringify!(nn_rmsg),
6056 "::",
6057 stringify!(refcount)
6058 )
6059 );
6060 assert_eq!(
6061 unsafe { &(*(::std::ptr::null::<nn_rmsg>())).lastchunk as *const _ as usize },
6062 8usize,
6063 concat!(
6064 "Offset of field: ",
6065 stringify!(nn_rmsg),
6066 "::",
6067 stringify!(lastchunk)
6068 )
6069 );
6070 assert_eq!(
6071 unsafe { &(*(::std::ptr::null::<nn_rmsg>())).trace as *const _ as usize },
6072 16usize,
6073 concat!(
6074 "Offset of field: ",
6075 stringify!(nn_rmsg),
6076 "::",
6077 stringify!(trace)
6078 )
6079 );
6080 assert_eq!(
6081 unsafe { &(*(::std::ptr::null::<nn_rmsg>())).chunk as *const _ as usize },
6082 24usize,
6083 concat!(
6084 "Offset of field: ",
6085 stringify!(nn_rmsg),
6086 "::",
6087 stringify!(chunk)
6088 )
6089 );
6090}
6091impl Default for nn_rmsg {
6092 fn default() -> Self {
6093 unsafe { ::std::mem::zeroed() }
6094 }
6095}
6096#[repr(C)]
6097#[derive(Debug, Copy, Clone)]
6098pub struct nn_rdata {
6099 pub rmsg: *mut nn_rmsg,
6100 pub nextfrag: *mut nn_rdata,
6101 pub min: u32,
6102 pub maxp1: u32,
6103 pub submsg_zoff: u16,
6104 pub payload_zoff: u16,
6105 pub keyhash_zoff: u16,
6106 pub refcount_bias_added: ddsrt_atomic_uint32_t,
6107}
6108#[test]
6109fn bindgen_test_layout_nn_rdata() {
6110 assert_eq!(
6111 ::std::mem::size_of::<nn_rdata>(),
6112 40usize,
6113 concat!("Size of: ", stringify!(nn_rdata))
6114 );
6115 assert_eq!(
6116 ::std::mem::align_of::<nn_rdata>(),
6117 8usize,
6118 concat!("Alignment of ", stringify!(nn_rdata))
6119 );
6120 assert_eq!(
6121 unsafe { &(*(::std::ptr::null::<nn_rdata>())).rmsg as *const _ as usize },
6122 0usize,
6123 concat!(
6124 "Offset of field: ",
6125 stringify!(nn_rdata),
6126 "::",
6127 stringify!(rmsg)
6128 )
6129 );
6130 assert_eq!(
6131 unsafe { &(*(::std::ptr::null::<nn_rdata>())).nextfrag as *const _ as usize },
6132 8usize,
6133 concat!(
6134 "Offset of field: ",
6135 stringify!(nn_rdata),
6136 "::",
6137 stringify!(nextfrag)
6138 )
6139 );
6140 assert_eq!(
6141 unsafe { &(*(::std::ptr::null::<nn_rdata>())).min as *const _ as usize },
6142 16usize,
6143 concat!(
6144 "Offset of field: ",
6145 stringify!(nn_rdata),
6146 "::",
6147 stringify!(min)
6148 )
6149 );
6150 assert_eq!(
6151 unsafe { &(*(::std::ptr::null::<nn_rdata>())).maxp1 as *const _ as usize },
6152 20usize,
6153 concat!(
6154 "Offset of field: ",
6155 stringify!(nn_rdata),
6156 "::",
6157 stringify!(maxp1)
6158 )
6159 );
6160 assert_eq!(
6161 unsafe { &(*(::std::ptr::null::<nn_rdata>())).submsg_zoff as *const _ as usize },
6162 24usize,
6163 concat!(
6164 "Offset of field: ",
6165 stringify!(nn_rdata),
6166 "::",
6167 stringify!(submsg_zoff)
6168 )
6169 );
6170 assert_eq!(
6171 unsafe { &(*(::std::ptr::null::<nn_rdata>())).payload_zoff as *const _ as usize },
6172 26usize,
6173 concat!(
6174 "Offset of field: ",
6175 stringify!(nn_rdata),
6176 "::",
6177 stringify!(payload_zoff)
6178 )
6179 );
6180 assert_eq!(
6181 unsafe { &(*(::std::ptr::null::<nn_rdata>())).keyhash_zoff as *const _ as usize },
6182 28usize,
6183 concat!(
6184 "Offset of field: ",
6185 stringify!(nn_rdata),
6186 "::",
6187 stringify!(keyhash_zoff)
6188 )
6189 );
6190 assert_eq!(
6191 unsafe { &(*(::std::ptr::null::<nn_rdata>())).refcount_bias_added as *const _ as usize },
6192 32usize,
6193 concat!(
6194 "Offset of field: ",
6195 stringify!(nn_rdata),
6196 "::",
6197 stringify!(refcount_bias_added)
6198 )
6199 );
6200}
6201impl Default for nn_rdata {
6202 fn default() -> Self {
6203 unsafe { ::std::mem::zeroed() }
6204 }
6205}
6206pub type ddsrt_md5_byte_t = ::std::os::raw::c_uchar;
6207pub type ddsrt_md5_word_t = ::std::os::raw::c_uint;
6208#[repr(C)]
6209#[derive(Copy, Clone)]
6210pub struct ddsrt_md5_state_s {
6211 pub count: [ddsrt_md5_word_t; 2usize],
6212 pub abcd: [ddsrt_md5_word_t; 4usize],
6213 pub buf: [ddsrt_md5_byte_t; 64usize],
6214}
6215#[test]
6216fn bindgen_test_layout_ddsrt_md5_state_s() {
6217 assert_eq!(
6218 ::std::mem::size_of::<ddsrt_md5_state_s>(),
6219 88usize,
6220 concat!("Size of: ", stringify!(ddsrt_md5_state_s))
6221 );
6222 assert_eq!(
6223 ::std::mem::align_of::<ddsrt_md5_state_s>(),
6224 4usize,
6225 concat!("Alignment of ", stringify!(ddsrt_md5_state_s))
6226 );
6227 assert_eq!(
6228 unsafe { &(*(::std::ptr::null::<ddsrt_md5_state_s>())).count as *const _ as usize },
6229 0usize,
6230 concat!(
6231 "Offset of field: ",
6232 stringify!(ddsrt_md5_state_s),
6233 "::",
6234 stringify!(count)
6235 )
6236 );
6237 assert_eq!(
6238 unsafe { &(*(::std::ptr::null::<ddsrt_md5_state_s>())).abcd as *const _ as usize },
6239 8usize,
6240 concat!(
6241 "Offset of field: ",
6242 stringify!(ddsrt_md5_state_s),
6243 "::",
6244 stringify!(abcd)
6245 )
6246 );
6247 assert_eq!(
6248 unsafe { &(*(::std::ptr::null::<ddsrt_md5_state_s>())).buf as *const _ as usize },
6249 24usize,
6250 concat!(
6251 "Offset of field: ",
6252 stringify!(ddsrt_md5_state_s),
6253 "::",
6254 stringify!(buf)
6255 )
6256 );
6257}
6258impl Default for ddsrt_md5_state_s {
6259 fn default() -> Self {
6260 unsafe { ::std::mem::zeroed() }
6261 }
6262}
6263pub type ddsrt_md5_state_t = ddsrt_md5_state_s;
6264extern "C" {
6265 pub fn ddsrt_md5_init(pms: *mut ddsrt_md5_state_t);
6266}
6267extern "C" {
6268 pub fn ddsrt_md5_append(
6269 pms: *mut ddsrt_md5_state_t,
6270 data: *const ddsrt_md5_byte_t,
6271 nbytes: ::std::os::raw::c_uint,
6272 );
6273}
6274extern "C" {
6275 pub fn ddsrt_md5_finish(pms: *mut ddsrt_md5_state_t, digest: *mut ddsrt_md5_byte_t);
6276}
6277pub const ddsi_shm_loglevel_DDSI_SHM_OFF: ddsi_shm_loglevel = 0;
6278pub const ddsi_shm_loglevel_DDSI_SHM_FATAL: ddsi_shm_loglevel = 1;
6279pub const ddsi_shm_loglevel_DDSI_SHM_ERROR: ddsi_shm_loglevel = 2;
6280pub const ddsi_shm_loglevel_DDSI_SHM_WARN: ddsi_shm_loglevel = 3;
6281pub const ddsi_shm_loglevel_DDSI_SHM_INFO: ddsi_shm_loglevel = 4;
6282pub const ddsi_shm_loglevel_DDSI_SHM_DEBUG: ddsi_shm_loglevel = 5;
6283pub const ddsi_shm_loglevel_DDSI_SHM_VERBOSE: ddsi_shm_loglevel = 6;
6284pub type ddsi_shm_loglevel = ::std::os::raw::c_uint;
6285#[repr(C)]
6286#[derive(Debug, Copy, Clone)]
6287pub struct cpp2c_Publisher {
6288 _unused: [u8; 0],
6289}
6290pub type iox_pub_t = *mut cpp2c_Publisher;
6291#[repr(C)]
6292#[derive(Debug, Copy, Clone)]
6293pub struct cpp2c_Subscriber {
6294 _unused: [u8; 0],
6295}
6296pub type iox_sub_t = *mut cpp2c_Subscriber;
6297pub const iox_shm_data_state_t_IOX_CHUNK_UNINITIALIZED: iox_shm_data_state_t = 0;
6298pub const iox_shm_data_state_t_IOX_CHUNK_CONTAINS_RAW_DATA: iox_shm_data_state_t = 1;
6299pub const iox_shm_data_state_t_IOX_CHUNK_CONTAINS_SERIALIZED_DATA: iox_shm_data_state_t = 2;
6300pub type iox_shm_data_state_t = ::std::os::raw::c_uint;
6301#[repr(C)]
6302#[derive(Copy, Clone)]
6303pub struct iceoryx_header {
6304 pub guid: ddsi_guid,
6305 pub tstamp: dds_time_t,
6306 pub statusinfo: u32,
6307 pub data_size: u32,
6308 pub data_kind: ::std::os::raw::c_uchar,
6309 pub keyhash: ddsi_keyhash_t,
6310 pub shm_data_state: iox_shm_data_state_t,
6311}
6312#[test]
6313fn bindgen_test_layout_iceoryx_header() {
6314 assert_eq!(
6315 ::std::mem::size_of::<iceoryx_header>(),
6316 56usize,
6317 concat!("Size of: ", stringify!(iceoryx_header))
6318 );
6319 assert_eq!(
6320 ::std::mem::align_of::<iceoryx_header>(),
6321 8usize,
6322 concat!("Alignment of ", stringify!(iceoryx_header))
6323 );
6324 assert_eq!(
6325 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).guid as *const _ as usize },
6326 0usize,
6327 concat!(
6328 "Offset of field: ",
6329 stringify!(iceoryx_header),
6330 "::",
6331 stringify!(guid)
6332 )
6333 );
6334 assert_eq!(
6335 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).tstamp as *const _ as usize },
6336 16usize,
6337 concat!(
6338 "Offset of field: ",
6339 stringify!(iceoryx_header),
6340 "::",
6341 stringify!(tstamp)
6342 )
6343 );
6344 assert_eq!(
6345 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).statusinfo as *const _ as usize },
6346 24usize,
6347 concat!(
6348 "Offset of field: ",
6349 stringify!(iceoryx_header),
6350 "::",
6351 stringify!(statusinfo)
6352 )
6353 );
6354 assert_eq!(
6355 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).data_size as *const _ as usize },
6356 28usize,
6357 concat!(
6358 "Offset of field: ",
6359 stringify!(iceoryx_header),
6360 "::",
6361 stringify!(data_size)
6362 )
6363 );
6364 assert_eq!(
6365 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).data_kind as *const _ as usize },
6366 32usize,
6367 concat!(
6368 "Offset of field: ",
6369 stringify!(iceoryx_header),
6370 "::",
6371 stringify!(data_kind)
6372 )
6373 );
6374 assert_eq!(
6375 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).keyhash as *const _ as usize },
6376 33usize,
6377 concat!(
6378 "Offset of field: ",
6379 stringify!(iceoryx_header),
6380 "::",
6381 stringify!(keyhash)
6382 )
6383 );
6384 assert_eq!(
6385 unsafe { &(*(::std::ptr::null::<iceoryx_header>())).shm_data_state as *const _ as usize },
6386 52usize,
6387 concat!(
6388 "Offset of field: ",
6389 stringify!(iceoryx_header),
6390 "::",
6391 stringify!(shm_data_state)
6392 )
6393 );
6394}
6395impl Default for iceoryx_header {
6396 fn default() -> Self {
6397 unsafe { ::std::mem::zeroed() }
6398 }
6399}
6400pub type iceoryx_header_t = iceoryx_header;
6401extern "C" {
6402 pub fn shm_lock_iox_sub(sub: iox_sub_t);
6403}
6404extern "C" {
6405 pub fn shm_unlock_iox_sub(sub: iox_sub_t);
6406}
6407extern "C" {
6408 pub fn free_iox_chunk(iox_sub: *mut iox_sub_t, iox_chunk: *mut *mut ::std::os::raw::c_void);
6409}
6410extern "C" {
6411 pub fn iceoryx_header_from_chunk(
6412 iox_chunk: *const ::std::os::raw::c_void,
6413 ) -> *mut iceoryx_header_t;
6414}
6415extern "C" {
6416 pub fn shm_set_loglevel(arg1: ddsi_shm_loglevel);
6417}
6418extern "C" {
6419 pub fn shm_create_chunk(iox_pub: iox_pub_t, size: size_t) -> *mut ::std::os::raw::c_void;
6420}
6421extern "C" {
6422 pub fn shm_set_data_state(
6423 iox_chunk: *mut ::std::os::raw::c_void,
6424 data_state: iox_shm_data_state_t,
6425 );
6426}
6427extern "C" {
6428 pub fn shm_get_data_state(iox_chunk: *mut ::std::os::raw::c_void) -> iox_shm_data_state_t;
6429}
6430extern "C" {
6431 pub fn dds_is_loan_available(entity: dds_entity_t) -> bool;
6432}
6433extern "C" {
6434 pub fn dds_is_shared_memory_available(entity: dds_entity_t) -> bool;
6435}
6436extern "C" {
6437 pub fn dds_loan_shared_memory_buffer(
6438 writer: dds_entity_t,
6439 size: size_t,
6440 buffer: *mut *mut ::std::os::raw::c_void,
6441 ) -> dds_return_t;
6442}
6443extern "C" {
6444 pub fn dds_loan_sample(
6445 writer: dds_entity_t,
6446 sample: *mut *mut ::std::os::raw::c_void,
6447 ) -> dds_return_t;
6448}
6449extern "C" {
6450 pub fn _dummy(status: dds_status_id_t);
6451}
6452extern "C" {
6453 pub fn ddsi_serdata_addref(serdata_const: *const ddsi_serdata) -> *mut ddsi_serdata;
6454}
6455extern "C" {
6456 pub fn ddsi_serdata_removeref(serdata: *mut ddsi_serdata);
6457}
6458pub const BUILTIN_TOPIC_DCPSPARTICIPANT: ::std::os::raw::c_int = 2147418113;
6459pub const BUILTIN_TOPIC_DCPSTOPIC: ::std::os::raw::c_int = 2147418114;
6460pub const BUILTIN_TOPIC_DCPSPUBLICATION: ::std::os::raw::c_int = 2147418115;
6461pub const BUILTIN_TOPIC_DCPSSUBSCRIPTION: ::std::os::raw::c_int = 2147418116;