1pub const _SYS_TIME_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __USE_ISOC11: u32 = 1;
7pub const __USE_ISOC99: u32 = 1;
8pub const __USE_ISOC95: u32 = 1;
9pub const __USE_POSIX_IMPLICITLY: u32 = 1;
10pub const _POSIX_SOURCE: u32 = 1;
11pub const _POSIX_C_SOURCE: u32 = 200809;
12pub const __USE_POSIX: u32 = 1;
13pub const __USE_POSIX2: u32 = 1;
14pub const __USE_POSIX199309: u32 = 1;
15pub const __USE_POSIX199506: u32 = 1;
16pub const __USE_XOPEN2K: u32 = 1;
17pub const __USE_XOPEN2K8: u32 = 1;
18pub const _ATFILE_SOURCE: u32 = 1;
19pub const __USE_MISC: u32 = 1;
20pub const __USE_ATFILE: u32 = 1;
21pub const __USE_FORTIFY_LEVEL: u32 = 0;
22pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
23pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
24pub const _STDC_PREDEF_H: u32 = 1;
25pub const __STDC_IEC_559__: u32 = 1;
26pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
27pub const __STDC_ISO_10646__: u32 = 201706;
28pub const __GNU_LIBRARY__: u32 = 6;
29pub const __GLIBC__: u32 = 2;
30pub const __GLIBC_MINOR__: u32 = 29;
31pub const _SYS_CDEFS_H: u32 = 1;
32pub const __glibc_c99_flexarr_available: u32 = 1;
33pub const __WORDSIZE: u32 = 64;
34pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
35pub const __SYSCALL_WORDSIZE: u32 = 64;
36pub const __HAVE_GENERIC_SELECTION: u32 = 1;
37pub const _BITS_TYPES_H: u32 = 1;
38pub const __TIMESIZE: u32 = 64;
39pub const _BITS_TYPESIZES_H: u32 = 1;
40pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
41pub const __INO_T_MATCHES_INO64_T: u32 = 1;
42pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
43pub const __FD_SETSIZE: u32 = 1024;
44pub const _BITS_TIME64_H: u32 = 1;
45pub const __time_t_defined: u32 = 1;
46pub const __timeval_defined: u32 = 1;
47pub const _SYS_SELECT_H: u32 = 1;
48pub const __FD_ZERO_STOS: &'static [u8; 6usize] = b"stosq\0";
49pub const __sigset_t_defined: u32 = 1;
50pub const _STRUCT_TIMESPEC: u32 = 1;
51pub const FD_SETSIZE: u32 = 1024;
52pub const _STDINT_H: u32 = 1;
53pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
54pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
55pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
56pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
57pub const _BITS_WCHAR_H: u32 = 1;
58pub const _BITS_STDINT_INTN_H: u32 = 1;
59pub const _BITS_STDINT_UINTN_H: u32 = 1;
60pub const INT8_MIN: i32 = -128;
61pub const INT16_MIN: i32 = -32768;
62pub const INT32_MIN: i32 = -2147483648;
63pub const INT8_MAX: u32 = 127;
64pub const INT16_MAX: u32 = 32767;
65pub const INT32_MAX: u32 = 2147483647;
66pub const UINT8_MAX: u32 = 255;
67pub const UINT16_MAX: u32 = 65535;
68pub const UINT32_MAX: u32 = 4294967295;
69pub const INT_LEAST8_MIN: i32 = -128;
70pub const INT_LEAST16_MIN: i32 = -32768;
71pub const INT_LEAST32_MIN: i32 = -2147483648;
72pub const INT_LEAST8_MAX: u32 = 127;
73pub const INT_LEAST16_MAX: u32 = 32767;
74pub const INT_LEAST32_MAX: u32 = 2147483647;
75pub const UINT_LEAST8_MAX: u32 = 255;
76pub const UINT_LEAST16_MAX: u32 = 65535;
77pub const UINT_LEAST32_MAX: u32 = 4294967295;
78pub const INT_FAST8_MIN: i32 = -128;
79pub const INT_FAST16_MIN: i64 = -9223372036854775808;
80pub const INT_FAST32_MIN: i64 = -9223372036854775808;
81pub const INT_FAST8_MAX: u32 = 127;
82pub const INT_FAST16_MAX: u64 = 9223372036854775807;
83pub const INT_FAST32_MAX: u64 = 9223372036854775807;
84pub const UINT_FAST8_MAX: u32 = 255;
85pub const UINT_FAST16_MAX: i32 = -1;
86pub const UINT_FAST32_MAX: i32 = -1;
87pub const INTPTR_MIN: i64 = -9223372036854775808;
88pub const INTPTR_MAX: u64 = 9223372036854775807;
89pub const UINTPTR_MAX: i32 = -1;
90pub const PTRDIFF_MIN: i64 = -9223372036854775808;
91pub const PTRDIFF_MAX: u64 = 9223372036854775807;
92pub const SIG_ATOMIC_MIN: i32 = -2147483648;
93pub const SIG_ATOMIC_MAX: u32 = 2147483647;
94pub const SIZE_MAX: i32 = -1;
95pub const WINT_MIN: u32 = 0;
96pub const WINT_MAX: u32 = 4294967295;
97pub const true_: u32 = 1;
98pub const false_: u32 = 0;
99pub const __bool_true_false_are_defined: u32 = 1;
100pub type __u_char = libc::c_uchar;
101pub type __u_short = libc::c_ushort;
102pub type __u_int = libc::c_uint;
103pub type __u_long = libc::c_ulong;
104pub type __int8_t = libc::c_schar;
105pub type __uint8_t = libc::c_uchar;
106pub type __int16_t = libc::c_short;
107pub type __uint16_t = libc::c_ushort;
108pub type __int32_t = libc::c_int;
109pub type __uint32_t = libc::c_uint;
110pub type __int64_t = libc::c_long;
111pub type __uint64_t = libc::c_ulong;
112pub type __int_least8_t = __int8_t;
113pub type __uint_least8_t = __uint8_t;
114pub type __int_least16_t = __int16_t;
115pub type __uint_least16_t = __uint16_t;
116pub type __int_least32_t = __int32_t;
117pub type __uint_least32_t = __uint32_t;
118pub type __int_least64_t = __int64_t;
119pub type __uint_least64_t = __uint64_t;
120pub type __quad_t = libc::c_long;
121pub type __u_quad_t = libc::c_ulong;
122pub type __intmax_t = libc::c_long;
123pub type __uintmax_t = libc::c_ulong;
124pub type __dev_t = libc::c_ulong;
125pub type __uid_t = libc::c_uint;
126pub type __gid_t = libc::c_uint;
127pub type __ino_t = libc::c_ulong;
128pub type __ino64_t = libc::c_ulong;
129pub type __mode_t = libc::c_uint;
130pub type __nlink_t = libc::c_ulong;
131pub type __off_t = libc::c_long;
132pub type __off64_t = libc::c_long;
133pub type __pid_t = libc::c_int;
134#[repr(C)]
135#[derive(Debug, Copy, Clone)]
136pub struct __fsid_t {
137 pub __val: [libc::c_int; 2usize],
138}
139#[test]
140fn bindgen_test_layout___fsid_t() {
141 assert_eq!(
142 ::std::mem::size_of::<__fsid_t>(),
143 8usize,
144 concat!("Size of: ", stringify!(__fsid_t))
145 );
146 assert_eq!(
147 ::std::mem::align_of::<__fsid_t>(),
148 4usize,
149 concat!("Alignment of ", stringify!(__fsid_t))
150 );
151 assert_eq!(
152 unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
153 0usize,
154 concat!(
155 "Offset of field: ",
156 stringify!(__fsid_t),
157 "::",
158 stringify!(__val)
159 )
160 );
161}
162pub type __clock_t = libc::c_long;
163pub type __rlim_t = libc::c_ulong;
164pub type __rlim64_t = libc::c_ulong;
165pub type __id_t = libc::c_uint;
166pub type __time_t = libc::c_long;
167pub type __useconds_t = libc::c_uint;
168pub type __suseconds_t = libc::c_long;
169pub type __daddr_t = libc::c_int;
170pub type __key_t = libc::c_int;
171pub type __clockid_t = libc::c_int;
172pub type __timer_t = *mut libc::c_void;
173pub type __blksize_t = libc::c_long;
174pub type __blkcnt_t = libc::c_long;
175pub type __blkcnt64_t = libc::c_long;
176pub type __fsblkcnt_t = libc::c_ulong;
177pub type __fsblkcnt64_t = libc::c_ulong;
178pub type __fsfilcnt_t = libc::c_ulong;
179pub type __fsfilcnt64_t = libc::c_ulong;
180pub type __fsword_t = libc::c_long;
181pub type __ssize_t = libc::c_long;
182pub type __syscall_slong_t = libc::c_long;
183pub type __syscall_ulong_t = libc::c_ulong;
184pub type __loff_t = __off64_t;
185pub type __caddr_t = *mut libc::c_char;
186pub type __intptr_t = libc::c_long;
187pub type __socklen_t = libc::c_uint;
188pub type __sig_atomic_t = libc::c_int;
189pub type time_t = __time_t;
190#[repr(C)]
191#[derive(Debug, Copy, Clone)]
192pub struct timeval {
193 pub tv_sec: __time_t,
194 pub tv_usec: __suseconds_t,
195}
196#[test]
197fn bindgen_test_layout_timeval() {
198 assert_eq!(
199 ::std::mem::size_of::<timeval>(),
200 16usize,
201 concat!("Size of: ", stringify!(timeval))
202 );
203 assert_eq!(
204 ::std::mem::align_of::<timeval>(),
205 8usize,
206 concat!("Alignment of ", stringify!(timeval))
207 );
208 assert_eq!(
209 unsafe { &(*(::std::ptr::null::<timeval>())).tv_sec as *const _ as usize },
210 0usize,
211 concat!(
212 "Offset of field: ",
213 stringify!(timeval),
214 "::",
215 stringify!(tv_sec)
216 )
217 );
218 assert_eq!(
219 unsafe { &(*(::std::ptr::null::<timeval>())).tv_usec as *const _ as usize },
220 8usize,
221 concat!(
222 "Offset of field: ",
223 stringify!(timeval),
224 "::",
225 stringify!(tv_usec)
226 )
227 );
228}
229pub type suseconds_t = __suseconds_t;
230#[repr(C)]
231#[derive(Debug, Copy, Clone)]
232pub struct __sigset_t {
233 pub __val: [libc::c_ulong; 16usize],
234}
235#[test]
236fn bindgen_test_layout___sigset_t() {
237 assert_eq!(
238 ::std::mem::size_of::<__sigset_t>(),
239 128usize,
240 concat!("Size of: ", stringify!(__sigset_t))
241 );
242 assert_eq!(
243 ::std::mem::align_of::<__sigset_t>(),
244 8usize,
245 concat!("Alignment of ", stringify!(__sigset_t))
246 );
247 assert_eq!(
248 unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
249 0usize,
250 concat!(
251 "Offset of field: ",
252 stringify!(__sigset_t),
253 "::",
254 stringify!(__val)
255 )
256 );
257}
258pub type sigset_t = __sigset_t;
259#[repr(C)]
260#[derive(Debug, Copy, Clone)]
261pub struct timespec {
262 pub tv_sec: __time_t,
263 pub tv_nsec: __syscall_slong_t,
264}
265#[test]
266fn bindgen_test_layout_timespec() {
267 assert_eq!(
268 ::std::mem::size_of::<timespec>(),
269 16usize,
270 concat!("Size of: ", stringify!(timespec))
271 );
272 assert_eq!(
273 ::std::mem::align_of::<timespec>(),
274 8usize,
275 concat!("Alignment of ", stringify!(timespec))
276 );
277 assert_eq!(
278 unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize },
279 0usize,
280 concat!(
281 "Offset of field: ",
282 stringify!(timespec),
283 "::",
284 stringify!(tv_sec)
285 )
286 );
287 assert_eq!(
288 unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
289 8usize,
290 concat!(
291 "Offset of field: ",
292 stringify!(timespec),
293 "::",
294 stringify!(tv_nsec)
295 )
296 );
297}
298pub type __fd_mask = libc::c_long;
299#[repr(C)]
300#[derive(Debug, Copy, Clone)]
301pub struct fd_set {
302 pub __fds_bits: [__fd_mask; 16usize],
303}
304#[test]
305fn bindgen_test_layout_fd_set() {
306 assert_eq!(
307 ::std::mem::size_of::<fd_set>(),
308 128usize,
309 concat!("Size of: ", stringify!(fd_set))
310 );
311 assert_eq!(
312 ::std::mem::align_of::<fd_set>(),
313 8usize,
314 concat!("Alignment of ", stringify!(fd_set))
315 );
316 assert_eq!(
317 unsafe { &(*(::std::ptr::null::<fd_set>())).__fds_bits as *const _ as usize },
318 0usize,
319 concat!(
320 "Offset of field: ",
321 stringify!(fd_set),
322 "::",
323 stringify!(__fds_bits)
324 )
325 );
326}
327pub type fd_mask = __fd_mask;
328extern "C" {
329 pub fn select(
330 __nfds: libc::c_int,
331 __readfds: *mut fd_set,
332 __writefds: *mut fd_set,
333 __exceptfds: *mut fd_set,
334 __timeout: *mut timeval,
335 ) -> libc::c_int;
336}
337extern "C" {
338 pub fn pselect(
339 __nfds: libc::c_int,
340 __readfds: *mut fd_set,
341 __writefds: *mut fd_set,
342 __exceptfds: *mut fd_set,
343 __timeout: *const timespec,
344 __sigmask: *const __sigset_t,
345 ) -> libc::c_int;
346}
347#[repr(C)]
348#[derive(Debug, Copy, Clone)]
349pub struct timezone {
350 pub tz_minuteswest: libc::c_int,
351 pub tz_dsttime: libc::c_int,
352}
353#[test]
354fn bindgen_test_layout_timezone() {
355 assert_eq!(
356 ::std::mem::size_of::<timezone>(),
357 8usize,
358 concat!("Size of: ", stringify!(timezone))
359 );
360 assert_eq!(
361 ::std::mem::align_of::<timezone>(),
362 4usize,
363 concat!("Alignment of ", stringify!(timezone))
364 );
365 assert_eq!(
366 unsafe { &(*(::std::ptr::null::<timezone>())).tz_minuteswest as *const _ as usize },
367 0usize,
368 concat!(
369 "Offset of field: ",
370 stringify!(timezone),
371 "::",
372 stringify!(tz_minuteswest)
373 )
374 );
375 assert_eq!(
376 unsafe { &(*(::std::ptr::null::<timezone>())).tz_dsttime as *const _ as usize },
377 4usize,
378 concat!(
379 "Offset of field: ",
380 stringify!(timezone),
381 "::",
382 stringify!(tz_dsttime)
383 )
384 );
385}
386pub type __timezone_ptr_t = *mut timezone;
387extern "C" {
388 pub fn gettimeofday(__tv: *mut timeval, __tz: __timezone_ptr_t) -> libc::c_int;
389}
390extern "C" {
391 pub fn settimeofday(__tv: *const timeval, __tz: *const timezone) -> libc::c_int;
392}
393extern "C" {
394 pub fn adjtime(__delta: *const timeval, __olddelta: *mut timeval) -> libc::c_int;
395}
396pub const __itimer_which_ITIMER_REAL: __itimer_which = 0;
397pub const __itimer_which_ITIMER_VIRTUAL: __itimer_which = 1;
398pub const __itimer_which_ITIMER_PROF: __itimer_which = 2;
399pub type __itimer_which = u32;
400#[repr(C)]
401#[derive(Debug, Copy, Clone)]
402pub struct itimerval {
403 pub it_interval: timeval,
404 pub it_value: timeval,
405}
406#[test]
407fn bindgen_test_layout_itimerval() {
408 assert_eq!(
409 ::std::mem::size_of::<itimerval>(),
410 32usize,
411 concat!("Size of: ", stringify!(itimerval))
412 );
413 assert_eq!(
414 ::std::mem::align_of::<itimerval>(),
415 8usize,
416 concat!("Alignment of ", stringify!(itimerval))
417 );
418 assert_eq!(
419 unsafe { &(*(::std::ptr::null::<itimerval>())).it_interval as *const _ as usize },
420 0usize,
421 concat!(
422 "Offset of field: ",
423 stringify!(itimerval),
424 "::",
425 stringify!(it_interval)
426 )
427 );
428 assert_eq!(
429 unsafe { &(*(::std::ptr::null::<itimerval>())).it_value as *const _ as usize },
430 16usize,
431 concat!(
432 "Offset of field: ",
433 stringify!(itimerval),
434 "::",
435 stringify!(it_value)
436 )
437 );
438}
439pub type __itimer_which_t = libc::c_int;
440extern "C" {
441 pub fn getitimer(__which: __itimer_which_t, __value: *mut itimerval) -> libc::c_int;
442}
443extern "C" {
444 pub fn setitimer(
445 __which: __itimer_which_t,
446 __new: *const itimerval,
447 __old: *mut itimerval,
448 ) -> libc::c_int;
449}
450extern "C" {
451 pub fn utimes(__file: *const libc::c_char, __tvp: *const timeval) -> libc::c_int;
452}
453extern "C" {
454 pub fn lutimes(__file: *const libc::c_char, __tvp: *const timeval) -> libc::c_int;
455}
456extern "C" {
457 pub fn futimes(__fd: libc::c_int, __tvp: *const timeval) -> libc::c_int;
458}
459pub type int_least8_t = __int_least8_t;
460pub type int_least16_t = __int_least16_t;
461pub type int_least32_t = __int_least32_t;
462pub type int_least64_t = __int_least64_t;
463pub type uint_least8_t = __uint_least8_t;
464pub type uint_least16_t = __uint_least16_t;
465pub type uint_least32_t = __uint_least32_t;
466pub type uint_least64_t = __uint_least64_t;
467pub type int_fast8_t = libc::c_schar;
468pub type int_fast16_t = libc::c_long;
469pub type int_fast32_t = libc::c_long;
470pub type int_fast64_t = libc::c_long;
471pub type uint_fast8_t = libc::c_uchar;
472pub type uint_fast16_t = libc::c_ulong;
473pub type uint_fast32_t = libc::c_ulong;
474pub type uint_fast64_t = libc::c_ulong;
475pub type intmax_t = __intmax_t;
476pub type uintmax_t = __uintmax_t;
477pub type TangoDevLong = i32;
478pub type TangoDevULong = u32;
479pub type TangoDevLong64 = i64;
480pub type TangoDevULong64 = u64;
481pub const TangoDataType_DEV_VOID: TangoDataType = 0;
482pub const TangoDataType_DEV_BOOLEAN: TangoDataType = 1;
483pub const TangoDataType_DEV_SHORT: TangoDataType = 2;
484pub const TangoDataType_DEV_LONG: TangoDataType = 3;
485pub const TangoDataType_DEV_FLOAT: TangoDataType = 4;
486pub const TangoDataType_DEV_DOUBLE: TangoDataType = 5;
487pub const TangoDataType_DEV_USHORT: TangoDataType = 6;
488pub const TangoDataType_DEV_ULONG: TangoDataType = 7;
489pub const TangoDataType_DEV_STRING: TangoDataType = 8;
490pub const TangoDataType_DEVVAR_CHARARRAY: TangoDataType = 9;
491pub const TangoDataType_DEVVAR_SHORTARRAY: TangoDataType = 10;
492pub const TangoDataType_DEVVAR_LONGARRAY: TangoDataType = 11;
493pub const TangoDataType_DEVVAR_FLOATARRAY: TangoDataType = 12;
494pub const TangoDataType_DEVVAR_DOUBLEARRAY: TangoDataType = 13;
495pub const TangoDataType_DEVVAR_USHORTARRAY: TangoDataType = 14;
496pub const TangoDataType_DEVVAR_ULONGARRAY: TangoDataType = 15;
497pub const TangoDataType_DEVVAR_STRINGARRAY: TangoDataType = 16;
498pub const TangoDataType_DEVVAR_LONGSTRINGARRAY: TangoDataType = 17;
499pub const TangoDataType_DEVVAR_DOUBLESTRINGARRAY: TangoDataType = 18;
500pub const TangoDataType_DEV_STATE: TangoDataType = 19;
501pub const TangoDataType_CONST_DEV_STRING: TangoDataType = 20;
502pub const TangoDataType_DEVVAR_BOOLEANARRAY: TangoDataType = 21;
503pub const TangoDataType_DEV_UCHAR: TangoDataType = 22;
504pub const TangoDataType_DEV_LONG64: TangoDataType = 23;
505pub const TangoDataType_DEV_ULONG64: TangoDataType = 24;
506pub const TangoDataType_DEVVAR_LONG64ARRAY: TangoDataType = 25;
507pub const TangoDataType_DEVVAR_ULONG64ARRAY: TangoDataType = 26;
508pub const TangoDataType_DEV_INT: TangoDataType = 27;
509pub const TangoDataType_DEV_ENCODED: TangoDataType = 28;
510pub type TangoDataType = u32;
511pub const TangoDevState_ON: TangoDevState = 0;
512pub const TangoDevState_OFF: TangoDevState = 1;
513pub const TangoDevState_CLOSE: TangoDevState = 2;
514pub const TangoDevState_OPEN: TangoDevState = 3;
515pub const TangoDevState_INSERT: TangoDevState = 4;
516pub const TangoDevState_EXTRACT: TangoDevState = 5;
517pub const TangoDevState_MOVING: TangoDevState = 6;
518pub const TangoDevState_STANDBY: TangoDevState = 7;
519pub const TangoDevState_FAULT: TangoDevState = 8;
520pub const TangoDevState_INIT: TangoDevState = 9;
521pub const TangoDevState_RUNNING: TangoDevState = 10;
522pub const TangoDevState_ALARM: TangoDevState = 11;
523pub const TangoDevState_DISABLE: TangoDevState = 12;
524pub const TangoDevState_UNKNOWN: TangoDevState = 13;
525pub type TangoDevState = u32;
526pub const AttrQuality_ATTR_VALID: AttrQuality = 0;
527pub const AttrQuality_ATTR_INVALID: AttrQuality = 1;
528pub const AttrQuality_ATTR_ALARM: AttrQuality = 2;
529pub const AttrQuality_ATTR_CHANGING: AttrQuality = 3;
530pub const AttrQuality_ATTR_WARNING: AttrQuality = 4;
531pub type AttrQuality = u32;
532pub const AttrWriteType_READ: AttrWriteType = 0;
533pub const AttrWriteType_READ_WITH_WRITE: AttrWriteType = 1;
534pub const AttrWriteType_WRITE: AttrWriteType = 2;
535pub const AttrWriteType_READ_WRITE: AttrWriteType = 3;
536pub type AttrWriteType = u32;
537pub const AttrDataFormat_SCALAR: AttrDataFormat = 0;
538pub const AttrDataFormat_SPECTRUM: AttrDataFormat = 1;
539pub const AttrDataFormat_IMAGE: AttrDataFormat = 2;
540pub type AttrDataFormat = u32;
541pub const DispLevel_OPERATOR: DispLevel = 0;
542pub const DispLevel_EXPERT: DispLevel = 1;
543pub type DispLevel = u32;
544pub const ErrSeverity_WARN: ErrSeverity = 0;
545pub const ErrSeverity_ERR: ErrSeverity = 1;
546pub const ErrSeverity_PANIC: ErrSeverity = 2;
547pub type ErrSeverity = u32;
548pub const DevSource_DEV: DevSource = 0;
549pub const DevSource_CACHE: DevSource = 1;
550pub const DevSource_CACHE_DEV: DevSource = 2;
551pub type DevSource = u32;
552#[repr(C)]
553#[derive(Debug, Copy, Clone)]
554pub struct TangoDevEncoded {
555 pub encoded_format: *mut libc::c_char,
556 pub encoded_length: u32,
557 pub encoded_data: *mut u8,
558}
559#[test]
560fn bindgen_test_layout_TangoDevEncoded() {
561 assert_eq!(
562 ::std::mem::size_of::<TangoDevEncoded>(),
563 24usize,
564 concat!("Size of: ", stringify!(TangoDevEncoded))
565 );
566 assert_eq!(
567 ::std::mem::align_of::<TangoDevEncoded>(),
568 8usize,
569 concat!("Alignment of ", stringify!(TangoDevEncoded))
570 );
571 assert_eq!(
572 unsafe { &(*(::std::ptr::null::<TangoDevEncoded>())).encoded_format as *const _ as usize },
573 0usize,
574 concat!(
575 "Offset of field: ",
576 stringify!(TangoDevEncoded),
577 "::",
578 stringify!(encoded_format)
579 )
580 );
581 assert_eq!(
582 unsafe { &(*(::std::ptr::null::<TangoDevEncoded>())).encoded_length as *const _ as usize },
583 8usize,
584 concat!(
585 "Offset of field: ",
586 stringify!(TangoDevEncoded),
587 "::",
588 stringify!(encoded_length)
589 )
590 );
591 assert_eq!(
592 unsafe { &(*(::std::ptr::null::<TangoDevEncoded>())).encoded_data as *const _ as usize },
593 16usize,
594 concat!(
595 "Offset of field: ",
596 stringify!(TangoDevEncoded),
597 "::",
598 stringify!(encoded_data)
599 )
600 );
601}
602#[repr(C)]
603#[derive(Debug, Copy, Clone)]
604pub struct VarBoolArray {
605 pub length: u32,
606 pub sequence: *mut bool,
607}
608#[test]
609fn bindgen_test_layout_VarBoolArray() {
610 assert_eq!(
611 ::std::mem::size_of::<VarBoolArray>(),
612 16usize,
613 concat!("Size of: ", stringify!(VarBoolArray))
614 );
615 assert_eq!(
616 ::std::mem::align_of::<VarBoolArray>(),
617 8usize,
618 concat!("Alignment of ", stringify!(VarBoolArray))
619 );
620 assert_eq!(
621 unsafe { &(*(::std::ptr::null::<VarBoolArray>())).length as *const _ as usize },
622 0usize,
623 concat!(
624 "Offset of field: ",
625 stringify!(VarBoolArray),
626 "::",
627 stringify!(length)
628 )
629 );
630 assert_eq!(
631 unsafe { &(*(::std::ptr::null::<VarBoolArray>())).sequence as *const _ as usize },
632 8usize,
633 concat!(
634 "Offset of field: ",
635 stringify!(VarBoolArray),
636 "::",
637 stringify!(sequence)
638 )
639 );
640}
641#[repr(C)]
642#[derive(Debug, Copy, Clone)]
643pub struct VarCharArray {
644 pub length: u32,
645 pub sequence: *mut u8,
646}
647#[test]
648fn bindgen_test_layout_VarCharArray() {
649 assert_eq!(
650 ::std::mem::size_of::<VarCharArray>(),
651 16usize,
652 concat!("Size of: ", stringify!(VarCharArray))
653 );
654 assert_eq!(
655 ::std::mem::align_of::<VarCharArray>(),
656 8usize,
657 concat!("Alignment of ", stringify!(VarCharArray))
658 );
659 assert_eq!(
660 unsafe { &(*(::std::ptr::null::<VarCharArray>())).length as *const _ as usize },
661 0usize,
662 concat!(
663 "Offset of field: ",
664 stringify!(VarCharArray),
665 "::",
666 stringify!(length)
667 )
668 );
669 assert_eq!(
670 unsafe { &(*(::std::ptr::null::<VarCharArray>())).sequence as *const _ as usize },
671 8usize,
672 concat!(
673 "Offset of field: ",
674 stringify!(VarCharArray),
675 "::",
676 stringify!(sequence)
677 )
678 );
679}
680#[repr(C)]
681#[derive(Debug, Copy, Clone)]
682pub struct VarShortArray {
683 pub length: u32,
684 pub sequence: *mut i16,
685}
686#[test]
687fn bindgen_test_layout_VarShortArray() {
688 assert_eq!(
689 ::std::mem::size_of::<VarShortArray>(),
690 16usize,
691 concat!("Size of: ", stringify!(VarShortArray))
692 );
693 assert_eq!(
694 ::std::mem::align_of::<VarShortArray>(),
695 8usize,
696 concat!("Alignment of ", stringify!(VarShortArray))
697 );
698 assert_eq!(
699 unsafe { &(*(::std::ptr::null::<VarShortArray>())).length as *const _ as usize },
700 0usize,
701 concat!(
702 "Offset of field: ",
703 stringify!(VarShortArray),
704 "::",
705 stringify!(length)
706 )
707 );
708 assert_eq!(
709 unsafe { &(*(::std::ptr::null::<VarShortArray>())).sequence as *const _ as usize },
710 8usize,
711 concat!(
712 "Offset of field: ",
713 stringify!(VarShortArray),
714 "::",
715 stringify!(sequence)
716 )
717 );
718}
719#[repr(C)]
720#[derive(Debug, Copy, Clone)]
721pub struct VarUShortArray {
722 pub length: u32,
723 pub sequence: *mut u16,
724}
725#[test]
726fn bindgen_test_layout_VarUShortArray() {
727 assert_eq!(
728 ::std::mem::size_of::<VarUShortArray>(),
729 16usize,
730 concat!("Size of: ", stringify!(VarUShortArray))
731 );
732 assert_eq!(
733 ::std::mem::align_of::<VarUShortArray>(),
734 8usize,
735 concat!("Alignment of ", stringify!(VarUShortArray))
736 );
737 assert_eq!(
738 unsafe { &(*(::std::ptr::null::<VarUShortArray>())).length as *const _ as usize },
739 0usize,
740 concat!(
741 "Offset of field: ",
742 stringify!(VarUShortArray),
743 "::",
744 stringify!(length)
745 )
746 );
747 assert_eq!(
748 unsafe { &(*(::std::ptr::null::<VarUShortArray>())).sequence as *const _ as usize },
749 8usize,
750 concat!(
751 "Offset of field: ",
752 stringify!(VarUShortArray),
753 "::",
754 stringify!(sequence)
755 )
756 );
757}
758#[repr(C)]
759#[derive(Debug, Copy, Clone)]
760pub struct VarLongArray {
761 pub length: u32,
762 pub sequence: *mut TangoDevLong,
763}
764#[test]
765fn bindgen_test_layout_VarLongArray() {
766 assert_eq!(
767 ::std::mem::size_of::<VarLongArray>(),
768 16usize,
769 concat!("Size of: ", stringify!(VarLongArray))
770 );
771 assert_eq!(
772 ::std::mem::align_of::<VarLongArray>(),
773 8usize,
774 concat!("Alignment of ", stringify!(VarLongArray))
775 );
776 assert_eq!(
777 unsafe { &(*(::std::ptr::null::<VarLongArray>())).length as *const _ as usize },
778 0usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(VarLongArray),
782 "::",
783 stringify!(length)
784 )
785 );
786 assert_eq!(
787 unsafe { &(*(::std::ptr::null::<VarLongArray>())).sequence as *const _ as usize },
788 8usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(VarLongArray),
792 "::",
793 stringify!(sequence)
794 )
795 );
796}
797#[repr(C)]
798#[derive(Debug, Copy, Clone)]
799pub struct VarULongArray {
800 pub length: u32,
801 pub sequence: *mut TangoDevULong,
802}
803#[test]
804fn bindgen_test_layout_VarULongArray() {
805 assert_eq!(
806 ::std::mem::size_of::<VarULongArray>(),
807 16usize,
808 concat!("Size of: ", stringify!(VarULongArray))
809 );
810 assert_eq!(
811 ::std::mem::align_of::<VarULongArray>(),
812 8usize,
813 concat!("Alignment of ", stringify!(VarULongArray))
814 );
815 assert_eq!(
816 unsafe { &(*(::std::ptr::null::<VarULongArray>())).length as *const _ as usize },
817 0usize,
818 concat!(
819 "Offset of field: ",
820 stringify!(VarULongArray),
821 "::",
822 stringify!(length)
823 )
824 );
825 assert_eq!(
826 unsafe { &(*(::std::ptr::null::<VarULongArray>())).sequence as *const _ as usize },
827 8usize,
828 concat!(
829 "Offset of field: ",
830 stringify!(VarULongArray),
831 "::",
832 stringify!(sequence)
833 )
834 );
835}
836#[repr(C)]
837#[derive(Debug, Copy, Clone)]
838pub struct VarLong64Array {
839 pub length: u32,
840 pub sequence: *mut TangoDevLong64,
841}
842#[test]
843fn bindgen_test_layout_VarLong64Array() {
844 assert_eq!(
845 ::std::mem::size_of::<VarLong64Array>(),
846 16usize,
847 concat!("Size of: ", stringify!(VarLong64Array))
848 );
849 assert_eq!(
850 ::std::mem::align_of::<VarLong64Array>(),
851 8usize,
852 concat!("Alignment of ", stringify!(VarLong64Array))
853 );
854 assert_eq!(
855 unsafe { &(*(::std::ptr::null::<VarLong64Array>())).length as *const _ as usize },
856 0usize,
857 concat!(
858 "Offset of field: ",
859 stringify!(VarLong64Array),
860 "::",
861 stringify!(length)
862 )
863 );
864 assert_eq!(
865 unsafe { &(*(::std::ptr::null::<VarLong64Array>())).sequence as *const _ as usize },
866 8usize,
867 concat!(
868 "Offset of field: ",
869 stringify!(VarLong64Array),
870 "::",
871 stringify!(sequence)
872 )
873 );
874}
875#[repr(C)]
876#[derive(Debug, Copy, Clone)]
877pub struct VarULong64Array {
878 pub length: u32,
879 pub sequence: *mut TangoDevULong64,
880}
881#[test]
882fn bindgen_test_layout_VarULong64Array() {
883 assert_eq!(
884 ::std::mem::size_of::<VarULong64Array>(),
885 16usize,
886 concat!("Size of: ", stringify!(VarULong64Array))
887 );
888 assert_eq!(
889 ::std::mem::align_of::<VarULong64Array>(),
890 8usize,
891 concat!("Alignment of ", stringify!(VarULong64Array))
892 );
893 assert_eq!(
894 unsafe { &(*(::std::ptr::null::<VarULong64Array>())).length as *const _ as usize },
895 0usize,
896 concat!(
897 "Offset of field: ",
898 stringify!(VarULong64Array),
899 "::",
900 stringify!(length)
901 )
902 );
903 assert_eq!(
904 unsafe { &(*(::std::ptr::null::<VarULong64Array>())).sequence as *const _ as usize },
905 8usize,
906 concat!(
907 "Offset of field: ",
908 stringify!(VarULong64Array),
909 "::",
910 stringify!(sequence)
911 )
912 );
913}
914#[repr(C)]
915#[derive(Debug, Copy, Clone)]
916pub struct VarFloatArray {
917 pub length: u32,
918 pub sequence: *mut f32,
919}
920#[test]
921fn bindgen_test_layout_VarFloatArray() {
922 assert_eq!(
923 ::std::mem::size_of::<VarFloatArray>(),
924 16usize,
925 concat!("Size of: ", stringify!(VarFloatArray))
926 );
927 assert_eq!(
928 ::std::mem::align_of::<VarFloatArray>(),
929 8usize,
930 concat!("Alignment of ", stringify!(VarFloatArray))
931 );
932 assert_eq!(
933 unsafe { &(*(::std::ptr::null::<VarFloatArray>())).length as *const _ as usize },
934 0usize,
935 concat!(
936 "Offset of field: ",
937 stringify!(VarFloatArray),
938 "::",
939 stringify!(length)
940 )
941 );
942 assert_eq!(
943 unsafe { &(*(::std::ptr::null::<VarFloatArray>())).sequence as *const _ as usize },
944 8usize,
945 concat!(
946 "Offset of field: ",
947 stringify!(VarFloatArray),
948 "::",
949 stringify!(sequence)
950 )
951 );
952}
953#[repr(C)]
954#[derive(Debug, Copy, Clone)]
955pub struct VarDoubleArray {
956 pub length: u32,
957 pub sequence: *mut f64,
958}
959#[test]
960fn bindgen_test_layout_VarDoubleArray() {
961 assert_eq!(
962 ::std::mem::size_of::<VarDoubleArray>(),
963 16usize,
964 concat!("Size of: ", stringify!(VarDoubleArray))
965 );
966 assert_eq!(
967 ::std::mem::align_of::<VarDoubleArray>(),
968 8usize,
969 concat!("Alignment of ", stringify!(VarDoubleArray))
970 );
971 assert_eq!(
972 unsafe { &(*(::std::ptr::null::<VarDoubleArray>())).length as *const _ as usize },
973 0usize,
974 concat!(
975 "Offset of field: ",
976 stringify!(VarDoubleArray),
977 "::",
978 stringify!(length)
979 )
980 );
981 assert_eq!(
982 unsafe { &(*(::std::ptr::null::<VarDoubleArray>())).sequence as *const _ as usize },
983 8usize,
984 concat!(
985 "Offset of field: ",
986 stringify!(VarDoubleArray),
987 "::",
988 stringify!(sequence)
989 )
990 );
991}
992#[repr(C)]
993#[derive(Debug, Copy, Clone)]
994pub struct VarStringArray {
995 pub length: u32,
996 pub sequence: *mut *mut libc::c_char,
997}
998#[test]
999fn bindgen_test_layout_VarStringArray() {
1000 assert_eq!(
1001 ::std::mem::size_of::<VarStringArray>(),
1002 16usize,
1003 concat!("Size of: ", stringify!(VarStringArray))
1004 );
1005 assert_eq!(
1006 ::std::mem::align_of::<VarStringArray>(),
1007 8usize,
1008 concat!("Alignment of ", stringify!(VarStringArray))
1009 );
1010 assert_eq!(
1011 unsafe { &(*(::std::ptr::null::<VarStringArray>())).length as *const _ as usize },
1012 0usize,
1013 concat!(
1014 "Offset of field: ",
1015 stringify!(VarStringArray),
1016 "::",
1017 stringify!(length)
1018 )
1019 );
1020 assert_eq!(
1021 unsafe { &(*(::std::ptr::null::<VarStringArray>())).sequence as *const _ as usize },
1022 8usize,
1023 concat!(
1024 "Offset of field: ",
1025 stringify!(VarStringArray),
1026 "::",
1027 stringify!(sequence)
1028 )
1029 );
1030}
1031#[repr(C)]
1032#[derive(Debug, Copy, Clone)]
1033pub struct VarStateArray {
1034 pub length: u32,
1035 pub sequence: *mut TangoDevState,
1036}
1037#[test]
1038fn bindgen_test_layout_VarStateArray() {
1039 assert_eq!(
1040 ::std::mem::size_of::<VarStateArray>(),
1041 16usize,
1042 concat!("Size of: ", stringify!(VarStateArray))
1043 );
1044 assert_eq!(
1045 ::std::mem::align_of::<VarStateArray>(),
1046 8usize,
1047 concat!("Alignment of ", stringify!(VarStateArray))
1048 );
1049 assert_eq!(
1050 unsafe { &(*(::std::ptr::null::<VarStateArray>())).length as *const _ as usize },
1051 0usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(VarStateArray),
1055 "::",
1056 stringify!(length)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { &(*(::std::ptr::null::<VarStateArray>())).sequence as *const _ as usize },
1061 8usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(VarStateArray),
1065 "::",
1066 stringify!(sequence)
1067 )
1068 );
1069}
1070#[repr(C)]
1071#[derive(Debug, Copy, Clone)]
1072pub struct VarEncodedArray {
1073 pub length: u32,
1074 pub sequence: *mut TangoDevEncoded,
1075}
1076#[test]
1077fn bindgen_test_layout_VarEncodedArray() {
1078 assert_eq!(
1079 ::std::mem::size_of::<VarEncodedArray>(),
1080 16usize,
1081 concat!("Size of: ", stringify!(VarEncodedArray))
1082 );
1083 assert_eq!(
1084 ::std::mem::align_of::<VarEncodedArray>(),
1085 8usize,
1086 concat!("Alignment of ", stringify!(VarEncodedArray))
1087 );
1088 assert_eq!(
1089 unsafe { &(*(::std::ptr::null::<VarEncodedArray>())).length as *const _ as usize },
1090 0usize,
1091 concat!(
1092 "Offset of field: ",
1093 stringify!(VarEncodedArray),
1094 "::",
1095 stringify!(length)
1096 )
1097 );
1098 assert_eq!(
1099 unsafe { &(*(::std::ptr::null::<VarEncodedArray>())).sequence as *const _ as usize },
1100 8usize,
1101 concat!(
1102 "Offset of field: ",
1103 stringify!(VarEncodedArray),
1104 "::",
1105 stringify!(sequence)
1106 )
1107 );
1108}
1109#[repr(C)]
1110#[derive(Debug, Copy, Clone)]
1111pub struct VarLongStringArray {
1112 pub long_length: u32,
1113 pub long_sequence: *mut TangoDevLong,
1114 pub string_length: u32,
1115 pub string_sequence: *mut *mut libc::c_char,
1116}
1117#[test]
1118fn bindgen_test_layout_VarLongStringArray() {
1119 assert_eq!(
1120 ::std::mem::size_of::<VarLongStringArray>(),
1121 32usize,
1122 concat!("Size of: ", stringify!(VarLongStringArray))
1123 );
1124 assert_eq!(
1125 ::std::mem::align_of::<VarLongStringArray>(),
1126 8usize,
1127 concat!("Alignment of ", stringify!(VarLongStringArray))
1128 );
1129 assert_eq!(
1130 unsafe { &(*(::std::ptr::null::<VarLongStringArray>())).long_length as *const _ as usize },
1131 0usize,
1132 concat!(
1133 "Offset of field: ",
1134 stringify!(VarLongStringArray),
1135 "::",
1136 stringify!(long_length)
1137 )
1138 );
1139 assert_eq!(
1140 unsafe {
1141 &(*(::std::ptr::null::<VarLongStringArray>())).long_sequence as *const _ as usize
1142 },
1143 8usize,
1144 concat!(
1145 "Offset of field: ",
1146 stringify!(VarLongStringArray),
1147 "::",
1148 stringify!(long_sequence)
1149 )
1150 );
1151 assert_eq!(
1152 unsafe {
1153 &(*(::std::ptr::null::<VarLongStringArray>())).string_length as *const _ as usize
1154 },
1155 16usize,
1156 concat!(
1157 "Offset of field: ",
1158 stringify!(VarLongStringArray),
1159 "::",
1160 stringify!(string_length)
1161 )
1162 );
1163 assert_eq!(
1164 unsafe {
1165 &(*(::std::ptr::null::<VarLongStringArray>())).string_sequence as *const _ as usize
1166 },
1167 24usize,
1168 concat!(
1169 "Offset of field: ",
1170 stringify!(VarLongStringArray),
1171 "::",
1172 stringify!(string_sequence)
1173 )
1174 );
1175}
1176#[repr(C)]
1177#[derive(Debug, Copy, Clone)]
1178pub struct VarDoubleStringArray {
1179 pub double_length: u32,
1180 pub double_sequence: *mut f64,
1181 pub string_length: u32,
1182 pub string_sequence: *mut *mut libc::c_char,
1183}
1184#[test]
1185fn bindgen_test_layout_VarDoubleStringArray() {
1186 assert_eq!(
1187 ::std::mem::size_of::<VarDoubleStringArray>(),
1188 32usize,
1189 concat!("Size of: ", stringify!(VarDoubleStringArray))
1190 );
1191 assert_eq!(
1192 ::std::mem::align_of::<VarDoubleStringArray>(),
1193 8usize,
1194 concat!("Alignment of ", stringify!(VarDoubleStringArray))
1195 );
1196 assert_eq!(
1197 unsafe {
1198 &(*(::std::ptr::null::<VarDoubleStringArray>())).double_length as *const _ as usize
1199 },
1200 0usize,
1201 concat!(
1202 "Offset of field: ",
1203 stringify!(VarDoubleStringArray),
1204 "::",
1205 stringify!(double_length)
1206 )
1207 );
1208 assert_eq!(
1209 unsafe {
1210 &(*(::std::ptr::null::<VarDoubleStringArray>())).double_sequence as *const _ as usize
1211 },
1212 8usize,
1213 concat!(
1214 "Offset of field: ",
1215 stringify!(VarDoubleStringArray),
1216 "::",
1217 stringify!(double_sequence)
1218 )
1219 );
1220 assert_eq!(
1221 unsafe {
1222 &(*(::std::ptr::null::<VarDoubleStringArray>())).string_length as *const _ as usize
1223 },
1224 16usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(VarDoubleStringArray),
1228 "::",
1229 stringify!(string_length)
1230 )
1231 );
1232 assert_eq!(
1233 unsafe {
1234 &(*(::std::ptr::null::<VarDoubleStringArray>())).string_sequence as *const _ as usize
1235 },
1236 24usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(VarDoubleStringArray),
1240 "::",
1241 stringify!(string_sequence)
1242 )
1243 );
1244}
1245#[repr(C)]
1246#[derive(Copy, Clone)]
1247pub union TangoAttributeData {
1248 pub bool_arr: VarBoolArray,
1249 pub char_arr: VarCharArray,
1250 pub short_arr: VarShortArray,
1251 pub ushort_arr: VarUShortArray,
1252 pub long_arr: VarLongArray,
1253 pub ulong_arr: VarULongArray,
1254 pub long64_arr: VarLong64Array,
1255 pub ulong64_arr: VarULong64Array,
1256 pub float_arr: VarFloatArray,
1257 pub double_arr: VarDoubleArray,
1258 pub string_arr: VarStringArray,
1259 pub state_arr: VarStateArray,
1260 pub encoded_arr: VarEncodedArray,
1261 _bindgen_union_align: [u64; 2usize],
1262}
1263#[test]
1264fn bindgen_test_layout_TangoAttributeData() {
1265 assert_eq!(
1266 ::std::mem::size_of::<TangoAttributeData>(),
1267 16usize,
1268 concat!("Size of: ", stringify!(TangoAttributeData))
1269 );
1270 assert_eq!(
1271 ::std::mem::align_of::<TangoAttributeData>(),
1272 8usize,
1273 concat!("Alignment of ", stringify!(TangoAttributeData))
1274 );
1275 assert_eq!(
1276 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).bool_arr as *const _ as usize },
1277 0usize,
1278 concat!(
1279 "Offset of field: ",
1280 stringify!(TangoAttributeData),
1281 "::",
1282 stringify!(bool_arr)
1283 )
1284 );
1285 assert_eq!(
1286 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).char_arr as *const _ as usize },
1287 0usize,
1288 concat!(
1289 "Offset of field: ",
1290 stringify!(TangoAttributeData),
1291 "::",
1292 stringify!(char_arr)
1293 )
1294 );
1295 assert_eq!(
1296 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).short_arr as *const _ as usize },
1297 0usize,
1298 concat!(
1299 "Offset of field: ",
1300 stringify!(TangoAttributeData),
1301 "::",
1302 stringify!(short_arr)
1303 )
1304 );
1305 assert_eq!(
1306 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).ushort_arr as *const _ as usize },
1307 0usize,
1308 concat!(
1309 "Offset of field: ",
1310 stringify!(TangoAttributeData),
1311 "::",
1312 stringify!(ushort_arr)
1313 )
1314 );
1315 assert_eq!(
1316 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).long_arr as *const _ as usize },
1317 0usize,
1318 concat!(
1319 "Offset of field: ",
1320 stringify!(TangoAttributeData),
1321 "::",
1322 stringify!(long_arr)
1323 )
1324 );
1325 assert_eq!(
1326 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).ulong_arr as *const _ as usize },
1327 0usize,
1328 concat!(
1329 "Offset of field: ",
1330 stringify!(TangoAttributeData),
1331 "::",
1332 stringify!(ulong_arr)
1333 )
1334 );
1335 assert_eq!(
1336 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).long64_arr as *const _ as usize },
1337 0usize,
1338 concat!(
1339 "Offset of field: ",
1340 stringify!(TangoAttributeData),
1341 "::",
1342 stringify!(long64_arr)
1343 )
1344 );
1345 assert_eq!(
1346 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).ulong64_arr as *const _ as usize },
1347 0usize,
1348 concat!(
1349 "Offset of field: ",
1350 stringify!(TangoAttributeData),
1351 "::",
1352 stringify!(ulong64_arr)
1353 )
1354 );
1355 assert_eq!(
1356 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).float_arr as *const _ as usize },
1357 0usize,
1358 concat!(
1359 "Offset of field: ",
1360 stringify!(TangoAttributeData),
1361 "::",
1362 stringify!(float_arr)
1363 )
1364 );
1365 assert_eq!(
1366 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).double_arr as *const _ as usize },
1367 0usize,
1368 concat!(
1369 "Offset of field: ",
1370 stringify!(TangoAttributeData),
1371 "::",
1372 stringify!(double_arr)
1373 )
1374 );
1375 assert_eq!(
1376 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).string_arr as *const _ as usize },
1377 0usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(TangoAttributeData),
1381 "::",
1382 stringify!(string_arr)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).state_arr as *const _ as usize },
1387 0usize,
1388 concat!(
1389 "Offset of field: ",
1390 stringify!(TangoAttributeData),
1391 "::",
1392 stringify!(state_arr)
1393 )
1394 );
1395 assert_eq!(
1396 unsafe { &(*(::std::ptr::null::<TangoAttributeData>())).encoded_arr as *const _ as usize },
1397 0usize,
1398 concat!(
1399 "Offset of field: ",
1400 stringify!(TangoAttributeData),
1401 "::",
1402 stringify!(encoded_arr)
1403 )
1404 );
1405}
1406#[repr(C)]
1407#[derive(Copy, Clone)]
1408pub union TangoCommandData {
1409 pub bool_val: bool,
1410 pub short_val: i16,
1411 pub ushort_val: u16,
1412 pub long_val: i32,
1413 pub ulong_val: u32,
1414 pub float_val: f32,
1415 pub double_val: f64,
1416 pub string_val: *mut libc::c_char,
1417 pub state_val: TangoDevState,
1418 pub long64_val: TangoDevLong64,
1419 pub ulong64_val: TangoDevULong64,
1420 pub bool_arr: VarBoolArray,
1421 pub char_arr: VarCharArray,
1422 pub short_arr: VarShortArray,
1423 pub ushort_arr: VarUShortArray,
1424 pub long_arr: VarLongArray,
1425 pub ulong_arr: VarULongArray,
1426 pub long64_arr: VarLong64Array,
1427 pub ulong64_arr: VarULong64Array,
1428 pub float_arr: VarFloatArray,
1429 pub double_arr: VarDoubleArray,
1430 pub string_arr: VarStringArray,
1431 pub state_arr: VarStateArray,
1432 pub encoded_val: TangoDevEncoded,
1433 pub long_string_arr: VarLongStringArray,
1434 pub double_string_arr: VarDoubleStringArray,
1435 _bindgen_union_align: [u64; 4usize],
1436}
1437#[test]
1438fn bindgen_test_layout_TangoCommandData() {
1439 assert_eq!(
1440 ::std::mem::size_of::<TangoCommandData>(),
1441 32usize,
1442 concat!("Size of: ", stringify!(TangoCommandData))
1443 );
1444 assert_eq!(
1445 ::std::mem::align_of::<TangoCommandData>(),
1446 8usize,
1447 concat!("Alignment of ", stringify!(TangoCommandData))
1448 );
1449 assert_eq!(
1450 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).bool_val as *const _ as usize },
1451 0usize,
1452 concat!(
1453 "Offset of field: ",
1454 stringify!(TangoCommandData),
1455 "::",
1456 stringify!(bool_val)
1457 )
1458 );
1459 assert_eq!(
1460 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).short_val as *const _ as usize },
1461 0usize,
1462 concat!(
1463 "Offset of field: ",
1464 stringify!(TangoCommandData),
1465 "::",
1466 stringify!(short_val)
1467 )
1468 );
1469 assert_eq!(
1470 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ushort_val as *const _ as usize },
1471 0usize,
1472 concat!(
1473 "Offset of field: ",
1474 stringify!(TangoCommandData),
1475 "::",
1476 stringify!(ushort_val)
1477 )
1478 );
1479 assert_eq!(
1480 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).long_val as *const _ as usize },
1481 0usize,
1482 concat!(
1483 "Offset of field: ",
1484 stringify!(TangoCommandData),
1485 "::",
1486 stringify!(long_val)
1487 )
1488 );
1489 assert_eq!(
1490 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ulong_val as *const _ as usize },
1491 0usize,
1492 concat!(
1493 "Offset of field: ",
1494 stringify!(TangoCommandData),
1495 "::",
1496 stringify!(ulong_val)
1497 )
1498 );
1499 assert_eq!(
1500 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).float_val as *const _ as usize },
1501 0usize,
1502 concat!(
1503 "Offset of field: ",
1504 stringify!(TangoCommandData),
1505 "::",
1506 stringify!(float_val)
1507 )
1508 );
1509 assert_eq!(
1510 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).double_val as *const _ as usize },
1511 0usize,
1512 concat!(
1513 "Offset of field: ",
1514 stringify!(TangoCommandData),
1515 "::",
1516 stringify!(double_val)
1517 )
1518 );
1519 assert_eq!(
1520 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).string_val as *const _ as usize },
1521 0usize,
1522 concat!(
1523 "Offset of field: ",
1524 stringify!(TangoCommandData),
1525 "::",
1526 stringify!(string_val)
1527 )
1528 );
1529 assert_eq!(
1530 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).state_val as *const _ as usize },
1531 0usize,
1532 concat!(
1533 "Offset of field: ",
1534 stringify!(TangoCommandData),
1535 "::",
1536 stringify!(state_val)
1537 )
1538 );
1539 assert_eq!(
1540 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).long64_val as *const _ as usize },
1541 0usize,
1542 concat!(
1543 "Offset of field: ",
1544 stringify!(TangoCommandData),
1545 "::",
1546 stringify!(long64_val)
1547 )
1548 );
1549 assert_eq!(
1550 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ulong64_val as *const _ as usize },
1551 0usize,
1552 concat!(
1553 "Offset of field: ",
1554 stringify!(TangoCommandData),
1555 "::",
1556 stringify!(ulong64_val)
1557 )
1558 );
1559 assert_eq!(
1560 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).bool_arr as *const _ as usize },
1561 0usize,
1562 concat!(
1563 "Offset of field: ",
1564 stringify!(TangoCommandData),
1565 "::",
1566 stringify!(bool_arr)
1567 )
1568 );
1569 assert_eq!(
1570 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).char_arr as *const _ as usize },
1571 0usize,
1572 concat!(
1573 "Offset of field: ",
1574 stringify!(TangoCommandData),
1575 "::",
1576 stringify!(char_arr)
1577 )
1578 );
1579 assert_eq!(
1580 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).short_arr as *const _ as usize },
1581 0usize,
1582 concat!(
1583 "Offset of field: ",
1584 stringify!(TangoCommandData),
1585 "::",
1586 stringify!(short_arr)
1587 )
1588 );
1589 assert_eq!(
1590 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ushort_arr as *const _ as usize },
1591 0usize,
1592 concat!(
1593 "Offset of field: ",
1594 stringify!(TangoCommandData),
1595 "::",
1596 stringify!(ushort_arr)
1597 )
1598 );
1599 assert_eq!(
1600 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).long_arr as *const _ as usize },
1601 0usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(TangoCommandData),
1605 "::",
1606 stringify!(long_arr)
1607 )
1608 );
1609 assert_eq!(
1610 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ulong_arr as *const _ as usize },
1611 0usize,
1612 concat!(
1613 "Offset of field: ",
1614 stringify!(TangoCommandData),
1615 "::",
1616 stringify!(ulong_arr)
1617 )
1618 );
1619 assert_eq!(
1620 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).long64_arr as *const _ as usize },
1621 0usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(TangoCommandData),
1625 "::",
1626 stringify!(long64_arr)
1627 )
1628 );
1629 assert_eq!(
1630 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).ulong64_arr as *const _ as usize },
1631 0usize,
1632 concat!(
1633 "Offset of field: ",
1634 stringify!(TangoCommandData),
1635 "::",
1636 stringify!(ulong64_arr)
1637 )
1638 );
1639 assert_eq!(
1640 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).float_arr as *const _ as usize },
1641 0usize,
1642 concat!(
1643 "Offset of field: ",
1644 stringify!(TangoCommandData),
1645 "::",
1646 stringify!(float_arr)
1647 )
1648 );
1649 assert_eq!(
1650 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).double_arr as *const _ as usize },
1651 0usize,
1652 concat!(
1653 "Offset of field: ",
1654 stringify!(TangoCommandData),
1655 "::",
1656 stringify!(double_arr)
1657 )
1658 );
1659 assert_eq!(
1660 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).string_arr as *const _ as usize },
1661 0usize,
1662 concat!(
1663 "Offset of field: ",
1664 stringify!(TangoCommandData),
1665 "::",
1666 stringify!(string_arr)
1667 )
1668 );
1669 assert_eq!(
1670 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).state_arr as *const _ as usize },
1671 0usize,
1672 concat!(
1673 "Offset of field: ",
1674 stringify!(TangoCommandData),
1675 "::",
1676 stringify!(state_arr)
1677 )
1678 );
1679 assert_eq!(
1680 unsafe { &(*(::std::ptr::null::<TangoCommandData>())).encoded_val as *const _ as usize },
1681 0usize,
1682 concat!(
1683 "Offset of field: ",
1684 stringify!(TangoCommandData),
1685 "::",
1686 stringify!(encoded_val)
1687 )
1688 );
1689 assert_eq!(
1690 unsafe {
1691 &(*(::std::ptr::null::<TangoCommandData>())).long_string_arr as *const _ as usize
1692 },
1693 0usize,
1694 concat!(
1695 "Offset of field: ",
1696 stringify!(TangoCommandData),
1697 "::",
1698 stringify!(long_string_arr)
1699 )
1700 );
1701 assert_eq!(
1702 unsafe {
1703 &(*(::std::ptr::null::<TangoCommandData>())).double_string_arr as *const _ as usize
1704 },
1705 0usize,
1706 concat!(
1707 "Offset of field: ",
1708 stringify!(TangoCommandData),
1709 "::",
1710 stringify!(double_string_arr)
1711 )
1712 );
1713}
1714#[repr(C)]
1715#[derive(Copy, Clone)]
1716pub union TangoPropertyData {
1717 pub bool_val: bool,
1718 pub char_val: u8,
1719 pub short_val: i16,
1720 pub ushort_val: u16,
1721 pub long_val: i32,
1722 pub ulong_val: u32,
1723 pub float_val: f32,
1724 pub double_val: f64,
1725 pub string_val: *mut libc::c_char,
1726 pub long64_val: TangoDevLong64,
1727 pub ulong64_val: TangoDevULong64,
1728 pub short_arr: VarShortArray,
1729 pub ushort_arr: VarUShortArray,
1730 pub long_arr: VarLongArray,
1731 pub ulong_arr: VarULongArray,
1732 pub long64_arr: VarLong64Array,
1733 pub ulong64_arr: VarULong64Array,
1734 pub float_arr: VarFloatArray,
1735 pub double_arr: VarDoubleArray,
1736 pub string_arr: VarStringArray,
1737 _bindgen_union_align: [u64; 2usize],
1738}
1739#[test]
1740fn bindgen_test_layout_TangoPropertyData() {
1741 assert_eq!(
1742 ::std::mem::size_of::<TangoPropertyData>(),
1743 16usize,
1744 concat!("Size of: ", stringify!(TangoPropertyData))
1745 );
1746 assert_eq!(
1747 ::std::mem::align_of::<TangoPropertyData>(),
1748 8usize,
1749 concat!("Alignment of ", stringify!(TangoPropertyData))
1750 );
1751 assert_eq!(
1752 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).bool_val as *const _ as usize },
1753 0usize,
1754 concat!(
1755 "Offset of field: ",
1756 stringify!(TangoPropertyData),
1757 "::",
1758 stringify!(bool_val)
1759 )
1760 );
1761 assert_eq!(
1762 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).char_val as *const _ as usize },
1763 0usize,
1764 concat!(
1765 "Offset of field: ",
1766 stringify!(TangoPropertyData),
1767 "::",
1768 stringify!(char_val)
1769 )
1770 );
1771 assert_eq!(
1772 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).short_val as *const _ as usize },
1773 0usize,
1774 concat!(
1775 "Offset of field: ",
1776 stringify!(TangoPropertyData),
1777 "::",
1778 stringify!(short_val)
1779 )
1780 );
1781 assert_eq!(
1782 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ushort_val as *const _ as usize },
1783 0usize,
1784 concat!(
1785 "Offset of field: ",
1786 stringify!(TangoPropertyData),
1787 "::",
1788 stringify!(ushort_val)
1789 )
1790 );
1791 assert_eq!(
1792 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).long_val as *const _ as usize },
1793 0usize,
1794 concat!(
1795 "Offset of field: ",
1796 stringify!(TangoPropertyData),
1797 "::",
1798 stringify!(long_val)
1799 )
1800 );
1801 assert_eq!(
1802 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ulong_val as *const _ as usize },
1803 0usize,
1804 concat!(
1805 "Offset of field: ",
1806 stringify!(TangoPropertyData),
1807 "::",
1808 stringify!(ulong_val)
1809 )
1810 );
1811 assert_eq!(
1812 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).float_val as *const _ as usize },
1813 0usize,
1814 concat!(
1815 "Offset of field: ",
1816 stringify!(TangoPropertyData),
1817 "::",
1818 stringify!(float_val)
1819 )
1820 );
1821 assert_eq!(
1822 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).double_val as *const _ as usize },
1823 0usize,
1824 concat!(
1825 "Offset of field: ",
1826 stringify!(TangoPropertyData),
1827 "::",
1828 stringify!(double_val)
1829 )
1830 );
1831 assert_eq!(
1832 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).string_val as *const _ as usize },
1833 0usize,
1834 concat!(
1835 "Offset of field: ",
1836 stringify!(TangoPropertyData),
1837 "::",
1838 stringify!(string_val)
1839 )
1840 );
1841 assert_eq!(
1842 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).long64_val as *const _ as usize },
1843 0usize,
1844 concat!(
1845 "Offset of field: ",
1846 stringify!(TangoPropertyData),
1847 "::",
1848 stringify!(long64_val)
1849 )
1850 );
1851 assert_eq!(
1852 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ulong64_val as *const _ as usize },
1853 0usize,
1854 concat!(
1855 "Offset of field: ",
1856 stringify!(TangoPropertyData),
1857 "::",
1858 stringify!(ulong64_val)
1859 )
1860 );
1861 assert_eq!(
1862 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).short_arr as *const _ as usize },
1863 0usize,
1864 concat!(
1865 "Offset of field: ",
1866 stringify!(TangoPropertyData),
1867 "::",
1868 stringify!(short_arr)
1869 )
1870 );
1871 assert_eq!(
1872 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ushort_arr as *const _ as usize },
1873 0usize,
1874 concat!(
1875 "Offset of field: ",
1876 stringify!(TangoPropertyData),
1877 "::",
1878 stringify!(ushort_arr)
1879 )
1880 );
1881 assert_eq!(
1882 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).long_arr as *const _ as usize },
1883 0usize,
1884 concat!(
1885 "Offset of field: ",
1886 stringify!(TangoPropertyData),
1887 "::",
1888 stringify!(long_arr)
1889 )
1890 );
1891 assert_eq!(
1892 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ulong_arr as *const _ as usize },
1893 0usize,
1894 concat!(
1895 "Offset of field: ",
1896 stringify!(TangoPropertyData),
1897 "::",
1898 stringify!(ulong_arr)
1899 )
1900 );
1901 assert_eq!(
1902 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).long64_arr as *const _ as usize },
1903 0usize,
1904 concat!(
1905 "Offset of field: ",
1906 stringify!(TangoPropertyData),
1907 "::",
1908 stringify!(long64_arr)
1909 )
1910 );
1911 assert_eq!(
1912 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).ulong64_arr as *const _ as usize },
1913 0usize,
1914 concat!(
1915 "Offset of field: ",
1916 stringify!(TangoPropertyData),
1917 "::",
1918 stringify!(ulong64_arr)
1919 )
1920 );
1921 assert_eq!(
1922 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).float_arr as *const _ as usize },
1923 0usize,
1924 concat!(
1925 "Offset of field: ",
1926 stringify!(TangoPropertyData),
1927 "::",
1928 stringify!(float_arr)
1929 )
1930 );
1931 assert_eq!(
1932 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).double_arr as *const _ as usize },
1933 0usize,
1934 concat!(
1935 "Offset of field: ",
1936 stringify!(TangoPropertyData),
1937 "::",
1938 stringify!(double_arr)
1939 )
1940 );
1941 assert_eq!(
1942 unsafe { &(*(::std::ptr::null::<TangoPropertyData>())).string_arr as *const _ as usize },
1943 0usize,
1944 concat!(
1945 "Offset of field: ",
1946 stringify!(TangoPropertyData),
1947 "::",
1948 stringify!(string_arr)
1949 )
1950 );
1951}
1952#[repr(C)]
1953#[derive(Copy, Clone)]
1954pub struct CommandData {
1955 pub arg_type: TangoDataType,
1956 pub cmd_data: TangoCommandData,
1957}
1958#[test]
1959fn bindgen_test_layout_CommandData() {
1960 assert_eq!(
1961 ::std::mem::size_of::<CommandData>(),
1962 40usize,
1963 concat!("Size of: ", stringify!(CommandData))
1964 );
1965 assert_eq!(
1966 ::std::mem::align_of::<CommandData>(),
1967 8usize,
1968 concat!("Alignment of ", stringify!(CommandData))
1969 );
1970 assert_eq!(
1971 unsafe { &(*(::std::ptr::null::<CommandData>())).arg_type as *const _ as usize },
1972 0usize,
1973 concat!(
1974 "Offset of field: ",
1975 stringify!(CommandData),
1976 "::",
1977 stringify!(arg_type)
1978 )
1979 );
1980 assert_eq!(
1981 unsafe { &(*(::std::ptr::null::<CommandData>())).cmd_data as *const _ as usize },
1982 8usize,
1983 concat!(
1984 "Offset of field: ",
1985 stringify!(CommandData),
1986 "::",
1987 stringify!(cmd_data)
1988 )
1989 );
1990}
1991#[repr(C)]
1992#[derive(Copy, Clone)]
1993pub struct AttributeData {
1994 pub data_type: TangoDataType,
1995 pub attr_data: TangoAttributeData,
1996 pub data_format: AttrDataFormat,
1997 pub quality: AttrQuality,
1998 pub nb_read: libc::c_long,
1999 pub name: *mut libc::c_char,
2000 pub dim_x: i32,
2001 pub dim_y: i32,
2002 pub time_stamp: timeval,
2003}
2004#[test]
2005fn bindgen_test_layout_AttributeData() {
2006 assert_eq!(
2007 ::std::mem::size_of::<AttributeData>(),
2008 72usize,
2009 concat!("Size of: ", stringify!(AttributeData))
2010 );
2011 assert_eq!(
2012 ::std::mem::align_of::<AttributeData>(),
2013 8usize,
2014 concat!("Alignment of ", stringify!(AttributeData))
2015 );
2016 assert_eq!(
2017 unsafe { &(*(::std::ptr::null::<AttributeData>())).data_type as *const _ as usize },
2018 0usize,
2019 concat!(
2020 "Offset of field: ",
2021 stringify!(AttributeData),
2022 "::",
2023 stringify!(data_type)
2024 )
2025 );
2026 assert_eq!(
2027 unsafe { &(*(::std::ptr::null::<AttributeData>())).attr_data as *const _ as usize },
2028 8usize,
2029 concat!(
2030 "Offset of field: ",
2031 stringify!(AttributeData),
2032 "::",
2033 stringify!(attr_data)
2034 )
2035 );
2036 assert_eq!(
2037 unsafe { &(*(::std::ptr::null::<AttributeData>())).data_format as *const _ as usize },
2038 24usize,
2039 concat!(
2040 "Offset of field: ",
2041 stringify!(AttributeData),
2042 "::",
2043 stringify!(data_format)
2044 )
2045 );
2046 assert_eq!(
2047 unsafe { &(*(::std::ptr::null::<AttributeData>())).quality as *const _ as usize },
2048 28usize,
2049 concat!(
2050 "Offset of field: ",
2051 stringify!(AttributeData),
2052 "::",
2053 stringify!(quality)
2054 )
2055 );
2056 assert_eq!(
2057 unsafe { &(*(::std::ptr::null::<AttributeData>())).nb_read as *const _ as usize },
2058 32usize,
2059 concat!(
2060 "Offset of field: ",
2061 stringify!(AttributeData),
2062 "::",
2063 stringify!(nb_read)
2064 )
2065 );
2066 assert_eq!(
2067 unsafe { &(*(::std::ptr::null::<AttributeData>())).name as *const _ as usize },
2068 40usize,
2069 concat!(
2070 "Offset of field: ",
2071 stringify!(AttributeData),
2072 "::",
2073 stringify!(name)
2074 )
2075 );
2076 assert_eq!(
2077 unsafe { &(*(::std::ptr::null::<AttributeData>())).dim_x as *const _ as usize },
2078 48usize,
2079 concat!(
2080 "Offset of field: ",
2081 stringify!(AttributeData),
2082 "::",
2083 stringify!(dim_x)
2084 )
2085 );
2086 assert_eq!(
2087 unsafe { &(*(::std::ptr::null::<AttributeData>())).dim_y as *const _ as usize },
2088 52usize,
2089 concat!(
2090 "Offset of field: ",
2091 stringify!(AttributeData),
2092 "::",
2093 stringify!(dim_y)
2094 )
2095 );
2096 assert_eq!(
2097 unsafe { &(*(::std::ptr::null::<AttributeData>())).time_stamp as *const _ as usize },
2098 56usize,
2099 concat!(
2100 "Offset of field: ",
2101 stringify!(AttributeData),
2102 "::",
2103 stringify!(time_stamp)
2104 )
2105 );
2106}
2107#[repr(C)]
2108#[derive(Debug, Copy, Clone)]
2109pub struct AttributeDataList {
2110 pub length: u32,
2111 pub sequence: *mut AttributeData,
2112}
2113#[test]
2114fn bindgen_test_layout_AttributeDataList() {
2115 assert_eq!(
2116 ::std::mem::size_of::<AttributeDataList>(),
2117 16usize,
2118 concat!("Size of: ", stringify!(AttributeDataList))
2119 );
2120 assert_eq!(
2121 ::std::mem::align_of::<AttributeDataList>(),
2122 8usize,
2123 concat!("Alignment of ", stringify!(AttributeDataList))
2124 );
2125 assert_eq!(
2126 unsafe { &(*(::std::ptr::null::<AttributeDataList>())).length as *const _ as usize },
2127 0usize,
2128 concat!(
2129 "Offset of field: ",
2130 stringify!(AttributeDataList),
2131 "::",
2132 stringify!(length)
2133 )
2134 );
2135 assert_eq!(
2136 unsafe { &(*(::std::ptr::null::<AttributeDataList>())).sequence as *const _ as usize },
2137 8usize,
2138 concat!(
2139 "Offset of field: ",
2140 stringify!(AttributeDataList),
2141 "::",
2142 stringify!(sequence)
2143 )
2144 );
2145}
2146#[repr(C)]
2147#[derive(Debug, Copy, Clone)]
2148pub struct DevFailed {
2149 pub desc: *mut libc::c_char,
2150 pub reason: *mut libc::c_char,
2151 pub origin: *mut libc::c_char,
2152 pub severity: ErrSeverity,
2153}
2154#[test]
2155fn bindgen_test_layout_DevFailed() {
2156 assert_eq!(
2157 ::std::mem::size_of::<DevFailed>(),
2158 32usize,
2159 concat!("Size of: ", stringify!(DevFailed))
2160 );
2161 assert_eq!(
2162 ::std::mem::align_of::<DevFailed>(),
2163 8usize,
2164 concat!("Alignment of ", stringify!(DevFailed))
2165 );
2166 assert_eq!(
2167 unsafe { &(*(::std::ptr::null::<DevFailed>())).desc as *const _ as usize },
2168 0usize,
2169 concat!(
2170 "Offset of field: ",
2171 stringify!(DevFailed),
2172 "::",
2173 stringify!(desc)
2174 )
2175 );
2176 assert_eq!(
2177 unsafe { &(*(::std::ptr::null::<DevFailed>())).reason as *const _ as usize },
2178 8usize,
2179 concat!(
2180 "Offset of field: ",
2181 stringify!(DevFailed),
2182 "::",
2183 stringify!(reason)
2184 )
2185 );
2186 assert_eq!(
2187 unsafe { &(*(::std::ptr::null::<DevFailed>())).origin as *const _ as usize },
2188 16usize,
2189 concat!(
2190 "Offset of field: ",
2191 stringify!(DevFailed),
2192 "::",
2193 stringify!(origin)
2194 )
2195 );
2196 assert_eq!(
2197 unsafe { &(*(::std::ptr::null::<DevFailed>())).severity as *const _ as usize },
2198 24usize,
2199 concat!(
2200 "Offset of field: ",
2201 stringify!(DevFailed),
2202 "::",
2203 stringify!(severity)
2204 )
2205 );
2206}
2207#[repr(C)]
2208#[derive(Debug, Copy, Clone)]
2209pub struct ErrorStack {
2210 pub length: u32,
2211 pub sequence: *mut DevFailed,
2212}
2213#[test]
2214fn bindgen_test_layout_ErrorStack() {
2215 assert_eq!(
2216 ::std::mem::size_of::<ErrorStack>(),
2217 16usize,
2218 concat!("Size of: ", stringify!(ErrorStack))
2219 );
2220 assert_eq!(
2221 ::std::mem::align_of::<ErrorStack>(),
2222 8usize,
2223 concat!("Alignment of ", stringify!(ErrorStack))
2224 );
2225 assert_eq!(
2226 unsafe { &(*(::std::ptr::null::<ErrorStack>())).length as *const _ as usize },
2227 0usize,
2228 concat!(
2229 "Offset of field: ",
2230 stringify!(ErrorStack),
2231 "::",
2232 stringify!(length)
2233 )
2234 );
2235 assert_eq!(
2236 unsafe { &(*(::std::ptr::null::<ErrorStack>())).sequence as *const _ as usize },
2237 8usize,
2238 concat!(
2239 "Offset of field: ",
2240 stringify!(ErrorStack),
2241 "::",
2242 stringify!(sequence)
2243 )
2244 );
2245}
2246#[repr(C)]
2247#[derive(Debug, Copy, Clone)]
2248pub struct CommandInfo {
2249 pub cmd_name: *mut libc::c_char,
2250 pub cmd_tag: i32,
2251 pub in_type: i32,
2252 pub out_type: i32,
2253 pub in_type_desc: *mut libc::c_char,
2254 pub out_type_desc: *mut libc::c_char,
2255 pub disp_level: DispLevel,
2256}
2257#[test]
2258fn bindgen_test_layout_CommandInfo() {
2259 assert_eq!(
2260 ::std::mem::size_of::<CommandInfo>(),
2261 48usize,
2262 concat!("Size of: ", stringify!(CommandInfo))
2263 );
2264 assert_eq!(
2265 ::std::mem::align_of::<CommandInfo>(),
2266 8usize,
2267 concat!("Alignment of ", stringify!(CommandInfo))
2268 );
2269 assert_eq!(
2270 unsafe { &(*(::std::ptr::null::<CommandInfo>())).cmd_name as *const _ as usize },
2271 0usize,
2272 concat!(
2273 "Offset of field: ",
2274 stringify!(CommandInfo),
2275 "::",
2276 stringify!(cmd_name)
2277 )
2278 );
2279 assert_eq!(
2280 unsafe { &(*(::std::ptr::null::<CommandInfo>())).cmd_tag as *const _ as usize },
2281 8usize,
2282 concat!(
2283 "Offset of field: ",
2284 stringify!(CommandInfo),
2285 "::",
2286 stringify!(cmd_tag)
2287 )
2288 );
2289 assert_eq!(
2290 unsafe { &(*(::std::ptr::null::<CommandInfo>())).in_type as *const _ as usize },
2291 12usize,
2292 concat!(
2293 "Offset of field: ",
2294 stringify!(CommandInfo),
2295 "::",
2296 stringify!(in_type)
2297 )
2298 );
2299 assert_eq!(
2300 unsafe { &(*(::std::ptr::null::<CommandInfo>())).out_type as *const _ as usize },
2301 16usize,
2302 concat!(
2303 "Offset of field: ",
2304 stringify!(CommandInfo),
2305 "::",
2306 stringify!(out_type)
2307 )
2308 );
2309 assert_eq!(
2310 unsafe { &(*(::std::ptr::null::<CommandInfo>())).in_type_desc as *const _ as usize },
2311 24usize,
2312 concat!(
2313 "Offset of field: ",
2314 stringify!(CommandInfo),
2315 "::",
2316 stringify!(in_type_desc)
2317 )
2318 );
2319 assert_eq!(
2320 unsafe { &(*(::std::ptr::null::<CommandInfo>())).out_type_desc as *const _ as usize },
2321 32usize,
2322 concat!(
2323 "Offset of field: ",
2324 stringify!(CommandInfo),
2325 "::",
2326 stringify!(out_type_desc)
2327 )
2328 );
2329 assert_eq!(
2330 unsafe { &(*(::std::ptr::null::<CommandInfo>())).disp_level as *const _ as usize },
2331 40usize,
2332 concat!(
2333 "Offset of field: ",
2334 stringify!(CommandInfo),
2335 "::",
2336 stringify!(disp_level)
2337 )
2338 );
2339}
2340#[repr(C)]
2341#[derive(Debug, Copy, Clone)]
2342pub struct CommandInfoList {
2343 pub length: u32,
2344 pub sequence: *mut CommandInfo,
2345}
2346#[test]
2347fn bindgen_test_layout_CommandInfoList() {
2348 assert_eq!(
2349 ::std::mem::size_of::<CommandInfoList>(),
2350 16usize,
2351 concat!("Size of: ", stringify!(CommandInfoList))
2352 );
2353 assert_eq!(
2354 ::std::mem::align_of::<CommandInfoList>(),
2355 8usize,
2356 concat!("Alignment of ", stringify!(CommandInfoList))
2357 );
2358 assert_eq!(
2359 unsafe { &(*(::std::ptr::null::<CommandInfoList>())).length as *const _ as usize },
2360 0usize,
2361 concat!(
2362 "Offset of field: ",
2363 stringify!(CommandInfoList),
2364 "::",
2365 stringify!(length)
2366 )
2367 );
2368 assert_eq!(
2369 unsafe { &(*(::std::ptr::null::<CommandInfoList>())).sequence as *const _ as usize },
2370 8usize,
2371 concat!(
2372 "Offset of field: ",
2373 stringify!(CommandInfoList),
2374 "::",
2375 stringify!(sequence)
2376 )
2377 );
2378}
2379#[repr(C)]
2380#[derive(Debug, Copy, Clone)]
2381pub struct AttributeInfo {
2382 pub name: *mut libc::c_char,
2383 pub writable: AttrWriteType,
2384 pub data_format: AttrDataFormat,
2385 pub data_type: TangoDataType,
2386 pub max_dim_x: i32,
2387 pub max_dim_y: i32,
2388 pub description: *mut libc::c_char,
2389 pub label: *mut libc::c_char,
2390 pub unit: *mut libc::c_char,
2391 pub standard_unit: *mut libc::c_char,
2392 pub display_unit: *mut libc::c_char,
2393 pub format: *mut libc::c_char,
2394 pub min_value: *mut libc::c_char,
2395 pub max_value: *mut libc::c_char,
2396 pub min_alarm: *mut libc::c_char,
2397 pub max_alarm: *mut libc::c_char,
2398 pub writable_attr_name: *mut libc::c_char,
2399 pub disp_level: DispLevel,
2400}
2401#[test]
2402fn bindgen_test_layout_AttributeInfo() {
2403 assert_eq!(
2404 ::std::mem::size_of::<AttributeInfo>(),
2405 128usize,
2406 concat!("Size of: ", stringify!(AttributeInfo))
2407 );
2408 assert_eq!(
2409 ::std::mem::align_of::<AttributeInfo>(),
2410 8usize,
2411 concat!("Alignment of ", stringify!(AttributeInfo))
2412 );
2413 assert_eq!(
2414 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).name as *const _ as usize },
2415 0usize,
2416 concat!(
2417 "Offset of field: ",
2418 stringify!(AttributeInfo),
2419 "::",
2420 stringify!(name)
2421 )
2422 );
2423 assert_eq!(
2424 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).writable as *const _ as usize },
2425 8usize,
2426 concat!(
2427 "Offset of field: ",
2428 stringify!(AttributeInfo),
2429 "::",
2430 stringify!(writable)
2431 )
2432 );
2433 assert_eq!(
2434 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).data_format as *const _ as usize },
2435 12usize,
2436 concat!(
2437 "Offset of field: ",
2438 stringify!(AttributeInfo),
2439 "::",
2440 stringify!(data_format)
2441 )
2442 );
2443 assert_eq!(
2444 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).data_type as *const _ as usize },
2445 16usize,
2446 concat!(
2447 "Offset of field: ",
2448 stringify!(AttributeInfo),
2449 "::",
2450 stringify!(data_type)
2451 )
2452 );
2453 assert_eq!(
2454 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).max_dim_x as *const _ as usize },
2455 20usize,
2456 concat!(
2457 "Offset of field: ",
2458 stringify!(AttributeInfo),
2459 "::",
2460 stringify!(max_dim_x)
2461 )
2462 );
2463 assert_eq!(
2464 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).max_dim_y as *const _ as usize },
2465 24usize,
2466 concat!(
2467 "Offset of field: ",
2468 stringify!(AttributeInfo),
2469 "::",
2470 stringify!(max_dim_y)
2471 )
2472 );
2473 assert_eq!(
2474 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).description as *const _ as usize },
2475 32usize,
2476 concat!(
2477 "Offset of field: ",
2478 stringify!(AttributeInfo),
2479 "::",
2480 stringify!(description)
2481 )
2482 );
2483 assert_eq!(
2484 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).label as *const _ as usize },
2485 40usize,
2486 concat!(
2487 "Offset of field: ",
2488 stringify!(AttributeInfo),
2489 "::",
2490 stringify!(label)
2491 )
2492 );
2493 assert_eq!(
2494 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).unit as *const _ as usize },
2495 48usize,
2496 concat!(
2497 "Offset of field: ",
2498 stringify!(AttributeInfo),
2499 "::",
2500 stringify!(unit)
2501 )
2502 );
2503 assert_eq!(
2504 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).standard_unit as *const _ as usize },
2505 56usize,
2506 concat!(
2507 "Offset of field: ",
2508 stringify!(AttributeInfo),
2509 "::",
2510 stringify!(standard_unit)
2511 )
2512 );
2513 assert_eq!(
2514 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).display_unit as *const _ as usize },
2515 64usize,
2516 concat!(
2517 "Offset of field: ",
2518 stringify!(AttributeInfo),
2519 "::",
2520 stringify!(display_unit)
2521 )
2522 );
2523 assert_eq!(
2524 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).format as *const _ as usize },
2525 72usize,
2526 concat!(
2527 "Offset of field: ",
2528 stringify!(AttributeInfo),
2529 "::",
2530 stringify!(format)
2531 )
2532 );
2533 assert_eq!(
2534 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).min_value as *const _ as usize },
2535 80usize,
2536 concat!(
2537 "Offset of field: ",
2538 stringify!(AttributeInfo),
2539 "::",
2540 stringify!(min_value)
2541 )
2542 );
2543 assert_eq!(
2544 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).max_value as *const _ as usize },
2545 88usize,
2546 concat!(
2547 "Offset of field: ",
2548 stringify!(AttributeInfo),
2549 "::",
2550 stringify!(max_value)
2551 )
2552 );
2553 assert_eq!(
2554 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).min_alarm as *const _ as usize },
2555 96usize,
2556 concat!(
2557 "Offset of field: ",
2558 stringify!(AttributeInfo),
2559 "::",
2560 stringify!(min_alarm)
2561 )
2562 );
2563 assert_eq!(
2564 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).max_alarm as *const _ as usize },
2565 104usize,
2566 concat!(
2567 "Offset of field: ",
2568 stringify!(AttributeInfo),
2569 "::",
2570 stringify!(max_alarm)
2571 )
2572 );
2573 assert_eq!(
2574 unsafe {
2575 &(*(::std::ptr::null::<AttributeInfo>())).writable_attr_name as *const _ as usize
2576 },
2577 112usize,
2578 concat!(
2579 "Offset of field: ",
2580 stringify!(AttributeInfo),
2581 "::",
2582 stringify!(writable_attr_name)
2583 )
2584 );
2585 assert_eq!(
2586 unsafe { &(*(::std::ptr::null::<AttributeInfo>())).disp_level as *const _ as usize },
2587 120usize,
2588 concat!(
2589 "Offset of field: ",
2590 stringify!(AttributeInfo),
2591 "::",
2592 stringify!(disp_level)
2593 )
2594 );
2595}
2596#[repr(C)]
2597#[derive(Debug, Copy, Clone)]
2598pub struct AttributeInfoList {
2599 pub length: u32,
2600 pub sequence: *mut AttributeInfo,
2601}
2602#[test]
2603fn bindgen_test_layout_AttributeInfoList() {
2604 assert_eq!(
2605 ::std::mem::size_of::<AttributeInfoList>(),
2606 16usize,
2607 concat!("Size of: ", stringify!(AttributeInfoList))
2608 );
2609 assert_eq!(
2610 ::std::mem::align_of::<AttributeInfoList>(),
2611 8usize,
2612 concat!("Alignment of ", stringify!(AttributeInfoList))
2613 );
2614 assert_eq!(
2615 unsafe { &(*(::std::ptr::null::<AttributeInfoList>())).length as *const _ as usize },
2616 0usize,
2617 concat!(
2618 "Offset of field: ",
2619 stringify!(AttributeInfoList),
2620 "::",
2621 stringify!(length)
2622 )
2623 );
2624 assert_eq!(
2625 unsafe { &(*(::std::ptr::null::<AttributeInfoList>())).sequence as *const _ as usize },
2626 8usize,
2627 concat!(
2628 "Offset of field: ",
2629 stringify!(AttributeInfoList),
2630 "::",
2631 stringify!(sequence)
2632 )
2633 );
2634}
2635#[repr(C)]
2636#[derive(Copy, Clone)]
2637pub struct DbDatum {
2638 pub property_name: *mut libc::c_char,
2639 pub data_type: TangoDataType,
2640 pub prop_data: TangoPropertyData,
2641 pub is_empty: bool,
2642 pub wrong_data_type: bool,
2643}
2644#[test]
2645fn bindgen_test_layout_DbDatum() {
2646 assert_eq!(
2647 ::std::mem::size_of::<DbDatum>(),
2648 40usize,
2649 concat!("Size of: ", stringify!(DbDatum))
2650 );
2651 assert_eq!(
2652 ::std::mem::align_of::<DbDatum>(),
2653 8usize,
2654 concat!("Alignment of ", stringify!(DbDatum))
2655 );
2656 assert_eq!(
2657 unsafe { &(*(::std::ptr::null::<DbDatum>())).property_name as *const _ as usize },
2658 0usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(DbDatum),
2662 "::",
2663 stringify!(property_name)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe { &(*(::std::ptr::null::<DbDatum>())).data_type as *const _ as usize },
2668 8usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(DbDatum),
2672 "::",
2673 stringify!(data_type)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { &(*(::std::ptr::null::<DbDatum>())).prop_data as *const _ as usize },
2678 16usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(DbDatum),
2682 "::",
2683 stringify!(prop_data)
2684 )
2685 );
2686 assert_eq!(
2687 unsafe { &(*(::std::ptr::null::<DbDatum>())).is_empty as *const _ as usize },
2688 32usize,
2689 concat!(
2690 "Offset of field: ",
2691 stringify!(DbDatum),
2692 "::",
2693 stringify!(is_empty)
2694 )
2695 );
2696 assert_eq!(
2697 unsafe { &(*(::std::ptr::null::<DbDatum>())).wrong_data_type as *const _ as usize },
2698 33usize,
2699 concat!(
2700 "Offset of field: ",
2701 stringify!(DbDatum),
2702 "::",
2703 stringify!(wrong_data_type)
2704 )
2705 );
2706}
2707#[repr(C)]
2708#[derive(Debug, Copy, Clone)]
2709pub struct DbData {
2710 pub length: u32,
2711 pub sequence: *mut DbDatum,
2712}
2713#[test]
2714fn bindgen_test_layout_DbData() {
2715 assert_eq!(
2716 ::std::mem::size_of::<DbData>(),
2717 16usize,
2718 concat!("Size of: ", stringify!(DbData))
2719 );
2720 assert_eq!(
2721 ::std::mem::align_of::<DbData>(),
2722 8usize,
2723 concat!("Alignment of ", stringify!(DbData))
2724 );
2725 assert_eq!(
2726 unsafe { &(*(::std::ptr::null::<DbData>())).length as *const _ as usize },
2727 0usize,
2728 concat!(
2729 "Offset of field: ",
2730 stringify!(DbData),
2731 "::",
2732 stringify!(length)
2733 )
2734 );
2735 assert_eq!(
2736 unsafe { &(*(::std::ptr::null::<DbData>())).sequence as *const _ as usize },
2737 8usize,
2738 concat!(
2739 "Offset of field: ",
2740 stringify!(DbData),
2741 "::",
2742 stringify!(sequence)
2743 )
2744 );
2745}
2746extern "C" {
2747 pub fn tango_create_device_proxy(
2748 dev_name: *mut libc::c_char,
2749 proxy: *mut *mut libc::c_void,
2750 ) -> *mut ErrorStack;
2751}
2752extern "C" {
2753 pub fn tango_delete_device_proxy(proxy: *mut libc::c_void) -> *mut ErrorStack;
2754}
2755extern "C" {
2756 pub fn tango_set_timeout_millis(
2757 proxy: *mut libc::c_void,
2758 millis: libc::c_int,
2759 ) -> *mut ErrorStack;
2760}
2761extern "C" {
2762 pub fn tango_get_timeout_millis(
2763 proxy: *mut libc::c_void,
2764 millis: *mut libc::c_int,
2765 ) -> *mut ErrorStack;
2766}
2767extern "C" {
2768 pub fn tango_set_source(proxy: *mut libc::c_void, source: DevSource) -> *mut ErrorStack;
2769}
2770extern "C" {
2771 pub fn tango_get_source(proxy: *mut libc::c_void, source: *mut DevSource) -> *mut ErrorStack;
2772}
2773extern "C" {
2774 pub fn tango_lock(proxy: *mut libc::c_void) -> *mut ErrorStack;
2775}
2776extern "C" {
2777 pub fn tango_unlock(proxy: *mut libc::c_void) -> *mut ErrorStack;
2778}
2779extern "C" {
2780 pub fn tango_is_locked(proxy: *mut libc::c_void, is_locked: *mut bool) -> *mut ErrorStack;
2781}
2782extern "C" {
2783 pub fn tango_is_locked_by_me(
2784 proxy: *mut libc::c_void,
2785 is_locked_by_me: *mut bool,
2786 ) -> *mut ErrorStack;
2787}
2788extern "C" {
2789 pub fn tango_locking_status(
2790 proxy: *mut libc::c_void,
2791 lock_status: *mut *mut libc::c_char,
2792 ) -> *mut ErrorStack;
2793}
2794extern "C" {
2795 pub fn tango_command_query(
2796 proxy: *mut libc::c_void,
2797 cmd_name: *mut libc::c_char,
2798 cmd_info: *mut CommandInfo,
2799 ) -> *mut ErrorStack;
2800}
2801extern "C" {
2802 pub fn tango_command_list_query(
2803 proxy: *mut libc::c_void,
2804 cmd_info_list: *mut CommandInfoList,
2805 ) -> *mut ErrorStack;
2806}
2807extern "C" {
2808 pub fn tango_command_inout(
2809 proxy: *mut libc::c_void,
2810 cmd_name: *mut libc::c_char,
2811 argin: *mut CommandData,
2812 argout: *mut CommandData,
2813 ) -> *mut ErrorStack;
2814}
2815extern "C" {
2816 pub fn tango_free_CommandData(command_data: *mut CommandData);
2817}
2818extern "C" {
2819 pub fn tango_free_CommandInfo(command_info: *mut CommandInfo);
2820}
2821extern "C" {
2822 pub fn tango_free_CommandInfoList(command_info_list: *mut CommandInfoList);
2823}
2824extern "C" {
2825 pub fn tango_get_attribute_list(
2826 proxy: *mut libc::c_void,
2827 attr_names: *mut VarStringArray,
2828 ) -> *mut ErrorStack;
2829}
2830extern "C" {
2831 pub fn tango_get_attribute_config(
2832 proxy: *mut libc::c_void,
2833 attr_names: *mut VarStringArray,
2834 attr_info_list: *mut AttributeInfoList,
2835 ) -> *mut ErrorStack;
2836}
2837extern "C" {
2838 pub fn tango_attribute_list_query(
2839 proxy: *mut libc::c_void,
2840 attr_info_list: *mut AttributeInfoList,
2841 ) -> *mut ErrorStack;
2842}
2843extern "C" {
2844 pub fn tango_read_attribute(
2845 proxy: *mut libc::c_void,
2846 attr_name: *mut libc::c_char,
2847 argout: *mut AttributeData,
2848 ) -> *mut ErrorStack;
2849}
2850extern "C" {
2851 pub fn tango_write_attribute(
2852 proxy: *mut libc::c_void,
2853 argin: *mut AttributeData,
2854 ) -> *mut ErrorStack;
2855}
2856extern "C" {
2857 pub fn tango_read_attributes(
2858 proxy: *mut libc::c_void,
2859 attr_names: *mut VarStringArray,
2860 argout: *mut AttributeDataList,
2861 ) -> *mut ErrorStack;
2862}
2863extern "C" {
2864 pub fn tango_write_attributes(
2865 proxy: *mut libc::c_void,
2866 argin: *mut AttributeDataList,
2867 ) -> *mut ErrorStack;
2868}
2869extern "C" {
2870 pub fn tango_free_AttributeData(attribute_data: *mut AttributeData);
2871}
2872extern "C" {
2873 pub fn tango_free_AttributeDataList(attribute_data_list: *mut AttributeDataList);
2874}
2875extern "C" {
2876 pub fn tango_free_VarStringArray(string_arr: *mut VarStringArray);
2877}
2878extern "C" {
2879 pub fn tango_free_AttributeInfoList(attribute_info_list: *mut AttributeInfoList);
2880}
2881extern "C" {
2882 pub fn tango_free_ErrorStack(error_stack: *mut ErrorStack);
2883}
2884extern "C" {
2885 pub fn tango_create_database_proxy(db_proxy: *mut *mut libc::c_void) -> *mut ErrorStack;
2886}
2887extern "C" {
2888 pub fn tango_delete_database_proxy(db_proxy: *mut libc::c_void) -> *mut ErrorStack;
2889}
2890extern "C" {
2891 pub fn tango_get_device_exported(
2892 db_proxy: *mut libc::c_void,
2893 name_filter: *mut libc::c_char,
2894 dev_list: *mut DbDatum,
2895 ) -> *mut ErrorStack;
2896}
2897extern "C" {
2898 pub fn tango_get_device_exported_for_class(
2899 db_proxy: *mut libc::c_void,
2900 class_name: *mut libc::c_char,
2901 dev_list: *mut DbDatum,
2902 ) -> *mut ErrorStack;
2903}
2904extern "C" {
2905 pub fn tango_get_object_list(
2906 db_proxy: *mut libc::c_void,
2907 name_filter: *mut libc::c_char,
2908 obj_list: *mut DbDatum,
2909 ) -> *mut ErrorStack;
2910}
2911extern "C" {
2912 pub fn tango_get_object_property_list(
2913 db_proxy: *mut libc::c_void,
2914 obj_name: *mut libc::c_char,
2915 name_filter: *mut libc::c_char,
2916 prop_list: *mut DbDatum,
2917 ) -> *mut ErrorStack;
2918}
2919extern "C" {
2920 pub fn tango_get_property(
2921 db_proxy: *mut libc::c_void,
2922 obj_name: *mut libc::c_char,
2923 prop_list: *mut DbData,
2924 ) -> *mut ErrorStack;
2925}
2926extern "C" {
2927 pub fn tango_put_property(
2928 db_proxy: *mut libc::c_void,
2929 obj_name: *mut libc::c_char,
2930 prop_list: *mut DbData,
2931 ) -> *mut ErrorStack;
2932}
2933extern "C" {
2934 pub fn tango_delete_property(
2935 db_proxy: *mut libc::c_void,
2936 obj_name: *mut libc::c_char,
2937 prop_list: *mut DbData,
2938 ) -> *mut ErrorStack;
2939}
2940extern "C" {
2941 pub fn tango_get_device_property(
2942 dev_proxy: *mut libc::c_void,
2943 prop_list: *mut DbData,
2944 ) -> *mut ErrorStack;
2945}
2946extern "C" {
2947 pub fn tango_put_device_property(
2948 dev_proxy: *mut libc::c_void,
2949 prop_list: *mut DbData,
2950 ) -> *mut ErrorStack;
2951}
2952extern "C" {
2953 pub fn tango_delete_device_property(
2954 dev_proxy: *mut libc::c_void,
2955 prop_list: *mut DbData,
2956 ) -> *mut ErrorStack;
2957}
2958extern "C" {
2959 pub fn tango_free_DbDatum(db_datum: *mut DbDatum);
2960}
2961extern "C" {
2962 pub fn tango_free_DbData(db_data: *mut DbData);
2963}