1#[repr(C)]
4#[derive(Debug, Copy, Clone)]
5pub struct pair {
6 pub _address: u8,
7}
8pub type pair_first_type = u8;
9pub type pair_second_type = u8;
10pub type pair__PCCP = u8;
11pub type pair__PCCFP = u8;
12pub type micro = u8;
13#[repr(C)]
14#[derive(Debug, Copy, Clone)]
15pub struct duration {
16 pub _address: u8,
17}
18pub type duration___is_float = u8;
19pub type duration___is_harmonic = u8;
20pub type duration_rep = u8;
21pub type duration_period = u8;
22#[repr(C)]
23#[derive(Debug, Copy, Clone)]
24pub struct time_point {
25 pub _address: u8,
26}
27pub type time_point_clock = u8;
28pub type time_point_duration = u8;
29pub type time_point_rep = u8;
30pub type time_point_period = u8;
31#[repr(C)]
32#[repr(align(1))]
33#[derive(Debug, Copy, Clone)]
34pub struct system_clock {
35 pub _bindgen_opaque_blob: u8,
36}
37pub type system_clock_duration = u64;
38pub type system_clock_rep = u64;
39pub type system_clock_period = u8;
40pub type system_clock_time_point = u64;
41#[test]
42fn bindgen_test_layout_system_clock() {
43 assert_eq!(
44 ::std::mem::size_of::<system_clock>(),
45 1usize,
46 concat!("Size of: ", stringify!(system_clock))
47 );
48 assert_eq!(
49 ::std::mem::align_of::<system_clock>(),
50 1usize,
51 concat!("Alignment of ", stringify!(system_clock))
52 );
53}
54extern "C" {
55 #[link_name = "\u{1}_ZNSt6chrono3_V212system_clock3nowEv"]
56 pub fn system_clock_now() -> system_clock_time_point;
57}
58extern "C" {
59 #[link_name = "\u{1}_ZNSt6chrono3_V212system_clock9to_time_tERKNS_10time_pointIS1_NS_8durationIlSt5ratioILl1ELl1000000000EEEEEE"]
60 pub fn system_clock_to_time_t(__t: *const system_clock_time_point) -> time_t;
61}
62extern "C" {
63 #[link_name = "\u{1}_ZNSt6chrono3_V212system_clock11from_time_tEl"]
64 pub fn system_clock_from_time_t(__t: time_t) -> system_clock_time_point;
65}
66impl system_clock {
67 #[inline]
68 pub unsafe fn now() -> system_clock_time_point {
69 system_clock_now()
70 }
71 #[inline]
72 pub unsafe fn to_time_t(__t: *const system_clock_time_point) -> time_t {
73 system_clock_to_time_t(__t)
74 }
75 #[inline]
76 pub unsafe fn from_time_t(__t: time_t) -> system_clock_time_point {
77 system_clock_from_time_t(__t)
78 }
79}
80pub const system_clock_is_steady: bool = false;
81pub type string = [u64; 4usize];
82pub type atomic_bool = u8;
83pub type __uint16_t = ::std::os::raw::c_ushort;
84pub type __int64_t = ::std::os::raw::c_long;
85pub type __time_t = ::std::os::raw::c_long;
86pub type time_t = __time_t;
87#[repr(C)]
88pub struct Clock__bindgen_vtable(::std::os::raw::c_void);
89#[repr(C)]
90#[derive(Debug)]
91pub struct Clock {
92 pub vtable_: *const Clock__bindgen_vtable,
93}
94#[test]
95fn bindgen_test_layout_Clock() {
96 assert_eq!(
97 ::std::mem::size_of::<Clock>(),
98 8usize,
99 concat!("Size of: ", stringify!(Clock))
100 );
101 assert_eq!(
102 ::std::mem::align_of::<Clock>(),
103 8usize,
104 concat!("Alignment of ", stringify!(Clock))
105 );
106}
107extern "C" {
108 #[link_name = "\u{1}_ZN3dex5Clock8getPhaseERS0_"]
109 pub fn Clock_getPhase(this: *mut ::std::os::raw::c_void, c: *mut Clock) -> dur;
110}
111extern "C" {
112 #[link_name = "\u{1}_ZN3dex5ClockD1Ev"]
113 pub fn Clock_Clock_destructor(this: *mut Clock);
114}
115extern "C" {
116 #[link_name = "\u{1}_ZN3dex5Clock3dieEv"]
117 pub fn Clock_die(this: *mut ::std::os::raw::c_void);
118}
119#[repr(C)]
120pub struct VariableFrequencyClock {
121 pub _base: Clock,
122 pub clockSrc_: *mut Clock,
123 pub frequencySrc_: f64,
124 pub frequency_: f64,
125 pub markerSrc_: tp,
126 pub marker_: tp,
127 pub rolledOver_: bool,
128}
129#[test]
130fn bindgen_test_layout_VariableFrequencyClock() {
131 assert_eq!(
132 ::std::mem::size_of::<VariableFrequencyClock>(),
133 56usize,
134 concat!("Size of: ", stringify!(VariableFrequencyClock))
135 );
136 assert_eq!(
137 ::std::mem::align_of::<VariableFrequencyClock>(),
138 8usize,
139 concat!("Alignment of ", stringify!(VariableFrequencyClock))
140 );
141 assert_eq!(
142 unsafe {
143 &(*(::std::ptr::null::<VariableFrequencyClock>())).clockSrc_ as *const _ as usize
144 },
145 8usize,
146 concat!(
147 "Offset of field: ",
148 stringify!(VariableFrequencyClock),
149 "::",
150 stringify!(clockSrc_)
151 )
152 );
153 assert_eq!(
154 unsafe {
155 &(*(::std::ptr::null::<VariableFrequencyClock>())).frequencySrc_ as *const _ as usize
156 },
157 16usize,
158 concat!(
159 "Offset of field: ",
160 stringify!(VariableFrequencyClock),
161 "::",
162 stringify!(frequencySrc_)
163 )
164 );
165 assert_eq!(
166 unsafe {
167 &(*(::std::ptr::null::<VariableFrequencyClock>())).frequency_ as *const _ as usize
168 },
169 24usize,
170 concat!(
171 "Offset of field: ",
172 stringify!(VariableFrequencyClock),
173 "::",
174 stringify!(frequency_)
175 )
176 );
177 assert_eq!(
178 unsafe {
179 &(*(::std::ptr::null::<VariableFrequencyClock>())).markerSrc_ as *const _ as usize
180 },
181 32usize,
182 concat!(
183 "Offset of field: ",
184 stringify!(VariableFrequencyClock),
185 "::",
186 stringify!(markerSrc_)
187 )
188 );
189 assert_eq!(
190 unsafe { &(*(::std::ptr::null::<VariableFrequencyClock>())).marker_ as *const _ as usize },
191 40usize,
192 concat!(
193 "Offset of field: ",
194 stringify!(VariableFrequencyClock),
195 "::",
196 stringify!(marker_)
197 )
198 );
199 assert_eq!(
200 unsafe {
201 &(*(::std::ptr::null::<VariableFrequencyClock>())).rolledOver_ as *const _ as usize
202 },
203 48usize,
204 concat!(
205 "Offset of field: ",
206 stringify!(VariableFrequencyClock),
207 "::",
208 stringify!(rolledOver_)
209 )
210 );
211}
212extern "C" {
213 #[link_name = "\u{1}_ZN3dex22VariableFrequencyClock8setValueENSt6chrono10time_pointINS1_3_V212system_clockENS1_8durationIlSt5ratioILl1ELl1000000EEEEEE"]
214 pub fn VariableFrequencyClock_setValue(this: *mut VariableFrequencyClock, arg1: tp);
215}
216extern "C" {
217 #[link_name = "\u{1}_ZNK3dex22VariableFrequencyClock12getFrequencyEv"]
218 pub fn VariableFrequencyClock_getFrequency(this: *const VariableFrequencyClock) -> f64;
219}
220extern "C" {
221 #[link_name = "\u{1}_ZN3dex22VariableFrequencyClock12setFrequencyEd"]
222 pub fn VariableFrequencyClock_setFrequency(this: *mut VariableFrequencyClock, arg1: f64);
223}
224extern "C" {
225 #[link_name = "\u{1}_ZN3dex22VariableFrequencyClockC1ERNS_5ClockE"]
226 pub fn VariableFrequencyClock_VariableFrequencyClock(
227 this: *mut VariableFrequencyClock,
228 arg1: *mut Clock,
229 );
230}
231impl VariableFrequencyClock {
232 #[inline]
233 pub unsafe fn setValue(&mut self, arg1: tp) {
234 VariableFrequencyClock_setValue(self, arg1)
235 }
236 #[inline]
237 pub unsafe fn getFrequency(&self) -> f64 {
238 VariableFrequencyClock_getFrequency(self)
239 }
240 #[inline]
241 pub unsafe fn setFrequency(&mut self, arg1: f64) {
242 VariableFrequencyClock_setFrequency(self, arg1)
243 }
244 #[inline]
245 pub unsafe fn new(arg1: *mut Clock) -> Self {
246 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
247 VariableFrequencyClock_VariableFrequencyClock(__bindgen_tmp.as_mut_ptr(), arg1);
248 __bindgen_tmp.assume_init()
249 }
250}
251extern "C" {
252 #[link_name = "\u{1}_ZN3dex22VariableFrequencyClock8getValueEv"]
253 pub fn VariableFrequencyClock_getValue(this: *mut ::std::os::raw::c_void) -> tp;
254}
255#[repr(C)]
256pub struct PhaseLockedClock {
257 pub _base: Clock,
258 pub primaryClock_: *mut Clock,
259 pub referenceClock_: *mut Clock,
260 pub variableFrequencyClock_: VariableFrequencyClock,
261 pub inSync_: bool,
262 pub phase_: dur,
263 pub phasePrev_: dur,
264 pub variableValue_: tp,
265 pub variableValuePrev_: tp,
266 pub primaryValue_: tp,
267 pub primaryValuePrev_: tp,
268 pub primaryFrequencyAvg_: f64,
269 pub phasePanic_: dur,
270 pub updatePanic_: dur,
271 pub updatePrev_: tp,
272}
273#[test]
274fn bindgen_test_layout_PhaseLockedClock() {
275 assert_eq!(
276 ::std::mem::size_of::<PhaseLockedClock>(),
277 168usize,
278 concat!("Size of: ", stringify!(PhaseLockedClock))
279 );
280 assert_eq!(
281 ::std::mem::align_of::<PhaseLockedClock>(),
282 8usize,
283 concat!("Alignment of ", stringify!(PhaseLockedClock))
284 );
285 assert_eq!(
286 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).primaryClock_ as *const _ as usize },
287 8usize,
288 concat!(
289 "Offset of field: ",
290 stringify!(PhaseLockedClock),
291 "::",
292 stringify!(primaryClock_)
293 )
294 );
295 assert_eq!(
296 unsafe {
297 &(*(::std::ptr::null::<PhaseLockedClock>())).referenceClock_ as *const _ as usize
298 },
299 16usize,
300 concat!(
301 "Offset of field: ",
302 stringify!(PhaseLockedClock),
303 "::",
304 stringify!(referenceClock_)
305 )
306 );
307 assert_eq!(
308 unsafe {
309 &(*(::std::ptr::null::<PhaseLockedClock>())).variableFrequencyClock_ as *const _
310 as usize
311 },
312 24usize,
313 concat!(
314 "Offset of field: ",
315 stringify!(PhaseLockedClock),
316 "::",
317 stringify!(variableFrequencyClock_)
318 )
319 );
320 assert_eq!(
321 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).inSync_ as *const _ as usize },
322 80usize,
323 concat!(
324 "Offset of field: ",
325 stringify!(PhaseLockedClock),
326 "::",
327 stringify!(inSync_)
328 )
329 );
330 assert_eq!(
331 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).phase_ as *const _ as usize },
332 88usize,
333 concat!(
334 "Offset of field: ",
335 stringify!(PhaseLockedClock),
336 "::",
337 stringify!(phase_)
338 )
339 );
340 assert_eq!(
341 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).phasePrev_ as *const _ as usize },
342 96usize,
343 concat!(
344 "Offset of field: ",
345 stringify!(PhaseLockedClock),
346 "::",
347 stringify!(phasePrev_)
348 )
349 );
350 assert_eq!(
351 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).variableValue_ as *const _ as usize },
352 104usize,
353 concat!(
354 "Offset of field: ",
355 stringify!(PhaseLockedClock),
356 "::",
357 stringify!(variableValue_)
358 )
359 );
360 assert_eq!(
361 unsafe {
362 &(*(::std::ptr::null::<PhaseLockedClock>())).variableValuePrev_ as *const _ as usize
363 },
364 112usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(PhaseLockedClock),
368 "::",
369 stringify!(variableValuePrev_)
370 )
371 );
372 assert_eq!(
373 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).primaryValue_ as *const _ as usize },
374 120usize,
375 concat!(
376 "Offset of field: ",
377 stringify!(PhaseLockedClock),
378 "::",
379 stringify!(primaryValue_)
380 )
381 );
382 assert_eq!(
383 unsafe {
384 &(*(::std::ptr::null::<PhaseLockedClock>())).primaryValuePrev_ as *const _ as usize
385 },
386 128usize,
387 concat!(
388 "Offset of field: ",
389 stringify!(PhaseLockedClock),
390 "::",
391 stringify!(primaryValuePrev_)
392 )
393 );
394 assert_eq!(
395 unsafe {
396 &(*(::std::ptr::null::<PhaseLockedClock>())).primaryFrequencyAvg_ as *const _ as usize
397 },
398 136usize,
399 concat!(
400 "Offset of field: ",
401 stringify!(PhaseLockedClock),
402 "::",
403 stringify!(primaryFrequencyAvg_)
404 )
405 );
406 assert_eq!(
407 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).phasePanic_ as *const _ as usize },
408 144usize,
409 concat!(
410 "Offset of field: ",
411 stringify!(PhaseLockedClock),
412 "::",
413 stringify!(phasePanic_)
414 )
415 );
416 assert_eq!(
417 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).updatePanic_ as *const _ as usize },
418 152usize,
419 concat!(
420 "Offset of field: ",
421 stringify!(PhaseLockedClock),
422 "::",
423 stringify!(updatePanic_)
424 )
425 );
426 assert_eq!(
427 unsafe { &(*(::std::ptr::null::<PhaseLockedClock>())).updatePrev_ as *const _ as usize },
428 160usize,
429 concat!(
430 "Offset of field: ",
431 stringify!(PhaseLockedClock),
432 "::",
433 stringify!(updatePrev_)
434 )
435 );
436}
437extern "C" {
438 #[link_name = "\u{1}_ZNK3dex16PhaseLockedClock14isSynchronizedEv"]
439 pub fn PhaseLockedClock_isSynchronized(this: *const PhaseLockedClock) -> bool;
440}
441extern "C" {
442 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock9getOffsetEv"]
443 pub fn PhaseLockedClock_getOffset(this: *mut PhaseLockedClock) -> dur;
444}
445extern "C" {
446 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock13setPhasePanicENSt6chrono8durationIlSt5ratioILl1ELl1000000EEEE"]
447 pub fn PhaseLockedClock_setPhasePanic(this: *mut PhaseLockedClock, phasePanic: dur);
448}
449extern "C" {
450 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock14setUpdatePanicENSt6chrono8durationIlSt5ratioILl1ELl1000000EEEE"]
451 pub fn PhaseLockedClock_setUpdatePanic(this: *mut PhaseLockedClock, usec: dur);
452}
453extern "C" {
454 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock3runERSt6atomicIbE"]
455 pub fn PhaseLockedClock_run(this: *mut PhaseLockedClock, arg1: *mut atomic_bool);
456}
457extern "C" {
458 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock6updateEv"]
459 pub fn PhaseLockedClock_update(this: *mut PhaseLockedClock);
460}
461extern "C" {
462 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock11updatePhaseEv"]
463 pub fn PhaseLockedClock_updatePhase(this: *mut PhaseLockedClock) -> bool;
464}
465extern "C" {
466 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock11updateClockEv"]
467 pub fn PhaseLockedClock_updateClock(this: *mut PhaseLockedClock) -> bool;
468}
469extern "C" {
470 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock8setClockEv"]
471 pub fn PhaseLockedClock_setClock(this: *mut PhaseLockedClock);
472}
473extern "C" {
474 #[link_name = "\u{1}_ZN3dex16PhaseLockedClockC1ERNS_5ClockES2_"]
475 pub fn PhaseLockedClock_PhaseLockedClock(
476 this: *mut PhaseLockedClock,
477 primary: *mut Clock,
478 reference: *mut Clock,
479 );
480}
481impl PhaseLockedClock {
482 #[inline]
483 pub unsafe fn isSynchronized(&self) -> bool {
484 PhaseLockedClock_isSynchronized(self)
485 }
486 #[inline]
487 pub unsafe fn getOffset(&mut self) -> dur {
488 PhaseLockedClock_getOffset(self)
489 }
490 #[inline]
491 pub unsafe fn setPhasePanic(&mut self, phasePanic: dur) {
492 PhaseLockedClock_setPhasePanic(self, phasePanic)
493 }
494 #[inline]
495 pub unsafe fn setUpdatePanic(&mut self, usec: dur) {
496 PhaseLockedClock_setUpdatePanic(self, usec)
497 }
498 #[inline]
499 pub unsafe fn run(&mut self, arg1: *mut atomic_bool) {
500 PhaseLockedClock_run(self, arg1)
501 }
502 #[inline]
503 pub unsafe fn update(&mut self) {
504 PhaseLockedClock_update(self)
505 }
506 #[inline]
507 pub unsafe fn updatePhase(&mut self) -> bool {
508 PhaseLockedClock_updatePhase(self)
509 }
510 #[inline]
511 pub unsafe fn updateClock(&mut self) -> bool {
512 PhaseLockedClock_updateClock(self)
513 }
514 #[inline]
515 pub unsafe fn setClock(&mut self) {
516 PhaseLockedClock_setClock(self)
517 }
518 #[inline]
519 pub unsafe fn new(primary: *mut Clock, reference: *mut Clock) -> Self {
520 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
521 PhaseLockedClock_PhaseLockedClock(__bindgen_tmp.as_mut_ptr(), primary, reference);
522 __bindgen_tmp.assume_init()
523 }
524}
525extern "C" {
526 #[link_name = "\u{1}_ZN3dex16PhaseLockedClockD1Ev"]
527 pub fn PhaseLockedClock_PhaseLockedClock_destructor(this: *mut PhaseLockedClock);
528}
529extern "C" {
530 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock3dieEv"]
531 pub fn PhaseLockedClock_die(this: *mut ::std::os::raw::c_void);
532}
533extern "C" {
534 #[link_name = "\u{1}_ZN3dex16PhaseLockedClock8getValueEv"]
535 pub fn PhaseLockedClock_getValue(this: *mut ::std::os::raw::c_void) -> tp;
536}
537#[doc = " A clock that gets its time over the network from a ClockServer."]
538#[doc = ""]
539#[doc = " To get the time, the clock sends a timestamped packet to to the server."]
540#[doc = " The server responds with its current time. The client then timestamps"]
541#[doc = " the response. The client can then calculate an estimated offset between"]
542#[doc = " the two clocks as well as an error bound on this calculation."]
543#[doc = ""]
544#[doc = " Because of this, getPhase() should really be used on a ClockClient."]
545#[doc = " However, getValue() can be used. getValue() calculates the current time"]
546#[doc = " by using the HighFrequencyClock as a timekeeper."]
547#[repr(C)]
548#[repr(align(8))]
549pub struct ClockClient {
550 pub _bindgen_opaque_blob: [u64; 35usize],
551}
552#[test]
553fn bindgen_test_layout_ClockClient() {
554 assert_eq!(
555 ::std::mem::size_of::<ClockClient>(),
556 280usize,
557 concat!("Size of: ", stringify!(ClockClient))
558 );
559 assert_eq!(
560 ::std::mem::align_of::<ClockClient>(),
561 8usize,
562 concat!("Alignment of ", stringify!(ClockClient))
563 );
564}
565extern "C" {
566 #[link_name = "\u{1}_ZNK3dex11ClockClient10getTimeoutEv"]
567 pub fn ClockClient_getTimeout(this: *const ClockClient) -> ::std::os::raw::c_int;
568}
569extern "C" {
570 #[link_name = "\u{1}_ZN3dex11ClockClient10setTimeoutEl"]
571 pub fn ClockClient_setTimeout(this: *mut ClockClient, usec: i64);
572}
573extern "C" {
574 #[link_name = "\u{1}_ZNK3dex11ClockClient3rttEv"]
575 pub fn ClockClient_rtt(this: *const ClockClient) -> dur;
576}
577extern "C" {
578 #[link_name = "\u{1}_ZN3dex11ClockClient14setAcknowledgeEb"]
579 pub fn ClockClient_setAcknowledge(this: *mut ClockClient, acknowledge: bool);
580}
581extern "C" {
582 #[link_name = "\u{1}_ZN3dex11ClockClientC1EN7kissnet8endpointE"]
583 pub fn ClockClient_ClockClient(this: *mut ClockClient, arg1: endpoint);
584}
585impl ClockClient {
586 #[inline]
587 pub unsafe fn getTimeout(&self) -> ::std::os::raw::c_int {
588 ClockClient_getTimeout(self)
589 }
590 #[inline]
591 pub unsafe fn setTimeout(&mut self, usec: i64) {
592 ClockClient_setTimeout(self, usec)
593 }
594 #[inline]
595 pub unsafe fn rtt(&self) -> dur {
596 ClockClient_rtt(self)
597 }
598 #[inline]
599 pub unsafe fn setAcknowledge(&mut self, acknowledge: bool) {
600 ClockClient_setAcknowledge(self, acknowledge)
601 }
602 #[inline]
603 pub unsafe fn new(arg1: endpoint) -> Self {
604 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
605 ClockClient_ClockClient(__bindgen_tmp.as_mut_ptr(), arg1);
606 __bindgen_tmp.assume_init()
607 }
608}
609extern "C" {
610 #[link_name = "\u{1}_ZN3dex11ClockClientD1Ev"]
611 pub fn ClockClient_ClockClient_destructor(this: *mut ClockClient);
612}
613extern "C" {
614 #[link_name = "\u{1}_ZN3dex11ClockClient8getValueEv"]
615 pub fn ClockClient_getValue(this: *mut ::std::os::raw::c_void) -> tp;
616}
617extern "C" {
618 #[link_name = "\u{1}_ZN3dex11ClockClient8getPhaseERNS_5ClockE"]
619 pub fn ClockClient_getPhase(this: *mut ::std::os::raw::c_void, clock: *mut Clock) -> dur;
620}
621extern "C" {
622 #[link_name = "\u{1}_ZN3dex11ClockClient3dieEv"]
623 pub fn ClockClient_die(this: *mut ::std::os::raw::c_void);
624}
625#[repr(C)]
626#[derive(Debug)]
627pub struct ConfigReader {
628 pub server: *const ::std::os::raw::c_char,
629 pub port: ::std::os::raw::c_uint,
630 pub timeout: ::std::os::raw::c_uint,
631 pub phasePanic: ::std::os::raw::c_uint,
632 pub updatePanic: ::std::os::raw::c_uint,
633}
634pub const ConfigReader_defaultPort: ::std::os::raw::c_uint = 4444;
635pub const ConfigReader_defaultTimeout: ::std::os::raw::c_uint = 1000;
636pub const ConfigReader_defaultPhasePanic: ::std::os::raw::c_uint = 5000;
637pub const ConfigReader_defaultUpdatePanic: ::std::os::raw::c_uint = 5000000;
638#[test]
639fn bindgen_test_layout_ConfigReader() {
640 assert_eq!(
641 ::std::mem::size_of::<ConfigReader>(),
642 24usize,
643 concat!("Size of: ", stringify!(ConfigReader))
644 );
645 assert_eq!(
646 ::std::mem::align_of::<ConfigReader>(),
647 8usize,
648 concat!("Alignment of ", stringify!(ConfigReader))
649 );
650 assert_eq!(
651 unsafe { &(*(::std::ptr::null::<ConfigReader>())).server as *const _ as usize },
652 0usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(ConfigReader),
656 "::",
657 stringify!(server)
658 )
659 );
660 assert_eq!(
661 unsafe { &(*(::std::ptr::null::<ConfigReader>())).port as *const _ as usize },
662 8usize,
663 concat!(
664 "Offset of field: ",
665 stringify!(ConfigReader),
666 "::",
667 stringify!(port)
668 )
669 );
670 assert_eq!(
671 unsafe { &(*(::std::ptr::null::<ConfigReader>())).timeout as *const _ as usize },
672 12usize,
673 concat!(
674 "Offset of field: ",
675 stringify!(ConfigReader),
676 "::",
677 stringify!(timeout)
678 )
679 );
680 assert_eq!(
681 unsafe { &(*(::std::ptr::null::<ConfigReader>())).phasePanic as *const _ as usize },
682 16usize,
683 concat!(
684 "Offset of field: ",
685 stringify!(ConfigReader),
686 "::",
687 stringify!(phasePanic)
688 )
689 );
690 assert_eq!(
691 unsafe { &(*(::std::ptr::null::<ConfigReader>())).updatePanic as *const _ as usize },
692 20usize,
693 concat!(
694 "Offset of field: ",
695 stringify!(ConfigReader),
696 "::",
697 stringify!(updatePanic)
698 )
699 );
700}
701extern "C" {
702 #[link_name = "\u{1}_ZN3dex12ConfigReader5printEv"]
703 pub fn ConfigReader_print(this: *mut ConfigReader);
704}
705extern "C" {
706 #[link_name = "\u{1}_ZN3dex12ConfigReader8readFromEPKc"]
707 pub fn ConfigReader_readFrom(
708 this: *mut ConfigReader,
709 arg1: *const ::std::os::raw::c_char,
710 ) -> bool;
711}
712extern "C" {
713 #[link_name = "\u{1}_ZN3dex12ConfigReader10buildClockEv"]
714 pub fn ConfigReader_buildClock(this: *mut ConfigReader) -> u8;
715}
716extern "C" {
717 #[link_name = "\u{1}_ZN3dex12ConfigReader8buildPLCEv"]
718 pub fn ConfigReader_buildPLC(this: *mut ConfigReader) -> *mut PhaseLockedClock;
719}
720extern "C" {
721 #[link_name = "\u{1}_ZN3dex12ConfigReaderC1Ev"]
722 pub fn ConfigReader_ConfigReader(this: *mut ConfigReader);
723}
724extern "C" {
725 #[link_name = "\u{1}_ZN3dex12ConfigReaderD1Ev"]
726 pub fn ConfigReader_ConfigReader_destructor(this: *mut ConfigReader);
727}
728impl ConfigReader {
729 #[inline]
730 pub unsafe fn print(&mut self) {
731 ConfigReader_print(self)
732 }
733 #[inline]
734 pub unsafe fn readFrom(&mut self, arg1: *const ::std::os::raw::c_char) -> bool {
735 ConfigReader_readFrom(self, arg1)
736 }
737 #[inline]
738 pub unsafe fn buildClock(&mut self) -> u8 {
739 ConfigReader_buildClock(self)
740 }
741 #[inline]
742 pub unsafe fn buildPLC(&mut self) -> *mut PhaseLockedClock {
743 ConfigReader_buildPLC(self)
744 }
745 #[inline]
746 pub unsafe fn new() -> Self {
747 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
748 ConfigReader_ConfigReader(__bindgen_tmp.as_mut_ptr());
749 __bindgen_tmp.assume_init()
750 }
751 #[inline]
752 pub unsafe fn destruct(&mut self) {
753 ConfigReader_ConfigReader_destructor(self)
754 }
755}
756pub type sa_family_t = ::std::os::raw::c_ushort;
757#[repr(C)]
758#[derive(Debug, Copy, Clone)]
759pub struct sockaddr {
760 pub sa_family: sa_family_t,
761 pub sa_data: [::std::os::raw::c_char; 14usize],
762}
763#[test]
764fn bindgen_test_layout_sockaddr() {
765 assert_eq!(
766 ::std::mem::size_of::<sockaddr>(),
767 16usize,
768 concat!("Size of: ", stringify!(sockaddr))
769 );
770 assert_eq!(
771 ::std::mem::align_of::<sockaddr>(),
772 2usize,
773 concat!("Alignment of ", stringify!(sockaddr))
774 );
775 assert_eq!(
776 unsafe { &(*(::std::ptr::null::<sockaddr>())).sa_family as *const _ as usize },
777 0usize,
778 concat!(
779 "Offset of field: ",
780 stringify!(sockaddr),
781 "::",
782 stringify!(sa_family)
783 )
784 );
785 assert_eq!(
786 unsafe { &(*(::std::ptr::null::<sockaddr>())).sa_data as *const _ as usize },
787 2usize,
788 concat!(
789 "Offset of field: ",
790 stringify!(sockaddr),
791 "::",
792 stringify!(sa_data)
793 )
794 );
795}
796pub type SOCKADDR = sockaddr;
797#[doc = "port_t is the port"]
798pub type port_t = u16;
799#[doc = "An endpoint is where the network will connect to (address and port)"]
800#[repr(C)]
801#[derive(Debug, Copy, Clone)]
802pub struct endpoint {
803 #[doc = "The address to connect to"]
804 pub address: string,
805 #[doc = "The port to connect to"]
806 pub port: port_t,
807}
808#[test]
809fn bindgen_test_layout_endpoint() {
810 assert_eq!(
811 ::std::mem::size_of::<endpoint>(),
812 40usize,
813 concat!("Size of: ", stringify!(endpoint))
814 );
815 assert_eq!(
816 ::std::mem::align_of::<endpoint>(),
817 8usize,
818 concat!("Alignment of ", stringify!(endpoint))
819 );
820 assert_eq!(
821 unsafe { &(*(::std::ptr::null::<endpoint>())).address as *const _ as usize },
822 0usize,
823 concat!(
824 "Offset of field: ",
825 stringify!(endpoint),
826 "::",
827 stringify!(address)
828 )
829 );
830 assert_eq!(
831 unsafe { &(*(::std::ptr::null::<endpoint>())).port as *const _ as usize },
832 32usize,
833 concat!(
834 "Offset of field: ",
835 stringify!(endpoint),
836 "::",
837 stringify!(port)
838 )
839 );
840}