1#![allow(warnings, unused)]
3pub const _FEATURES_H: u32 = 1;
4pub const _DEFAULT_SOURCE: u32 = 1;
5pub const __USE_ISOC11: u32 = 1;
6pub const __USE_ISOC99: u32 = 1;
7pub const __USE_ISOC95: u32 = 1;
8pub const __USE_POSIX_IMPLICITLY: u32 = 1;
9pub const _POSIX_SOURCE: u32 = 1;
10pub const _POSIX_C_SOURCE: u32 = 200809;
11pub const __USE_POSIX: u32 = 1;
12pub const __USE_POSIX2: u32 = 1;
13pub const __USE_POSIX199309: u32 = 1;
14pub const __USE_POSIX199506: u32 = 1;
15pub const __USE_XOPEN2K: u32 = 1;
16pub const __USE_XOPEN2K8: u32 = 1;
17pub const _ATFILE_SOURCE: u32 = 1;
18pub const __USE_MISC: u32 = 1;
19pub const __USE_ATFILE: u32 = 1;
20pub const __USE_FORTIFY_LEVEL: u32 = 0;
21pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
22pub const _STDC_PREDEF_H: u32 = 1;
23pub const __STDC_IEC_559__: u32 = 1;
24pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
25pub const __STDC_ISO_10646__: u32 = 201706;
26pub const __STDC_NO_THREADS__: u32 = 1;
27pub const __GNU_LIBRARY__: u32 = 6;
28pub const __GLIBC__: u32 = 2;
29pub const __GLIBC_MINOR__: u32 = 27;
30pub const _SYS_CDEFS_H: u32 = 1;
31pub const __glibc_c99_flexarr_available: u32 = 1;
32pub const __WORDSIZE: u32 = 64;
33pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
34pub const __SYSCALL_WORDSIZE: u32 = 64;
35pub const __HAVE_GENERIC_SELECTION: u32 = 1;
36pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
37pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
38pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
39pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
40pub const _STDLIB_H: u32 = 1;
41pub const WNOHANG: u32 = 1;
42pub const WUNTRACED: u32 = 2;
43pub const WSTOPPED: u32 = 2;
44pub const WEXITED: u32 = 4;
45pub const WCONTINUED: u32 = 8;
46pub const WNOWAIT: u32 = 16777216;
47pub const __WNOTHREAD: u32 = 536870912;
48pub const __WALL: u32 = 1073741824;
49pub const __WCLONE: u32 = 2147483648;
50pub const __ENUM_IDTYPE_T: u32 = 1;
51pub const __W_CONTINUED: u32 = 65535;
52pub const __WCOREFLAG: u32 = 128;
53pub const __HAVE_FLOAT128: u32 = 0;
54pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
55pub const __HAVE_FLOAT64X: u32 = 1;
56pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
57pub const __HAVE_FLOAT16: u32 = 0;
58pub const __HAVE_FLOAT32: u32 = 1;
59pub const __HAVE_FLOAT64: u32 = 1;
60pub const __HAVE_FLOAT32X: u32 = 1;
61pub const __HAVE_FLOAT128X: u32 = 0;
62pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
63pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
64pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
65pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
66pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
67pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
68pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
69pub const __ldiv_t_defined: u32 = 1;
70pub const __lldiv_t_defined: u32 = 1;
71pub const RAND_MAX: u32 = 2147483647;
72pub const EXIT_FAILURE: u32 = 1;
73pub const EXIT_SUCCESS: u32 = 0;
74pub const _SYS_TYPES_H: u32 = 1;
75pub const _BITS_TYPES_H: u32 = 1;
76pub const _BITS_TYPESIZES_H: u32 = 1;
77pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
78pub const __INO_T_MATCHES_INO64_T: u32 = 1;
79pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
80pub const __FD_SETSIZE: u32 = 1024;
81pub const __clock_t_defined: u32 = 1;
82pub const __clockid_t_defined: u32 = 1;
83pub const __time_t_defined: u32 = 1;
84pub const __timer_t_defined: u32 = 1;
85pub const _BITS_STDINT_INTN_H: u32 = 1;
86pub const __BIT_TYPES_DEFINED__: u32 = 1;
87pub const _ENDIAN_H: u32 = 1;
88pub const __LITTLE_ENDIAN: u32 = 1234;
89pub const __BIG_ENDIAN: u32 = 4321;
90pub const __PDP_ENDIAN: u32 = 3412;
91pub const __BYTE_ORDER: u32 = 1234;
92pub const __FLOAT_WORD_ORDER: u32 = 1234;
93pub const LITTLE_ENDIAN: u32 = 1234;
94pub const BIG_ENDIAN: u32 = 4321;
95pub const PDP_ENDIAN: u32 = 3412;
96pub const BYTE_ORDER: u32 = 1234;
97pub const _BITS_BYTESWAP_H: u32 = 1;
98pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
99pub const _SYS_SELECT_H: u32 = 1;
100pub const __FD_ZERO_STOS: &[u8; 6usize] = b"stosq\0";
101pub const __sigset_t_defined: u32 = 1;
102pub const __timeval_defined: u32 = 1;
103pub const _STRUCT_TIMESPEC: u32 = 1;
104pub const FD_SETSIZE: u32 = 1024;
105pub const _SYS_SYSMACROS_H: u32 = 1;
106pub const _BITS_SYSMACROS_H: u32 = 1;
107pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
108pub const _THREAD_SHARED_TYPES_H: u32 = 1;
109pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
110pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
111pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
112pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
113pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
114pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
115pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
116pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
117pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
118pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
119pub const __PTHREAD_MUTEX_LOCK_ELISION: u32 = 1;
120pub const __PTHREAD_MUTEX_NUSERS_AFTER_KIND: u32 = 0;
121pub const __PTHREAD_MUTEX_USE_UNION: u32 = 0;
122pub const __PTHREAD_RWLOCK_INT_FLAGS_SHARED: u32 = 1;
123pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
124pub const __have_pthread_attr_t: u32 = 1;
125pub const _ALLOCA_H: u32 = 1;
126pub const _STDINT_H: u32 = 1;
127pub const _BITS_WCHAR_H: u32 = 1;
128pub const _BITS_STDINT_UINTN_H: u32 = 1;
129pub const INT8_MIN: i32 = -128;
130pub const INT16_MIN: i32 = -32768;
131pub const INT32_MIN: i32 = -2147483648;
132pub const INT8_MAX: u32 = 127;
133pub const INT16_MAX: u32 = 32767;
134pub const INT32_MAX: u32 = 2147483647;
135pub const UINT8_MAX: u32 = 255;
136pub const UINT16_MAX: u32 = 65535;
137pub const UINT32_MAX: u32 = 4294967295;
138pub const INT_LEAST8_MIN: i32 = -128;
139pub const INT_LEAST16_MIN: i32 = -32768;
140pub const INT_LEAST32_MIN: i32 = -2147483648;
141pub const INT_LEAST8_MAX: u32 = 127;
142pub const INT_LEAST16_MAX: u32 = 32767;
143pub const INT_LEAST32_MAX: u32 = 2147483647;
144pub const UINT_LEAST8_MAX: u32 = 255;
145pub const UINT_LEAST16_MAX: u32 = 65535;
146pub const UINT_LEAST32_MAX: u32 = 4294967295;
147pub const INT_FAST8_MIN: i32 = -128;
148pub const INT_FAST16_MIN: i64 = -9223372036854775808;
149pub const INT_FAST32_MIN: i64 = -9223372036854775808;
150pub const INT_FAST8_MAX: u32 = 127;
151pub const INT_FAST16_MAX: u64 = 9223372036854775807;
152pub const INT_FAST32_MAX: u64 = 9223372036854775807;
153pub const UINT_FAST8_MAX: u32 = 255;
154pub const UINT_FAST16_MAX: i32 = -1;
155pub const UINT_FAST32_MAX: i32 = -1;
156pub const INTPTR_MIN: i64 = -9223372036854775808;
157pub const INTPTR_MAX: u64 = 9223372036854775807;
158pub const UINTPTR_MAX: i32 = -1;
159pub const PTRDIFF_MIN: i64 = -9223372036854775808;
160pub const PTRDIFF_MAX: u64 = 9223372036854775807;
161pub const SIG_ATOMIC_MIN: i32 = -2147483648;
162pub const SIG_ATOMIC_MAX: u32 = 2147483647;
163pub const SIZE_MAX: i32 = -1;
164pub const WINT_MIN: u32 = 0;
165pub const WINT_MAX: u32 = 4294967295;
166pub const GS_CLIENT_VERSION_MAJOR: u32 = 4;
167pub const GS_CLIENT_VERSION_MINOR: u32 = 3;
168pub const GS_INTERNAL_DEFINITION_VISIBLE: u32 = 1;
169pub const GS_DEPRECATION_IGNORABLE: u32 = 0;
170pub const GS_DEPRECATED_FUNC_ENABLED: u32 = 1;
171pub const GS_EXPERIMENTAL_TOOL_ENABLED: u32 = 0;
172pub const GS_COMPATIBILITY_FACTORY_BETA_0_3: u32 = 0;
173pub const GS_COMPATIBILITY_TIME_SERIES_PROPERTIES_0_0_10: u32 = 0;
174pub const GS_COMPATIBILITY_TIME_SERIES_SAMPLING_BETA_0_1: u32 = 0;
175pub const GS_COMPATIBILITY_GET_MULTIPLE_ROWS_BETA_0_3: u32 = 0;
176pub const GS_COMPATIBILITY_VALUE_1_1_106: u32 = 0;
177pub const GS_COMPATIBILITY_MULTIPLE_CONTAINERS_1_1_106: u32 = 0;
178pub const GS_COMPATIBILITY_DEPRECATE_FETCH_OPTION_SIZE: u32 = 1;
179pub const GS_COMPATIBILITY_SUPPORT_1_5: u32 = 1;
180pub const GS_COMPATIBILITY_SUPPORT_2_0: u32 = 1;
181pub const GS_COMPATIBILITY_SUPPORT_2_1: u32 = 1;
182pub const GS_COMPATIBILITY_SUPPORT_3_5: u32 = 1;
183pub const GS_COMPATIBILITY_SUPPORT_4_0: u32 = 1;
184pub const GS_COMPATIBILITY_SUPPORT_4_1: u32 = 1;
185pub const GS_COMPATIBILITY_SUPPORT_4_2: u32 = 1;
186pub const GS_COMPATIBILITY_SUPPORT_4_3: u32 = 1;
187pub const GS_TRUE: u32 = 1;
188pub const GS_FALSE: u32 = 0;
189pub const GS_RESULT_OK: u32 = 0;
190pub const GS_TIMESTAMP_DEFAULT: u32 = 0;
191pub const GS_TIME_STRING_SIZE_MAX: u32 = 32;
192pub const GS_TIME_ZONE_STRING_SIZE_MAX: u32 = 8;
193pub type size_t = ::std::os::raw::c_ulong;
194pub type wchar_t = ::std::os::raw::c_int;
195pub const idtype_t_P_ALL: idtype_t = 0;
196pub const idtype_t_P_PID: idtype_t = 1;
197pub const idtype_t_P_PGID: idtype_t = 2;
198pub type idtype_t = ::std::os::raw::c_uint;
199pub type _Float32 = f32;
200pub type _Float64 = f64;
201pub type _Float32x = f64;
202pub type _Float64x = u128;
203#[repr(C)]
204#[derive(Debug, Copy, Clone)]
205pub struct div_t {
206 pub quot: ::std::os::raw::c_int,
207 pub rem: ::std::os::raw::c_int,
208}
209#[test]
210fn bindgen_test_layout_div_t() {
211 assert_eq!(
212 ::std::mem::size_of::<div_t>(),
213 8usize,
214 concat!("Size of: ", stringify!(div_t))
215 );
216 assert_eq!(
217 ::std::mem::align_of::<div_t>(),
218 4usize,
219 concat!("Alignment of ", stringify!(div_t))
220 );
221 assert_eq!(
222 unsafe { &(*(::std::ptr::null::<div_t>())).quot as *const _ as usize },
223 0usize,
224 concat!(
225 "Offset of field: ",
226 stringify!(div_t),
227 "::",
228 stringify!(quot)
229 )
230 );
231 assert_eq!(
232 unsafe { &(*(::std::ptr::null::<div_t>())).rem as *const _ as usize },
233 4usize,
234 concat!(
235 "Offset of field: ",
236 stringify!(div_t),
237 "::",
238 stringify!(rem)
239 )
240 );
241}
242#[repr(C)]
243#[derive(Debug, Copy, Clone)]
244pub struct ldiv_t {
245 pub quot: ::std::os::raw::c_long,
246 pub rem: ::std::os::raw::c_long,
247}
248#[test]
249fn bindgen_test_layout_ldiv_t() {
250 assert_eq!(
251 ::std::mem::size_of::<ldiv_t>(),
252 16usize,
253 concat!("Size of: ", stringify!(ldiv_t))
254 );
255 assert_eq!(
256 ::std::mem::align_of::<ldiv_t>(),
257 8usize,
258 concat!("Alignment of ", stringify!(ldiv_t))
259 );
260 assert_eq!(
261 unsafe { &(*(::std::ptr::null::<ldiv_t>())).quot as *const _ as usize },
262 0usize,
263 concat!(
264 "Offset of field: ",
265 stringify!(ldiv_t),
266 "::",
267 stringify!(quot)
268 )
269 );
270 assert_eq!(
271 unsafe { &(*(::std::ptr::null::<ldiv_t>())).rem as *const _ as usize },
272 8usize,
273 concat!(
274 "Offset of field: ",
275 stringify!(ldiv_t),
276 "::",
277 stringify!(rem)
278 )
279 );
280}
281#[repr(C)]
282#[derive(Debug, Copy, Clone)]
283pub struct lldiv_t {
284 pub quot: ::std::os::raw::c_longlong,
285 pub rem: ::std::os::raw::c_longlong,
286}
287#[test]
288fn bindgen_test_layout_lldiv_t() {
289 assert_eq!(
290 ::std::mem::size_of::<lldiv_t>(),
291 16usize,
292 concat!("Size of: ", stringify!(lldiv_t))
293 );
294 assert_eq!(
295 ::std::mem::align_of::<lldiv_t>(),
296 8usize,
297 concat!("Alignment of ", stringify!(lldiv_t))
298 );
299 assert_eq!(
300 unsafe { &(*(::std::ptr::null::<lldiv_t>())).quot as *const _ as usize },
301 0usize,
302 concat!(
303 "Offset of field: ",
304 stringify!(lldiv_t),
305 "::",
306 stringify!(quot)
307 )
308 );
309 assert_eq!(
310 unsafe { &(*(::std::ptr::null::<lldiv_t>())).rem as *const _ as usize },
311 8usize,
312 concat!(
313 "Offset of field: ",
314 stringify!(lldiv_t),
315 "::",
316 stringify!(rem)
317 )
318 );
319}
320extern "C" {
321 pub fn __ctype_get_mb_cur_max() -> size_t;
322}
323extern "C" {
324 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
325}
326extern "C" {
327 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
328}
329extern "C" {
330 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
331}
332extern "C" {
333 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
334}
335extern "C" {
336 pub fn strtod(
337 __nptr: *const ::std::os::raw::c_char,
338 __endptr: *mut *mut ::std::os::raw::c_char,
339 ) -> f64;
340}
341extern "C" {
342 pub fn strtof(
343 __nptr: *const ::std::os::raw::c_char,
344 __endptr: *mut *mut ::std::os::raw::c_char,
345 ) -> f32;
346}
347extern "C" {
348 pub fn strtold(
349 __nptr: *const ::std::os::raw::c_char,
350 __endptr: *mut *mut ::std::os::raw::c_char,
351 ) -> u128;
352}
353extern "C" {
354 pub fn strtol(
355 __nptr: *const ::std::os::raw::c_char,
356 __endptr: *mut *mut ::std::os::raw::c_char,
357 __base: ::std::os::raw::c_int,
358 ) -> ::std::os::raw::c_long;
359}
360extern "C" {
361 pub fn strtoul(
362 __nptr: *const ::std::os::raw::c_char,
363 __endptr: *mut *mut ::std::os::raw::c_char,
364 __base: ::std::os::raw::c_int,
365 ) -> ::std::os::raw::c_ulong;
366}
367extern "C" {
368 pub fn strtoq(
369 __nptr: *const ::std::os::raw::c_char,
370 __endptr: *mut *mut ::std::os::raw::c_char,
371 __base: ::std::os::raw::c_int,
372 ) -> ::std::os::raw::c_longlong;
373}
374extern "C" {
375 pub fn strtouq(
376 __nptr: *const ::std::os::raw::c_char,
377 __endptr: *mut *mut ::std::os::raw::c_char,
378 __base: ::std::os::raw::c_int,
379 ) -> ::std::os::raw::c_ulonglong;
380}
381extern "C" {
382 pub fn strtoll(
383 __nptr: *const ::std::os::raw::c_char,
384 __endptr: *mut *mut ::std::os::raw::c_char,
385 __base: ::std::os::raw::c_int,
386 ) -> ::std::os::raw::c_longlong;
387}
388extern "C" {
389 pub fn strtoull(
390 __nptr: *const ::std::os::raw::c_char,
391 __endptr: *mut *mut ::std::os::raw::c_char,
392 __base: ::std::os::raw::c_int,
393 ) -> ::std::os::raw::c_ulonglong;
394}
395extern "C" {
396 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
397}
398extern "C" {
399 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
400}
401pub type __u_char = ::std::os::raw::c_uchar;
402pub type __u_short = ::std::os::raw::c_ushort;
403pub type __u_int = ::std::os::raw::c_uint;
404pub type __u_long = ::std::os::raw::c_ulong;
405pub type __int8_t = ::std::os::raw::c_schar;
406pub type __uint8_t = ::std::os::raw::c_uchar;
407pub type __int16_t = ::std::os::raw::c_short;
408pub type __uint16_t = ::std::os::raw::c_ushort;
409pub type __int32_t = ::std::os::raw::c_int;
410pub type __uint32_t = ::std::os::raw::c_uint;
411pub type __int64_t = ::std::os::raw::c_long;
412pub type __uint64_t = ::std::os::raw::c_ulong;
413pub type __quad_t = ::std::os::raw::c_long;
414pub type __u_quad_t = ::std::os::raw::c_ulong;
415pub type __intmax_t = ::std::os::raw::c_long;
416pub type __uintmax_t = ::std::os::raw::c_ulong;
417pub type __dev_t = ::std::os::raw::c_ulong;
418pub type __uid_t = ::std::os::raw::c_uint;
419pub type __gid_t = ::std::os::raw::c_uint;
420pub type __ino_t = ::std::os::raw::c_ulong;
421pub type __ino64_t = ::std::os::raw::c_ulong;
422pub type __mode_t = ::std::os::raw::c_uint;
423pub type __nlink_t = ::std::os::raw::c_ulong;
424pub type __off_t = ::std::os::raw::c_long;
425pub type __off64_t = ::std::os::raw::c_long;
426pub type __pid_t = ::std::os::raw::c_int;
427#[repr(C)]
428#[derive(Debug, Copy, Clone)]
429pub struct __fsid_t {
430 pub __val: [::std::os::raw::c_int; 2usize],
431}
432#[test]
433fn bindgen_test_layout___fsid_t() {
434 assert_eq!(
435 ::std::mem::size_of::<__fsid_t>(),
436 8usize,
437 concat!("Size of: ", stringify!(__fsid_t))
438 );
439 assert_eq!(
440 ::std::mem::align_of::<__fsid_t>(),
441 4usize,
442 concat!("Alignment of ", stringify!(__fsid_t))
443 );
444 assert_eq!(
445 unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
446 0usize,
447 concat!(
448 "Offset of field: ",
449 stringify!(__fsid_t),
450 "::",
451 stringify!(__val)
452 )
453 );
454}
455pub type __clock_t = ::std::os::raw::c_long;
456pub type __rlim_t = ::std::os::raw::c_ulong;
457pub type __rlim64_t = ::std::os::raw::c_ulong;
458pub type __id_t = ::std::os::raw::c_uint;
459pub type __time_t = ::std::os::raw::c_long;
460pub type __useconds_t = ::std::os::raw::c_uint;
461pub type __suseconds_t = ::std::os::raw::c_long;
462pub type __daddr_t = ::std::os::raw::c_int;
463pub type __key_t = ::std::os::raw::c_int;
464pub type __clockid_t = ::std::os::raw::c_int;
465pub type __timer_t = *mut ::std::os::raw::c_void;
466pub type __blksize_t = ::std::os::raw::c_long;
467pub type __blkcnt_t = ::std::os::raw::c_long;
468pub type __blkcnt64_t = ::std::os::raw::c_long;
469pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
470pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
471pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
472pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
473pub type __fsword_t = ::std::os::raw::c_long;
474pub type __ssize_t = ::std::os::raw::c_long;
475pub type __syscall_slong_t = ::std::os::raw::c_long;
476pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
477pub type __loff_t = __off64_t;
478pub type __caddr_t = *mut ::std::os::raw::c_char;
479pub type __intptr_t = ::std::os::raw::c_long;
480pub type __socklen_t = ::std::os::raw::c_uint;
481pub type __sig_atomic_t = ::std::os::raw::c_int;
482pub type u_char = __u_char;
483pub type u_short = __u_short;
484pub type u_int = __u_int;
485pub type u_long = __u_long;
486pub type quad_t = __quad_t;
487pub type u_quad_t = __u_quad_t;
488pub type fsid_t = __fsid_t;
489pub type loff_t = __loff_t;
490pub type ino_t = __ino_t;
491pub type dev_t = __dev_t;
492pub type gid_t = __gid_t;
493pub type mode_t = __mode_t;
494pub type nlink_t = __nlink_t;
495pub type uid_t = __uid_t;
496pub type off_t = __off_t;
497pub type pid_t = __pid_t;
498pub type id_t = __id_t;
499pub type ssize_t = __ssize_t;
500pub type daddr_t = __daddr_t;
501pub type caddr_t = __caddr_t;
502pub type key_t = __key_t;
503pub type clock_t = __clock_t;
504pub type clockid_t = __clockid_t;
505pub type time_t = __time_t;
506pub type timer_t = __timer_t;
507pub type ulong = ::std::os::raw::c_ulong;
508pub type ushort = ::std::os::raw::c_ushort;
509pub type uint = ::std::os::raw::c_uint;
510pub type u_int8_t = ::std::os::raw::c_uchar;
511pub type u_int16_t = ::std::os::raw::c_ushort;
512pub type u_int32_t = ::std::os::raw::c_uint;
513pub type u_int64_t = ::std::os::raw::c_ulong;
514pub type register_t = ::std::os::raw::c_long;
515#[repr(C)]
516#[derive(Debug, Copy, Clone)]
517pub struct __sigset_t {
518 pub __val: [::std::os::raw::c_ulong; 16usize],
519}
520#[test]
521fn bindgen_test_layout___sigset_t() {
522 assert_eq!(
523 ::std::mem::size_of::<__sigset_t>(),
524 128usize,
525 concat!("Size of: ", stringify!(__sigset_t))
526 );
527 assert_eq!(
528 ::std::mem::align_of::<__sigset_t>(),
529 8usize,
530 concat!("Alignment of ", stringify!(__sigset_t))
531 );
532 assert_eq!(
533 unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
534 0usize,
535 concat!(
536 "Offset of field: ",
537 stringify!(__sigset_t),
538 "::",
539 stringify!(__val)
540 )
541 );
542}
543pub type sigset_t = __sigset_t;
544#[repr(C)]
545#[derive(Debug, Copy, Clone)]
546pub struct timeval {
547 pub tv_sec: __time_t,
548 pub tv_usec: __suseconds_t,
549}
550#[test]
551fn bindgen_test_layout_timeval() {
552 assert_eq!(
553 ::std::mem::size_of::<timeval>(),
554 16usize,
555 concat!("Size of: ", stringify!(timeval))
556 );
557 assert_eq!(
558 ::std::mem::align_of::<timeval>(),
559 8usize,
560 concat!("Alignment of ", stringify!(timeval))
561 );
562 assert_eq!(
563 unsafe { &(*(::std::ptr::null::<timeval>())).tv_sec as *const _ as usize },
564 0usize,
565 concat!(
566 "Offset of field: ",
567 stringify!(timeval),
568 "::",
569 stringify!(tv_sec)
570 )
571 );
572 assert_eq!(
573 unsafe { &(*(::std::ptr::null::<timeval>())).tv_usec as *const _ as usize },
574 8usize,
575 concat!(
576 "Offset of field: ",
577 stringify!(timeval),
578 "::",
579 stringify!(tv_usec)
580 )
581 );
582}
583#[repr(C)]
584#[derive(Debug, Copy, Clone)]
585pub struct timespec {
586 pub tv_sec: __time_t,
587 pub tv_nsec: __syscall_slong_t,
588}
589#[test]
590fn bindgen_test_layout_timespec() {
591 assert_eq!(
592 ::std::mem::size_of::<timespec>(),
593 16usize,
594 concat!("Size of: ", stringify!(timespec))
595 );
596 assert_eq!(
597 ::std::mem::align_of::<timespec>(),
598 8usize,
599 concat!("Alignment of ", stringify!(timespec))
600 );
601 assert_eq!(
602 unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize },
603 0usize,
604 concat!(
605 "Offset of field: ",
606 stringify!(timespec),
607 "::",
608 stringify!(tv_sec)
609 )
610 );
611 assert_eq!(
612 unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
613 8usize,
614 concat!(
615 "Offset of field: ",
616 stringify!(timespec),
617 "::",
618 stringify!(tv_nsec)
619 )
620 );
621}
622pub type suseconds_t = __suseconds_t;
623pub type __fd_mask = ::std::os::raw::c_long;
624#[repr(C)]
625#[derive(Debug, Copy, Clone)]
626pub struct fd_set {
627 pub __fds_bits: [__fd_mask; 16usize],
628}
629#[test]
630fn bindgen_test_layout_fd_set() {
631 assert_eq!(
632 ::std::mem::size_of::<fd_set>(),
633 128usize,
634 concat!("Size of: ", stringify!(fd_set))
635 );
636 assert_eq!(
637 ::std::mem::align_of::<fd_set>(),
638 8usize,
639 concat!("Alignment of ", stringify!(fd_set))
640 );
641 assert_eq!(
642 unsafe { &(*(::std::ptr::null::<fd_set>())).__fds_bits as *const _ as usize },
643 0usize,
644 concat!(
645 "Offset of field: ",
646 stringify!(fd_set),
647 "::",
648 stringify!(__fds_bits)
649 )
650 );
651}
652pub type fd_mask = __fd_mask;
653extern "C" {
654 pub fn select(
655 __nfds: ::std::os::raw::c_int,
656 __readfds: *mut fd_set,
657 __writefds: *mut fd_set,
658 __exceptfds: *mut fd_set,
659 __timeout: *mut timeval,
660 ) -> ::std::os::raw::c_int;
661}
662extern "C" {
663 pub fn pselect(
664 __nfds: ::std::os::raw::c_int,
665 __readfds: *mut fd_set,
666 __writefds: *mut fd_set,
667 __exceptfds: *mut fd_set,
668 __timeout: *const timespec,
669 __sigmask: *const __sigset_t,
670 ) -> ::std::os::raw::c_int;
671}
672extern "C" {
673 pub fn gnu_dev_major(__dev: __dev_t) -> ::std::os::raw::c_uint;
674}
675extern "C" {
676 pub fn gnu_dev_minor(__dev: __dev_t) -> ::std::os::raw::c_uint;
677}
678extern "C" {
679 pub fn gnu_dev_makedev(
680 __major: ::std::os::raw::c_uint,
681 __minor: ::std::os::raw::c_uint,
682 ) -> __dev_t;
683}
684pub type blksize_t = __blksize_t;
685pub type blkcnt_t = __blkcnt_t;
686pub type fsblkcnt_t = __fsblkcnt_t;
687pub type fsfilcnt_t = __fsfilcnt_t;
688#[repr(C)]
689#[derive(Debug, Copy, Clone)]
690pub struct __pthread_rwlock_arch_t {
691 pub __readers: ::std::os::raw::c_uint,
692 pub __writers: ::std::os::raw::c_uint,
693 pub __wrphase_futex: ::std::os::raw::c_uint,
694 pub __writers_futex: ::std::os::raw::c_uint,
695 pub __pad3: ::std::os::raw::c_uint,
696 pub __pad4: ::std::os::raw::c_uint,
697 pub __cur_writer: ::std::os::raw::c_int,
698 pub __shared: ::std::os::raw::c_int,
699 pub __rwelision: ::std::os::raw::c_schar,
700 pub __pad1: [::std::os::raw::c_uchar; 7usize],
701 pub __pad2: ::std::os::raw::c_ulong,
702 pub __flags: ::std::os::raw::c_uint,
703}
704#[test]
705fn bindgen_test_layout___pthread_rwlock_arch_t() {
706 assert_eq!(
707 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
708 56usize,
709 concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
710 );
711 assert_eq!(
712 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
713 8usize,
714 concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
715 );
716 assert_eq!(
717 unsafe {
718 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
719 },
720 0usize,
721 concat!(
722 "Offset of field: ",
723 stringify!(__pthread_rwlock_arch_t),
724 "::",
725 stringify!(__readers)
726 )
727 );
728 assert_eq!(
729 unsafe {
730 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
731 },
732 4usize,
733 concat!(
734 "Offset of field: ",
735 stringify!(__pthread_rwlock_arch_t),
736 "::",
737 stringify!(__writers)
738 )
739 );
740 assert_eq!(
741 unsafe {
742 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _ as usize
743 },
744 8usize,
745 concat!(
746 "Offset of field: ",
747 stringify!(__pthread_rwlock_arch_t),
748 "::",
749 stringify!(__wrphase_futex)
750 )
751 );
752 assert_eq!(
753 unsafe {
754 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _ as usize
755 },
756 12usize,
757 concat!(
758 "Offset of field: ",
759 stringify!(__pthread_rwlock_arch_t),
760 "::",
761 stringify!(__writers_futex)
762 )
763 );
764 assert_eq!(
765 unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
766 16usize,
767 concat!(
768 "Offset of field: ",
769 stringify!(__pthread_rwlock_arch_t),
770 "::",
771 stringify!(__pad3)
772 )
773 );
774 assert_eq!(
775 unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
776 20usize,
777 concat!(
778 "Offset of field: ",
779 stringify!(__pthread_rwlock_arch_t),
780 "::",
781 stringify!(__pad4)
782 )
783 );
784 assert_eq!(
785 unsafe {
786 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
787 },
788 24usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(__pthread_rwlock_arch_t),
792 "::",
793 stringify!(__cur_writer)
794 )
795 );
796 assert_eq!(
797 unsafe {
798 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
799 },
800 28usize,
801 concat!(
802 "Offset of field: ",
803 stringify!(__pthread_rwlock_arch_t),
804 "::",
805 stringify!(__shared)
806 )
807 );
808 assert_eq!(
809 unsafe {
810 &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
811 },
812 32usize,
813 concat!(
814 "Offset of field: ",
815 stringify!(__pthread_rwlock_arch_t),
816 "::",
817 stringify!(__rwelision)
818 )
819 );
820 assert_eq!(
821 unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
822 33usize,
823 concat!(
824 "Offset of field: ",
825 stringify!(__pthread_rwlock_arch_t),
826 "::",
827 stringify!(__pad1)
828 )
829 );
830 assert_eq!(
831 unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
832 40usize,
833 concat!(
834 "Offset of field: ",
835 stringify!(__pthread_rwlock_arch_t),
836 "::",
837 stringify!(__pad2)
838 )
839 );
840 assert_eq!(
841 unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize },
842 48usize,
843 concat!(
844 "Offset of field: ",
845 stringify!(__pthread_rwlock_arch_t),
846 "::",
847 stringify!(__flags)
848 )
849 );
850}
851#[repr(C)]
852#[derive(Debug, Copy, Clone)]
853pub struct __pthread_internal_list {
854 pub __prev: *mut __pthread_internal_list,
855 pub __next: *mut __pthread_internal_list,
856}
857#[test]
858fn bindgen_test_layout___pthread_internal_list() {
859 assert_eq!(
860 ::std::mem::size_of::<__pthread_internal_list>(),
861 16usize,
862 concat!("Size of: ", stringify!(__pthread_internal_list))
863 );
864 assert_eq!(
865 ::std::mem::align_of::<__pthread_internal_list>(),
866 8usize,
867 concat!("Alignment of ", stringify!(__pthread_internal_list))
868 );
869 assert_eq!(
870 unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
871 0usize,
872 concat!(
873 "Offset of field: ",
874 stringify!(__pthread_internal_list),
875 "::",
876 stringify!(__prev)
877 )
878 );
879 assert_eq!(
880 unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
881 8usize,
882 concat!(
883 "Offset of field: ",
884 stringify!(__pthread_internal_list),
885 "::",
886 stringify!(__next)
887 )
888 );
889}
890pub type __pthread_list_t = __pthread_internal_list;
891#[repr(C)]
892#[derive(Debug, Copy, Clone)]
893pub struct __pthread_mutex_s {
894 pub __lock: ::std::os::raw::c_int,
895 pub __count: ::std::os::raw::c_uint,
896 pub __owner: ::std::os::raw::c_int,
897 pub __nusers: ::std::os::raw::c_uint,
898 pub __kind: ::std::os::raw::c_int,
899 pub __spins: ::std::os::raw::c_short,
900 pub __elision: ::std::os::raw::c_short,
901 pub __list: __pthread_list_t,
902}
903#[test]
904fn bindgen_test_layout___pthread_mutex_s() {
905 assert_eq!(
906 ::std::mem::size_of::<__pthread_mutex_s>(),
907 40usize,
908 concat!("Size of: ", stringify!(__pthread_mutex_s))
909 );
910 assert_eq!(
911 ::std::mem::align_of::<__pthread_mutex_s>(),
912 8usize,
913 concat!("Alignment of ", stringify!(__pthread_mutex_s))
914 );
915 assert_eq!(
916 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
917 0usize,
918 concat!(
919 "Offset of field: ",
920 stringify!(__pthread_mutex_s),
921 "::",
922 stringify!(__lock)
923 )
924 );
925 assert_eq!(
926 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
927 4usize,
928 concat!(
929 "Offset of field: ",
930 stringify!(__pthread_mutex_s),
931 "::",
932 stringify!(__count)
933 )
934 );
935 assert_eq!(
936 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
937 8usize,
938 concat!(
939 "Offset of field: ",
940 stringify!(__pthread_mutex_s),
941 "::",
942 stringify!(__owner)
943 )
944 );
945 assert_eq!(
946 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
947 12usize,
948 concat!(
949 "Offset of field: ",
950 stringify!(__pthread_mutex_s),
951 "::",
952 stringify!(__nusers)
953 )
954 );
955 assert_eq!(
956 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
957 16usize,
958 concat!(
959 "Offset of field: ",
960 stringify!(__pthread_mutex_s),
961 "::",
962 stringify!(__kind)
963 )
964 );
965 assert_eq!(
966 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
967 20usize,
968 concat!(
969 "Offset of field: ",
970 stringify!(__pthread_mutex_s),
971 "::",
972 stringify!(__spins)
973 )
974 );
975 assert_eq!(
976 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
977 22usize,
978 concat!(
979 "Offset of field: ",
980 stringify!(__pthread_mutex_s),
981 "::",
982 stringify!(__elision)
983 )
984 );
985 assert_eq!(
986 unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
987 24usize,
988 concat!(
989 "Offset of field: ",
990 stringify!(__pthread_mutex_s),
991 "::",
992 stringify!(__list)
993 )
994 );
995}
996#[repr(C)]
997#[derive(Copy, Clone)]
998pub struct __pthread_cond_s {
999 pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
1000 pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
1001 pub __g_refs: [::std::os::raw::c_uint; 2usize],
1002 pub __g_size: [::std::os::raw::c_uint; 2usize],
1003 pub __g1_orig_size: ::std::os::raw::c_uint,
1004 pub __wrefs: ::std::os::raw::c_uint,
1005 pub __g_signals: [::std::os::raw::c_uint; 2usize],
1006}
1007#[repr(C)]
1008#[derive(Copy, Clone)]
1009pub union __pthread_cond_s__bindgen_ty_1 {
1010 pub __wseq: ::std::os::raw::c_ulonglong,
1011 pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
1012}
1013#[repr(C)]
1014#[derive(Debug, Copy, Clone)]
1015pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
1016 pub __low: ::std::os::raw::c_uint,
1017 pub __high: ::std::os::raw::c_uint,
1018}
1019#[test]
1020fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
1021 assert_eq!(
1022 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
1023 8usize,
1024 concat!(
1025 "Size of: ",
1026 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
1027 )
1028 );
1029 assert_eq!(
1030 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
1031 4usize,
1032 concat!(
1033 "Alignment of ",
1034 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
1035 )
1036 );
1037 assert_eq!(
1038 unsafe {
1039 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
1040 as *const _ as usize
1041 },
1042 0usize,
1043 concat!(
1044 "Offset of field: ",
1045 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
1046 "::",
1047 stringify!(__low)
1048 )
1049 );
1050 assert_eq!(
1051 unsafe {
1052 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
1053 as *const _ as usize
1054 },
1055 4usize,
1056 concat!(
1057 "Offset of field: ",
1058 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
1059 "::",
1060 stringify!(__high)
1061 )
1062 );
1063}
1064#[test]
1065fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
1066 assert_eq!(
1067 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
1068 8usize,
1069 concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
1070 );
1071 assert_eq!(
1072 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
1073 8usize,
1074 concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
1075 );
1076 assert_eq!(
1077 unsafe {
1078 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
1079 },
1080 0usize,
1081 concat!(
1082 "Offset of field: ",
1083 stringify!(__pthread_cond_s__bindgen_ty_1),
1084 "::",
1085 stringify!(__wseq)
1086 )
1087 );
1088 assert_eq!(
1089 unsafe {
1090 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ as usize
1091 },
1092 0usize,
1093 concat!(
1094 "Offset of field: ",
1095 stringify!(__pthread_cond_s__bindgen_ty_1),
1096 "::",
1097 stringify!(__wseq32)
1098 )
1099 );
1100}
1101#[repr(C)]
1102#[derive(Copy, Clone)]
1103pub union __pthread_cond_s__bindgen_ty_2 {
1104 pub __g1_start: ::std::os::raw::c_ulonglong,
1105 pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
1106}
1107#[repr(C)]
1108#[derive(Debug, Copy, Clone)]
1109pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
1110 pub __low: ::std::os::raw::c_uint,
1111 pub __high: ::std::os::raw::c_uint,
1112}
1113#[test]
1114fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
1115 assert_eq!(
1116 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
1117 8usize,
1118 concat!(
1119 "Size of: ",
1120 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
1121 )
1122 );
1123 assert_eq!(
1124 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
1125 4usize,
1126 concat!(
1127 "Alignment of ",
1128 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
1129 )
1130 );
1131 assert_eq!(
1132 unsafe {
1133 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
1134 as *const _ as usize
1135 },
1136 0usize,
1137 concat!(
1138 "Offset of field: ",
1139 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
1140 "::",
1141 stringify!(__low)
1142 )
1143 );
1144 assert_eq!(
1145 unsafe {
1146 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
1147 as *const _ as usize
1148 },
1149 4usize,
1150 concat!(
1151 "Offset of field: ",
1152 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
1153 "::",
1154 stringify!(__high)
1155 )
1156 );
1157}
1158#[test]
1159fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
1160 assert_eq!(
1161 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
1162 8usize,
1163 concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
1164 );
1165 assert_eq!(
1166 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
1167 8usize,
1168 concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
1169 );
1170 assert_eq!(
1171 unsafe {
1172 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
1173 as usize
1174 },
1175 0usize,
1176 concat!(
1177 "Offset of field: ",
1178 stringify!(__pthread_cond_s__bindgen_ty_2),
1179 "::",
1180 stringify!(__g1_start)
1181 )
1182 );
1183 assert_eq!(
1184 unsafe {
1185 &(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
1186 as usize
1187 },
1188 0usize,
1189 concat!(
1190 "Offset of field: ",
1191 stringify!(__pthread_cond_s__bindgen_ty_2),
1192 "::",
1193 stringify!(__g1_start32)
1194 )
1195 );
1196}
1197#[test]
1198fn bindgen_test_layout___pthread_cond_s() {
1199 assert_eq!(
1200 ::std::mem::size_of::<__pthread_cond_s>(),
1201 48usize,
1202 concat!("Size of: ", stringify!(__pthread_cond_s))
1203 );
1204 assert_eq!(
1205 ::std::mem::align_of::<__pthread_cond_s>(),
1206 8usize,
1207 concat!("Alignment of ", stringify!(__pthread_cond_s))
1208 );
1209 assert_eq!(
1210 unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
1211 16usize,
1212 concat!(
1213 "Offset of field: ",
1214 stringify!(__pthread_cond_s),
1215 "::",
1216 stringify!(__g_refs)
1217 )
1218 );
1219 assert_eq!(
1220 unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
1221 24usize,
1222 concat!(
1223 "Offset of field: ",
1224 stringify!(__pthread_cond_s),
1225 "::",
1226 stringify!(__g_size)
1227 )
1228 );
1229 assert_eq!(
1230 unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize },
1231 32usize,
1232 concat!(
1233 "Offset of field: ",
1234 stringify!(__pthread_cond_s),
1235 "::",
1236 stringify!(__g1_orig_size)
1237 )
1238 );
1239 assert_eq!(
1240 unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
1241 36usize,
1242 concat!(
1243 "Offset of field: ",
1244 stringify!(__pthread_cond_s),
1245 "::",
1246 stringify!(__wrefs)
1247 )
1248 );
1249 assert_eq!(
1250 unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
1251 40usize,
1252 concat!(
1253 "Offset of field: ",
1254 stringify!(__pthread_cond_s),
1255 "::",
1256 stringify!(__g_signals)
1257 )
1258 );
1259}
1260pub type pthread_t = ::std::os::raw::c_ulong;
1261#[repr(C)]
1262#[derive(Copy, Clone)]
1263pub union pthread_mutexattr_t {
1264 pub __size: [::std::os::raw::c_char; 4usize],
1265 pub __align: ::std::os::raw::c_int,
1266}
1267#[test]
1268fn bindgen_test_layout_pthread_mutexattr_t() {
1269 assert_eq!(
1270 ::std::mem::size_of::<pthread_mutexattr_t>(),
1271 4usize,
1272 concat!("Size of: ", stringify!(pthread_mutexattr_t))
1273 );
1274 assert_eq!(
1275 ::std::mem::align_of::<pthread_mutexattr_t>(),
1276 4usize,
1277 concat!("Alignment of ", stringify!(pthread_mutexattr_t))
1278 );
1279 assert_eq!(
1280 unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
1281 0usize,
1282 concat!(
1283 "Offset of field: ",
1284 stringify!(pthread_mutexattr_t),
1285 "::",
1286 stringify!(__size)
1287 )
1288 );
1289 assert_eq!(
1290 unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
1291 0usize,
1292 concat!(
1293 "Offset of field: ",
1294 stringify!(pthread_mutexattr_t),
1295 "::",
1296 stringify!(__align)
1297 )
1298 );
1299}
1300#[repr(C)]
1301#[derive(Copy, Clone)]
1302pub union pthread_condattr_t {
1303 pub __size: [::std::os::raw::c_char; 4usize],
1304 pub __align: ::std::os::raw::c_int,
1305}
1306#[test]
1307fn bindgen_test_layout_pthread_condattr_t() {
1308 assert_eq!(
1309 ::std::mem::size_of::<pthread_condattr_t>(),
1310 4usize,
1311 concat!("Size of: ", stringify!(pthread_condattr_t))
1312 );
1313 assert_eq!(
1314 ::std::mem::align_of::<pthread_condattr_t>(),
1315 4usize,
1316 concat!("Alignment of ", stringify!(pthread_condattr_t))
1317 );
1318 assert_eq!(
1319 unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
1320 0usize,
1321 concat!(
1322 "Offset of field: ",
1323 stringify!(pthread_condattr_t),
1324 "::",
1325 stringify!(__size)
1326 )
1327 );
1328 assert_eq!(
1329 unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
1330 0usize,
1331 concat!(
1332 "Offset of field: ",
1333 stringify!(pthread_condattr_t),
1334 "::",
1335 stringify!(__align)
1336 )
1337 );
1338}
1339pub type pthread_key_t = ::std::os::raw::c_uint;
1340pub type pthread_once_t = ::std::os::raw::c_int;
1341#[repr(C)]
1342#[derive(Copy, Clone)]
1343pub union pthread_attr_t {
1344 pub __size: [::std::os::raw::c_char; 56usize],
1345 pub __align: ::std::os::raw::c_long,
1346}
1347#[test]
1348fn bindgen_test_layout_pthread_attr_t() {
1349 assert_eq!(
1350 ::std::mem::size_of::<pthread_attr_t>(),
1351 56usize,
1352 concat!("Size of: ", stringify!(pthread_attr_t))
1353 );
1354 assert_eq!(
1355 ::std::mem::align_of::<pthread_attr_t>(),
1356 8usize,
1357 concat!("Alignment of ", stringify!(pthread_attr_t))
1358 );
1359 assert_eq!(
1360 unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
1361 0usize,
1362 concat!(
1363 "Offset of field: ",
1364 stringify!(pthread_attr_t),
1365 "::",
1366 stringify!(__size)
1367 )
1368 );
1369 assert_eq!(
1370 unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
1371 0usize,
1372 concat!(
1373 "Offset of field: ",
1374 stringify!(pthread_attr_t),
1375 "::",
1376 stringify!(__align)
1377 )
1378 );
1379}
1380#[repr(C)]
1381#[derive(Copy, Clone)]
1382pub union pthread_mutex_t {
1383 pub __data: __pthread_mutex_s,
1384 pub __size: [::std::os::raw::c_char; 40usize],
1385 pub __align: ::std::os::raw::c_long,
1386}
1387#[test]
1388fn bindgen_test_layout_pthread_mutex_t() {
1389 assert_eq!(
1390 ::std::mem::size_of::<pthread_mutex_t>(),
1391 40usize,
1392 concat!("Size of: ", stringify!(pthread_mutex_t))
1393 );
1394 assert_eq!(
1395 ::std::mem::align_of::<pthread_mutex_t>(),
1396 8usize,
1397 concat!("Alignment of ", stringify!(pthread_mutex_t))
1398 );
1399 assert_eq!(
1400 unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
1401 0usize,
1402 concat!(
1403 "Offset of field: ",
1404 stringify!(pthread_mutex_t),
1405 "::",
1406 stringify!(__data)
1407 )
1408 );
1409 assert_eq!(
1410 unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
1411 0usize,
1412 concat!(
1413 "Offset of field: ",
1414 stringify!(pthread_mutex_t),
1415 "::",
1416 stringify!(__size)
1417 )
1418 );
1419 assert_eq!(
1420 unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
1421 0usize,
1422 concat!(
1423 "Offset of field: ",
1424 stringify!(pthread_mutex_t),
1425 "::",
1426 stringify!(__align)
1427 )
1428 );
1429}
1430#[repr(C)]
1431#[derive(Copy, Clone)]
1432pub union pthread_cond_t {
1433 pub __data: __pthread_cond_s,
1434 pub __size: [::std::os::raw::c_char; 48usize],
1435 pub __align: ::std::os::raw::c_longlong,
1436}
1437#[test]
1438fn bindgen_test_layout_pthread_cond_t() {
1439 assert_eq!(
1440 ::std::mem::size_of::<pthread_cond_t>(),
1441 48usize,
1442 concat!("Size of: ", stringify!(pthread_cond_t))
1443 );
1444 assert_eq!(
1445 ::std::mem::align_of::<pthread_cond_t>(),
1446 8usize,
1447 concat!("Alignment of ", stringify!(pthread_cond_t))
1448 );
1449 assert_eq!(
1450 unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
1451 0usize,
1452 concat!(
1453 "Offset of field: ",
1454 stringify!(pthread_cond_t),
1455 "::",
1456 stringify!(__data)
1457 )
1458 );
1459 assert_eq!(
1460 unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
1461 0usize,
1462 concat!(
1463 "Offset of field: ",
1464 stringify!(pthread_cond_t),
1465 "::",
1466 stringify!(__size)
1467 )
1468 );
1469 assert_eq!(
1470 unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
1471 0usize,
1472 concat!(
1473 "Offset of field: ",
1474 stringify!(pthread_cond_t),
1475 "::",
1476 stringify!(__align)
1477 )
1478 );
1479}
1480#[repr(C)]
1481#[derive(Copy, Clone)]
1482pub union pthread_rwlock_t {
1483 pub __data: __pthread_rwlock_arch_t,
1484 pub __size: [::std::os::raw::c_char; 56usize],
1485 pub __align: ::std::os::raw::c_long,
1486}
1487#[test]
1488fn bindgen_test_layout_pthread_rwlock_t() {
1489 assert_eq!(
1490 ::std::mem::size_of::<pthread_rwlock_t>(),
1491 56usize,
1492 concat!("Size of: ", stringify!(pthread_rwlock_t))
1493 );
1494 assert_eq!(
1495 ::std::mem::align_of::<pthread_rwlock_t>(),
1496 8usize,
1497 concat!("Alignment of ", stringify!(pthread_rwlock_t))
1498 );
1499 assert_eq!(
1500 unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
1501 0usize,
1502 concat!(
1503 "Offset of field: ",
1504 stringify!(pthread_rwlock_t),
1505 "::",
1506 stringify!(__data)
1507 )
1508 );
1509 assert_eq!(
1510 unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
1511 0usize,
1512 concat!(
1513 "Offset of field: ",
1514 stringify!(pthread_rwlock_t),
1515 "::",
1516 stringify!(__size)
1517 )
1518 );
1519 assert_eq!(
1520 unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
1521 0usize,
1522 concat!(
1523 "Offset of field: ",
1524 stringify!(pthread_rwlock_t),
1525 "::",
1526 stringify!(__align)
1527 )
1528 );
1529}
1530#[repr(C)]
1531#[derive(Copy, Clone)]
1532pub union pthread_rwlockattr_t {
1533 pub __size: [::std::os::raw::c_char; 8usize],
1534 pub __align: ::std::os::raw::c_long,
1535}
1536#[test]
1537fn bindgen_test_layout_pthread_rwlockattr_t() {
1538 assert_eq!(
1539 ::std::mem::size_of::<pthread_rwlockattr_t>(),
1540 8usize,
1541 concat!("Size of: ", stringify!(pthread_rwlockattr_t))
1542 );
1543 assert_eq!(
1544 ::std::mem::align_of::<pthread_rwlockattr_t>(),
1545 8usize,
1546 concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
1547 );
1548 assert_eq!(
1549 unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
1550 0usize,
1551 concat!(
1552 "Offset of field: ",
1553 stringify!(pthread_rwlockattr_t),
1554 "::",
1555 stringify!(__size)
1556 )
1557 );
1558 assert_eq!(
1559 unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
1560 0usize,
1561 concat!(
1562 "Offset of field: ",
1563 stringify!(pthread_rwlockattr_t),
1564 "::",
1565 stringify!(__align)
1566 )
1567 );
1568}
1569pub type pthread_spinlock_t = ::std::os::raw::c_int;
1570#[repr(C)]
1571#[derive(Copy, Clone)]
1572pub union pthread_barrier_t {
1573 pub __size: [::std::os::raw::c_char; 32usize],
1574 pub __align: ::std::os::raw::c_long,
1575}
1576#[test]
1577fn bindgen_test_layout_pthread_barrier_t() {
1578 assert_eq!(
1579 ::std::mem::size_of::<pthread_barrier_t>(),
1580 32usize,
1581 concat!("Size of: ", stringify!(pthread_barrier_t))
1582 );
1583 assert_eq!(
1584 ::std::mem::align_of::<pthread_barrier_t>(),
1585 8usize,
1586 concat!("Alignment of ", stringify!(pthread_barrier_t))
1587 );
1588 assert_eq!(
1589 unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
1590 0usize,
1591 concat!(
1592 "Offset of field: ",
1593 stringify!(pthread_barrier_t),
1594 "::",
1595 stringify!(__size)
1596 )
1597 );
1598 assert_eq!(
1599 unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
1600 0usize,
1601 concat!(
1602 "Offset of field: ",
1603 stringify!(pthread_barrier_t),
1604 "::",
1605 stringify!(__align)
1606 )
1607 );
1608}
1609#[repr(C)]
1610#[derive(Copy, Clone)]
1611pub union pthread_barrierattr_t {
1612 pub __size: [::std::os::raw::c_char; 4usize],
1613 pub __align: ::std::os::raw::c_int,
1614}
1615#[test]
1616fn bindgen_test_layout_pthread_barrierattr_t() {
1617 assert_eq!(
1618 ::std::mem::size_of::<pthread_barrierattr_t>(),
1619 4usize,
1620 concat!("Size of: ", stringify!(pthread_barrierattr_t))
1621 );
1622 assert_eq!(
1623 ::std::mem::align_of::<pthread_barrierattr_t>(),
1624 4usize,
1625 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
1626 );
1627 assert_eq!(
1628 unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
1629 0usize,
1630 concat!(
1631 "Offset of field: ",
1632 stringify!(pthread_barrierattr_t),
1633 "::",
1634 stringify!(__size)
1635 )
1636 );
1637 assert_eq!(
1638 unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
1639 0usize,
1640 concat!(
1641 "Offset of field: ",
1642 stringify!(pthread_barrierattr_t),
1643 "::",
1644 stringify!(__align)
1645 )
1646 );
1647}
1648extern "C" {
1649 pub fn random() -> ::std::os::raw::c_long;
1650}
1651extern "C" {
1652 pub fn srandom(__seed: ::std::os::raw::c_uint);
1653}
1654extern "C" {
1655 pub fn initstate(
1656 __seed: ::std::os::raw::c_uint,
1657 __statebuf: *mut ::std::os::raw::c_char,
1658 __statelen: size_t,
1659 ) -> *mut ::std::os::raw::c_char;
1660}
1661extern "C" {
1662 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1663}
1664#[repr(C)]
1665#[derive(Debug, Copy, Clone)]
1666pub struct random_data {
1667 pub fptr: *mut i32,
1668 pub rptr: *mut i32,
1669 pub state: *mut i32,
1670 pub rand_type: ::std::os::raw::c_int,
1671 pub rand_deg: ::std::os::raw::c_int,
1672 pub rand_sep: ::std::os::raw::c_int,
1673 pub end_ptr: *mut i32,
1674}
1675#[test]
1676fn bindgen_test_layout_random_data() {
1677 assert_eq!(
1678 ::std::mem::size_of::<random_data>(),
1679 48usize,
1680 concat!("Size of: ", stringify!(random_data))
1681 );
1682 assert_eq!(
1683 ::std::mem::align_of::<random_data>(),
1684 8usize,
1685 concat!("Alignment of ", stringify!(random_data))
1686 );
1687 assert_eq!(
1688 unsafe { &(*(::std::ptr::null::<random_data>())).fptr as *const _ as usize },
1689 0usize,
1690 concat!(
1691 "Offset of field: ",
1692 stringify!(random_data),
1693 "::",
1694 stringify!(fptr)
1695 )
1696 );
1697 assert_eq!(
1698 unsafe { &(*(::std::ptr::null::<random_data>())).rptr as *const _ as usize },
1699 8usize,
1700 concat!(
1701 "Offset of field: ",
1702 stringify!(random_data),
1703 "::",
1704 stringify!(rptr)
1705 )
1706 );
1707 assert_eq!(
1708 unsafe { &(*(::std::ptr::null::<random_data>())).state as *const _ as usize },
1709 16usize,
1710 concat!(
1711 "Offset of field: ",
1712 stringify!(random_data),
1713 "::",
1714 stringify!(state)
1715 )
1716 );
1717 assert_eq!(
1718 unsafe { &(*(::std::ptr::null::<random_data>())).rand_type as *const _ as usize },
1719 24usize,
1720 concat!(
1721 "Offset of field: ",
1722 stringify!(random_data),
1723 "::",
1724 stringify!(rand_type)
1725 )
1726 );
1727 assert_eq!(
1728 unsafe { &(*(::std::ptr::null::<random_data>())).rand_deg as *const _ as usize },
1729 28usize,
1730 concat!(
1731 "Offset of field: ",
1732 stringify!(random_data),
1733 "::",
1734 stringify!(rand_deg)
1735 )
1736 );
1737 assert_eq!(
1738 unsafe { &(*(::std::ptr::null::<random_data>())).rand_sep as *const _ as usize },
1739 32usize,
1740 concat!(
1741 "Offset of field: ",
1742 stringify!(random_data),
1743 "::",
1744 stringify!(rand_sep)
1745 )
1746 );
1747 assert_eq!(
1748 unsafe { &(*(::std::ptr::null::<random_data>())).end_ptr as *const _ as usize },
1749 40usize,
1750 concat!(
1751 "Offset of field: ",
1752 stringify!(random_data),
1753 "::",
1754 stringify!(end_ptr)
1755 )
1756 );
1757}
1758extern "C" {
1759 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
1760}
1761extern "C" {
1762 pub fn srandom_r(
1763 __seed: ::std::os::raw::c_uint,
1764 __buf: *mut random_data,
1765 ) -> ::std::os::raw::c_int;
1766}
1767extern "C" {
1768 pub fn initstate_r(
1769 __seed: ::std::os::raw::c_uint,
1770 __statebuf: *mut ::std::os::raw::c_char,
1771 __statelen: size_t,
1772 __buf: *mut random_data,
1773 ) -> ::std::os::raw::c_int;
1774}
1775extern "C" {
1776 pub fn setstate_r(
1777 __statebuf: *mut ::std::os::raw::c_char,
1778 __buf: *mut random_data,
1779 ) -> ::std::os::raw::c_int;
1780}
1781extern "C" {
1782 pub fn rand() -> ::std::os::raw::c_int;
1783}
1784extern "C" {
1785 pub fn srand(__seed: ::std::os::raw::c_uint);
1786}
1787extern "C" {
1788 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
1789}
1790extern "C" {
1791 pub fn drand48() -> f64;
1792}
1793extern "C" {
1794 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
1795}
1796extern "C" {
1797 pub fn lrand48() -> ::std::os::raw::c_long;
1798}
1799extern "C" {
1800 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1801}
1802extern "C" {
1803 pub fn mrand48() -> ::std::os::raw::c_long;
1804}
1805extern "C" {
1806 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1807}
1808extern "C" {
1809 pub fn srand48(__seedval: ::std::os::raw::c_long);
1810}
1811extern "C" {
1812 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
1813}
1814extern "C" {
1815 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
1816}
1817#[repr(C)]
1818#[derive(Debug, Copy, Clone)]
1819pub struct drand48_data {
1820 pub __x: [::std::os::raw::c_ushort; 3usize],
1821 pub __old_x: [::std::os::raw::c_ushort; 3usize],
1822 pub __c: ::std::os::raw::c_ushort,
1823 pub __init: ::std::os::raw::c_ushort,
1824 pub __a: ::std::os::raw::c_ulonglong,
1825}
1826#[test]
1827fn bindgen_test_layout_drand48_data() {
1828 assert_eq!(
1829 ::std::mem::size_of::<drand48_data>(),
1830 24usize,
1831 concat!("Size of: ", stringify!(drand48_data))
1832 );
1833 assert_eq!(
1834 ::std::mem::align_of::<drand48_data>(),
1835 8usize,
1836 concat!("Alignment of ", stringify!(drand48_data))
1837 );
1838 assert_eq!(
1839 unsafe { &(*(::std::ptr::null::<drand48_data>())).__x as *const _ as usize },
1840 0usize,
1841 concat!(
1842 "Offset of field: ",
1843 stringify!(drand48_data),
1844 "::",
1845 stringify!(__x)
1846 )
1847 );
1848 assert_eq!(
1849 unsafe { &(*(::std::ptr::null::<drand48_data>())).__old_x as *const _ as usize },
1850 6usize,
1851 concat!(
1852 "Offset of field: ",
1853 stringify!(drand48_data),
1854 "::",
1855 stringify!(__old_x)
1856 )
1857 );
1858 assert_eq!(
1859 unsafe { &(*(::std::ptr::null::<drand48_data>())).__c as *const _ as usize },
1860 12usize,
1861 concat!(
1862 "Offset of field: ",
1863 stringify!(drand48_data),
1864 "::",
1865 stringify!(__c)
1866 )
1867 );
1868 assert_eq!(
1869 unsafe { &(*(::std::ptr::null::<drand48_data>())).__init as *const _ as usize },
1870 14usize,
1871 concat!(
1872 "Offset of field: ",
1873 stringify!(drand48_data),
1874 "::",
1875 stringify!(__init)
1876 )
1877 );
1878 assert_eq!(
1879 unsafe { &(*(::std::ptr::null::<drand48_data>())).__a as *const _ as usize },
1880 16usize,
1881 concat!(
1882 "Offset of field: ",
1883 stringify!(drand48_data),
1884 "::",
1885 stringify!(__a)
1886 )
1887 );
1888}
1889extern "C" {
1890 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
1891}
1892extern "C" {
1893 pub fn erand48_r(
1894 __xsubi: *mut ::std::os::raw::c_ushort,
1895 __buffer: *mut drand48_data,
1896 __result: *mut f64,
1897 ) -> ::std::os::raw::c_int;
1898}
1899extern "C" {
1900 pub fn lrand48_r(
1901 __buffer: *mut drand48_data,
1902 __result: *mut ::std::os::raw::c_long,
1903 ) -> ::std::os::raw::c_int;
1904}
1905extern "C" {
1906 pub fn nrand48_r(
1907 __xsubi: *mut ::std::os::raw::c_ushort,
1908 __buffer: *mut drand48_data,
1909 __result: *mut ::std::os::raw::c_long,
1910 ) -> ::std::os::raw::c_int;
1911}
1912extern "C" {
1913 pub fn mrand48_r(
1914 __buffer: *mut drand48_data,
1915 __result: *mut ::std::os::raw::c_long,
1916 ) -> ::std::os::raw::c_int;
1917}
1918extern "C" {
1919 pub fn jrand48_r(
1920 __xsubi: *mut ::std::os::raw::c_ushort,
1921 __buffer: *mut drand48_data,
1922 __result: *mut ::std::os::raw::c_long,
1923 ) -> ::std::os::raw::c_int;
1924}
1925extern "C" {
1926 pub fn srand48_r(
1927 __seedval: ::std::os::raw::c_long,
1928 __buffer: *mut drand48_data,
1929 ) -> ::std::os::raw::c_int;
1930}
1931extern "C" {
1932 pub fn seed48_r(
1933 __seed16v: *mut ::std::os::raw::c_ushort,
1934 __buffer: *mut drand48_data,
1935 ) -> ::std::os::raw::c_int;
1936}
1937extern "C" {
1938 pub fn lcong48_r(
1939 __param: *mut ::std::os::raw::c_ushort,
1940 __buffer: *mut drand48_data,
1941 ) -> ::std::os::raw::c_int;
1942}
1943extern "C" {
1944 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1945}
1946extern "C" {
1947 pub fn calloc(
1948 __nmemb: ::std::os::raw::c_ulong,
1949 __size: ::std::os::raw::c_ulong,
1950 ) -> *mut ::std::os::raw::c_void;
1951}
1952extern "C" {
1953 pub fn realloc(
1954 __ptr: *mut ::std::os::raw::c_void,
1955 __size: ::std::os::raw::c_ulong,
1956 ) -> *mut ::std::os::raw::c_void;
1957}
1958extern "C" {
1959 pub fn free(__ptr: *mut ::std::os::raw::c_void);
1960}
1961extern "C" {
1962 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1963}
1964extern "C" {
1965 pub fn valloc(__size: size_t) -> *mut ::std::os::raw::c_void;
1966}
1967extern "C" {
1968 pub fn posix_memalign(
1969 __memptr: *mut *mut ::std::os::raw::c_void,
1970 __alignment: size_t,
1971 __size: size_t,
1972 ) -> ::std::os::raw::c_int;
1973}
1974extern "C" {
1975 pub fn aligned_alloc(__alignment: size_t, __size: size_t) -> *mut ::std::os::raw::c_void;
1976}
1977extern "C" {
1978 pub fn abort();
1979}
1980extern "C" {
1981 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
1982}
1983extern "C" {
1984 pub fn at_quick_exit(
1985 __func: ::std::option::Option<unsafe extern "C" fn()>,
1986 ) -> ::std::os::raw::c_int;
1987}
1988extern "C" {
1989 pub fn on_exit(
1990 __func: ::std::option::Option<
1991 unsafe extern "C" fn(
1992 __status: ::std::os::raw::c_int,
1993 __arg: *mut ::std::os::raw::c_void,
1994 ),
1995 >,
1996 __arg: *mut ::std::os::raw::c_void,
1997 ) -> ::std::os::raw::c_int;
1998}
1999extern "C" {
2000 pub fn exit(__status: ::std::os::raw::c_int);
2001}
2002extern "C" {
2003 pub fn quick_exit(__status: ::std::os::raw::c_int);
2004}
2005extern "C" {
2006 pub fn _Exit(__status: ::std::os::raw::c_int);
2007}
2008extern "C" {
2009 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2010}
2011extern "C" {
2012 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2013}
2014extern "C" {
2015 pub fn setenv(
2016 __name: *const ::std::os::raw::c_char,
2017 __value: *const ::std::os::raw::c_char,
2018 __replace: ::std::os::raw::c_int,
2019 ) -> ::std::os::raw::c_int;
2020}
2021extern "C" {
2022 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2023}
2024extern "C" {
2025 pub fn clearenv() -> ::std::os::raw::c_int;
2026}
2027extern "C" {
2028 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2029}
2030extern "C" {
2031 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2032}
2033extern "C" {
2034 pub fn mkstemps(
2035 __template: *mut ::std::os::raw::c_char,
2036 __suffixlen: ::std::os::raw::c_int,
2037 ) -> ::std::os::raw::c_int;
2038}
2039extern "C" {
2040 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2041}
2042extern "C" {
2043 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2044}
2045extern "C" {
2046 pub fn realpath(
2047 __name: *const ::std::os::raw::c_char,
2048 __resolved: *mut ::std::os::raw::c_char,
2049 ) -> *mut ::std::os::raw::c_char;
2050}
2051pub type __compar_fn_t = ::std::option::Option<
2052 unsafe extern "C" fn(
2053 arg1: *const ::std::os::raw::c_void,
2054 arg2: *const ::std::os::raw::c_void,
2055 ) -> ::std::os::raw::c_int,
2056>;
2057extern "C" {
2058 pub fn bsearch(
2059 __key: *const ::std::os::raw::c_void,
2060 __base: *const ::std::os::raw::c_void,
2061 __nmemb: size_t,
2062 __size: size_t,
2063 __compar: __compar_fn_t,
2064 ) -> *mut ::std::os::raw::c_void;
2065}
2066extern "C" {
2067 pub fn qsort(
2068 __base: *mut ::std::os::raw::c_void,
2069 __nmemb: size_t,
2070 __size: size_t,
2071 __compar: __compar_fn_t,
2072 );
2073}
2074extern "C" {
2075 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2076}
2077extern "C" {
2078 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
2079}
2080extern "C" {
2081 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
2082}
2083extern "C" {
2084 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
2085}
2086extern "C" {
2087 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
2088}
2089extern "C" {
2090 pub fn lldiv(
2091 __numer: ::std::os::raw::c_longlong,
2092 __denom: ::std::os::raw::c_longlong,
2093 ) -> lldiv_t;
2094}
2095extern "C" {
2096 pub fn ecvt(
2097 __value: f64,
2098 __ndigit: ::std::os::raw::c_int,
2099 __decpt: *mut ::std::os::raw::c_int,
2100 __sign: *mut ::std::os::raw::c_int,
2101 ) -> *mut ::std::os::raw::c_char;
2102}
2103extern "C" {
2104 pub fn fcvt(
2105 __value: f64,
2106 __ndigit: ::std::os::raw::c_int,
2107 __decpt: *mut ::std::os::raw::c_int,
2108 __sign: *mut ::std::os::raw::c_int,
2109 ) -> *mut ::std::os::raw::c_char;
2110}
2111extern "C" {
2112 pub fn gcvt(
2113 __value: f64,
2114 __ndigit: ::std::os::raw::c_int,
2115 __buf: *mut ::std::os::raw::c_char,
2116 ) -> *mut ::std::os::raw::c_char;
2117}
2118extern "C" {
2119 pub fn qecvt(
2120 __value: u128,
2121 __ndigit: ::std::os::raw::c_int,
2122 __decpt: *mut ::std::os::raw::c_int,
2123 __sign: *mut ::std::os::raw::c_int,
2124 ) -> *mut ::std::os::raw::c_char;
2125}
2126extern "C" {
2127 pub fn qfcvt(
2128 __value: u128,
2129 __ndigit: ::std::os::raw::c_int,
2130 __decpt: *mut ::std::os::raw::c_int,
2131 __sign: *mut ::std::os::raw::c_int,
2132 ) -> *mut ::std::os::raw::c_char;
2133}
2134extern "C" {
2135 pub fn qgcvt(
2136 __value: u128,
2137 __ndigit: ::std::os::raw::c_int,
2138 __buf: *mut ::std::os::raw::c_char,
2139 ) -> *mut ::std::os::raw::c_char;
2140}
2141extern "C" {
2142 pub fn ecvt_r(
2143 __value: f64,
2144 __ndigit: ::std::os::raw::c_int,
2145 __decpt: *mut ::std::os::raw::c_int,
2146 __sign: *mut ::std::os::raw::c_int,
2147 __buf: *mut ::std::os::raw::c_char,
2148 __len: size_t,
2149 ) -> ::std::os::raw::c_int;
2150}
2151extern "C" {
2152 pub fn fcvt_r(
2153 __value: f64,
2154 __ndigit: ::std::os::raw::c_int,
2155 __decpt: *mut ::std::os::raw::c_int,
2156 __sign: *mut ::std::os::raw::c_int,
2157 __buf: *mut ::std::os::raw::c_char,
2158 __len: size_t,
2159 ) -> ::std::os::raw::c_int;
2160}
2161extern "C" {
2162 pub fn qecvt_r(
2163 __value: u128,
2164 __ndigit: ::std::os::raw::c_int,
2165 __decpt: *mut ::std::os::raw::c_int,
2166 __sign: *mut ::std::os::raw::c_int,
2167 __buf: *mut ::std::os::raw::c_char,
2168 __len: size_t,
2169 ) -> ::std::os::raw::c_int;
2170}
2171extern "C" {
2172 pub fn qfcvt_r(
2173 __value: u128,
2174 __ndigit: ::std::os::raw::c_int,
2175 __decpt: *mut ::std::os::raw::c_int,
2176 __sign: *mut ::std::os::raw::c_int,
2177 __buf: *mut ::std::os::raw::c_char,
2178 __len: size_t,
2179 ) -> ::std::os::raw::c_int;
2180}
2181extern "C" {
2182 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: size_t) -> ::std::os::raw::c_int;
2183}
2184extern "C" {
2185 pub fn mbtowc(
2186 __pwc: *mut wchar_t,
2187 __s: *const ::std::os::raw::c_char,
2188 __n: size_t,
2189 ) -> ::std::os::raw::c_int;
2190}
2191extern "C" {
2192 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
2193}
2194extern "C" {
2195 pub fn mbstowcs(
2196 __pwcs: *mut wchar_t,
2197 __s: *const ::std::os::raw::c_char,
2198 __n: size_t,
2199 ) -> size_t;
2200}
2201extern "C" {
2202 pub fn wcstombs(
2203 __s: *mut ::std::os::raw::c_char,
2204 __pwcs: *const wchar_t,
2205 __n: size_t,
2206 ) -> size_t;
2207}
2208extern "C" {
2209 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2210}
2211extern "C" {
2212 pub fn getsubopt(
2213 __optionp: *mut *mut ::std::os::raw::c_char,
2214 __tokens: *const *mut ::std::os::raw::c_char,
2215 __valuep: *mut *mut ::std::os::raw::c_char,
2216 ) -> ::std::os::raw::c_int;
2217}
2218extern "C" {
2219 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
2220 -> ::std::os::raw::c_int;
2221}
2222pub type int_least8_t = ::std::os::raw::c_schar;
2223pub type int_least16_t = ::std::os::raw::c_short;
2224pub type int_least32_t = ::std::os::raw::c_int;
2225pub type int_least64_t = ::std::os::raw::c_long;
2226pub type uint_least8_t = ::std::os::raw::c_uchar;
2227pub type uint_least16_t = ::std::os::raw::c_ushort;
2228pub type uint_least32_t = ::std::os::raw::c_uint;
2229pub type uint_least64_t = ::std::os::raw::c_ulong;
2230pub type int_fast8_t = ::std::os::raw::c_schar;
2231pub type int_fast16_t = ::std::os::raw::c_long;
2232pub type int_fast32_t = ::std::os::raw::c_long;
2233pub type int_fast64_t = ::std::os::raw::c_long;
2234pub type uint_fast8_t = ::std::os::raw::c_uchar;
2235pub type uint_fast16_t = ::std::os::raw::c_ulong;
2236pub type uint_fast32_t = ::std::os::raw::c_ulong;
2237pub type uint_fast64_t = ::std::os::raw::c_ulong;
2238pub type intmax_t = __intmax_t;
2239pub type uintmax_t = __uintmax_t;
2240pub type GSChar = ::std::os::raw::c_char;
2241pub type GSBool = ::std::os::raw::c_char;
2242pub type GSEnum = i32;
2243pub type GSTimestamp = i64;
2244#[repr(C)]
2245#[derive(Debug, Copy, Clone)]
2246pub struct GSGridStoreFactoryTag {
2247 _unused: [u8; 0],
2248}
2249pub type GSGridStoreFactory = GSGridStoreFactoryTag;
2250#[repr(C)]
2251#[derive(Debug, Copy, Clone)]
2252pub struct GSGridStoreTag {
2253 _unused: [u8; 0],
2254}
2255pub type GSGridStore = GSGridStoreTag;
2256#[repr(C)]
2257#[derive(Debug, Copy, Clone)]
2258pub struct GSContainerTag {
2259 _unused: [u8; 0],
2260}
2261pub type GSContainer = GSContainerTag;
2262#[repr(C)]
2263#[derive(Debug, Copy, Clone)]
2264pub struct GSQueryTag {
2265 _unused: [u8; 0],
2266}
2267pub type GSQuery = GSQueryTag;
2268#[repr(C)]
2269#[derive(Debug, Copy, Clone)]
2270pub struct GSRowSetTag {
2271 _unused: [u8; 0],
2272}
2273pub type GSRowSet = GSRowSetTag;
2274#[repr(C)]
2275#[derive(Debug, Copy, Clone)]
2276pub struct GSAggregationResultTag {
2277 _unused: [u8; 0],
2278}
2279pub type GSAggregationResult = GSAggregationResultTag;
2280pub type GSCollection = GSContainer;
2281pub type GSTimeSeries = GSContainer;
2282#[repr(C)]
2283#[derive(Debug, Copy, Clone)]
2284pub struct GSRowTag {
2285 _unused: [u8; 0],
2286}
2287pub type GSRow = GSRowTag;
2288pub type GSRowKey = GSRow;
2289#[repr(C)]
2290#[derive(Debug, Copy, Clone)]
2291pub struct GSRowKeyPredicateTag {
2292 _unused: [u8; 0],
2293}
2294pub type GSRowKeyPredicate = GSRowKeyPredicateTag;
2295#[repr(C)]
2296#[derive(Debug, Copy, Clone)]
2297pub struct GSPartitionControllerTag {
2298 _unused: [u8; 0],
2299}
2300pub type GSPartitionController = GSPartitionControllerTag;
2301pub type GSResult = i32;
2302#[repr(C)]
2303#[derive(Debug, Copy, Clone)]
2304pub struct GSBlobTag {
2305 pub size: size_t,
2306 pub data: *const ::std::os::raw::c_void,
2307}
2308#[test]
2309fn bindgen_test_layout_GSBlobTag() {
2310 assert_eq!(
2311 ::std::mem::size_of::<GSBlobTag>(),
2312 16usize,
2313 concat!("Size of: ", stringify!(GSBlobTag))
2314 );
2315 assert_eq!(
2316 ::std::mem::align_of::<GSBlobTag>(),
2317 8usize,
2318 concat!("Alignment of ", stringify!(GSBlobTag))
2319 );
2320 assert_eq!(
2321 unsafe { &(*(::std::ptr::null::<GSBlobTag>())).size as *const _ as usize },
2322 0usize,
2323 concat!(
2324 "Offset of field: ",
2325 stringify!(GSBlobTag),
2326 "::",
2327 stringify!(size)
2328 )
2329 );
2330 assert_eq!(
2331 unsafe { &(*(::std::ptr::null::<GSBlobTag>())).data as *const _ as usize },
2332 8usize,
2333 concat!(
2334 "Offset of field: ",
2335 stringify!(GSBlobTag),
2336 "::",
2337 stringify!(data)
2338 )
2339 );
2340}
2341pub type GSBlob = GSBlobTag;
2342#[repr(C)]
2343#[derive(Debug, Copy, Clone)]
2344pub struct GSPropertyEntryTag {
2345 pub name: *const GSChar,
2346 pub value: *const GSChar,
2347}
2348#[test]
2349fn bindgen_test_layout_GSPropertyEntryTag() {
2350 assert_eq!(
2351 ::std::mem::size_of::<GSPropertyEntryTag>(),
2352 16usize,
2353 concat!("Size of: ", stringify!(GSPropertyEntryTag))
2354 );
2355 assert_eq!(
2356 ::std::mem::align_of::<GSPropertyEntryTag>(),
2357 8usize,
2358 concat!("Alignment of ", stringify!(GSPropertyEntryTag))
2359 );
2360 assert_eq!(
2361 unsafe { &(*(::std::ptr::null::<GSPropertyEntryTag>())).name as *const _ as usize },
2362 0usize,
2363 concat!(
2364 "Offset of field: ",
2365 stringify!(GSPropertyEntryTag),
2366 "::",
2367 stringify!(name)
2368 )
2369 );
2370 assert_eq!(
2371 unsafe { &(*(::std::ptr::null::<GSPropertyEntryTag>())).value as *const _ as usize },
2372 8usize,
2373 concat!(
2374 "Offset of field: ",
2375 stringify!(GSPropertyEntryTag),
2376 "::",
2377 stringify!(value)
2378 )
2379 );
2380}
2381pub type GSPropertyEntry = GSPropertyEntryTag;
2382pub const GSFetchOptionTag_GS_FETCH_LIMIT: GSFetchOptionTag = 0;
2383pub const GSFetchOptionTag_GS_FETCH_PARTIAL_EXECUTION: GSFetchOptionTag = 2;
2384pub type GSFetchOptionTag = ::std::os::raw::c_uint;
2385extern "C" {
2386 pub static GS_FETCH_SIZE: GSFetchOptionTag;
2387}
2388pub type GSFetchOption = GSEnum;
2389pub const GSQueryOrderTag_GS_ORDER_ASCENDING: GSQueryOrderTag = 0;
2390pub const GSQueryOrderTag_GS_ORDER_DESCENDING: GSQueryOrderTag = 1;
2391pub type GSQueryOrderTag = ::std::os::raw::c_uint;
2392pub type GSQueryOrder = GSEnum;
2393pub const GSIndexTypeFlagTag_GS_INDEX_FLAG_DEFAULT: GSIndexTypeFlagTag = -1;
2394pub const GSIndexTypeFlagTag_GS_INDEX_FLAG_TREE: GSIndexTypeFlagTag = 1;
2395pub const GSIndexTypeFlagTag_GS_INDEX_FLAG_HASH: GSIndexTypeFlagTag = 2;
2396pub const GSIndexTypeFlagTag_GS_INDEX_FLAG_SPATIAL: GSIndexTypeFlagTag = 4;
2397pub type GSIndexTypeFlagTag = ::std::os::raw::c_int;
2398pub type GSIndexTypeFlags = i32;
2399pub const GSAggregationTag_GS_AGGREGATION_MINIMUM: GSAggregationTag = 0;
2400pub const GSAggregationTag_GS_AGGREGATION_MAXIMUM: GSAggregationTag = 1;
2401pub const GSAggregationTag_GS_AGGREGATION_TOTAL: GSAggregationTag = 2;
2402pub const GSAggregationTag_GS_AGGREGATION_AVERAGE: GSAggregationTag = 3;
2403pub const GSAggregationTag_GS_AGGREGATION_VARIANCE: GSAggregationTag = 4;
2404pub const GSAggregationTag_GS_AGGREGATION_STANDARD_DEVIATION: GSAggregationTag = 5;
2405pub const GSAggregationTag_GS_AGGREGATION_COUNT: GSAggregationTag = 6;
2406pub const GSAggregationTag_GS_AGGREGATION_WEIGHTED_AVERAGE: GSAggregationTag = 7;
2407pub type GSAggregationTag = ::std::os::raw::c_uint;
2408pub type GSAggregation = GSEnum;
2409pub const GSInterpolationModeTag_GS_INTERPOLATION_LINEAR_OR_PREVIOUS: GSInterpolationModeTag = 0;
2410pub const GSInterpolationModeTag_GS_INTERPOLATION_EMPTY: GSInterpolationModeTag = 1;
2411pub type GSInterpolationModeTag = ::std::os::raw::c_uint;
2412pub type GSInterpolationMode = GSEnum;
2413pub const GSTimeOperatorTag_GS_TIME_OPERATOR_PREVIOUS: GSTimeOperatorTag = 0;
2414pub const GSTimeOperatorTag_GS_TIME_OPERATOR_PREVIOUS_ONLY: GSTimeOperatorTag = 1;
2415pub const GSTimeOperatorTag_GS_TIME_OPERATOR_NEXT: GSTimeOperatorTag = 2;
2416pub const GSTimeOperatorTag_GS_TIME_OPERATOR_NEXT_ONLY: GSTimeOperatorTag = 3;
2417pub type GSTimeOperatorTag = ::std::os::raw::c_uint;
2418pub type GSTimeOperator = GSEnum;
2419pub const GSGeometryOperatorTag_GS_GEOMETRY_OPERATOR_INTERSECT: GSGeometryOperatorTag = 0;
2420pub type GSGeometryOperatorTag = ::std::os::raw::c_uint;
2421pub type GSGeometryOperator = GSEnum;
2422pub const GSCompressionMethodTag_GS_COMPRESSION_NO: GSCompressionMethodTag = 0;
2423pub const GSCompressionMethodTag_GS_COMPRESSION_SS: GSCompressionMethodTag = 1;
2424pub const GSCompressionMethodTag_GS_COMPRESSION_HI: GSCompressionMethodTag = 2;
2425pub type GSCompressionMethodTag = ::std::os::raw::c_uint;
2426pub type GSCompressionMethod = GSEnum;
2427pub const GSTimeUnitTag_GS_TIME_UNIT_YEAR: GSTimeUnitTag = 0;
2428pub const GSTimeUnitTag_GS_TIME_UNIT_MONTH: GSTimeUnitTag = 1;
2429pub const GSTimeUnitTag_GS_TIME_UNIT_DAY: GSTimeUnitTag = 2;
2430pub const GSTimeUnitTag_GS_TIME_UNIT_HOUR: GSTimeUnitTag = 3;
2431pub const GSTimeUnitTag_GS_TIME_UNIT_MINUTE: GSTimeUnitTag = 4;
2432pub const GSTimeUnitTag_GS_TIME_UNIT_SECOND: GSTimeUnitTag = 5;
2433pub const GSTimeUnitTag_GS_TIME_UNIT_MILLISECOND: GSTimeUnitTag = 6;
2434pub type GSTimeUnitTag = ::std::os::raw::c_uint;
2435pub type GSTimeUnit = GSEnum;
2436pub const GSContainerTypeTag_GS_CONTAINER_COLLECTION: GSContainerTypeTag = 0;
2437pub const GSContainerTypeTag_GS_CONTAINER_TIME_SERIES: GSContainerTypeTag = 1;
2438pub type GSContainerTypeTag = ::std::os::raw::c_uint;
2439pub type GSContainerType = GSEnum;
2440pub const GSTypeTag_GS_TYPE_STRING: GSTypeTag = 0;
2441pub const GSTypeTag_GS_TYPE_BOOL: GSTypeTag = 1;
2442pub const GSTypeTag_GS_TYPE_BYTE: GSTypeTag = 2;
2443pub const GSTypeTag_GS_TYPE_SHORT: GSTypeTag = 3;
2444pub const GSTypeTag_GS_TYPE_INTEGER: GSTypeTag = 4;
2445pub const GSTypeTag_GS_TYPE_LONG: GSTypeTag = 5;
2446pub const GSTypeTag_GS_TYPE_FLOAT: GSTypeTag = 6;
2447pub const GSTypeTag_GS_TYPE_DOUBLE: GSTypeTag = 7;
2448pub const GSTypeTag_GS_TYPE_TIMESTAMP: GSTypeTag = 8;
2449pub const GSTypeTag_GS_TYPE_GEOMETRY: GSTypeTag = 9;
2450pub const GSTypeTag_GS_TYPE_BLOB: GSTypeTag = 10;
2451pub const GSTypeTag_GS_TYPE_STRING_ARRAY: GSTypeTag = 11;
2452pub const GSTypeTag_GS_TYPE_BOOL_ARRAY: GSTypeTag = 12;
2453pub const GSTypeTag_GS_TYPE_BYTE_ARRAY: GSTypeTag = 13;
2454pub const GSTypeTag_GS_TYPE_SHORT_ARRAY: GSTypeTag = 14;
2455pub const GSTypeTag_GS_TYPE_INTEGER_ARRAY: GSTypeTag = 15;
2456pub const GSTypeTag_GS_TYPE_LONG_ARRAY: GSTypeTag = 16;
2457pub const GSTypeTag_GS_TYPE_FLOAT_ARRAY: GSTypeTag = 17;
2458pub const GSTypeTag_GS_TYPE_DOUBLE_ARRAY: GSTypeTag = 18;
2459pub const GSTypeTag_GS_TYPE_TIMESTAMP_ARRAY: GSTypeTag = 19;
2460pub const GSTypeTag_GS_TYPE_NULL: GSTypeTag = -1;
2461pub type GSTypeTag = ::std::os::raw::c_int;
2462pub type GSType = GSEnum;
2463pub const GSTypeOptionTag_GS_TYPE_OPTION_KEY: GSTypeOptionTag = 1;
2464pub const GSTypeOptionTag_GS_TYPE_OPTION_NULLABLE: GSTypeOptionTag = 2;
2465pub const GSTypeOptionTag_GS_TYPE_OPTION_NOT_NULL: GSTypeOptionTag = 4;
2466pub const GSTypeOptionTag_GS_TYPE_OPTION_DEFAULT_VALUE_NULL: GSTypeOptionTag = 8;
2467pub const GSTypeOptionTag_GS_TYPE_OPTION_DEFAULT_VALUE_NOT_NULL: GSTypeOptionTag = 16;
2468pub type GSTypeOptionTag = ::std::os::raw::c_uint;
2469pub type GSTypeOption = i32;
2470pub const GSRowSetTypeTag_GS_ROW_SET_CONTAINER_ROWS: GSRowSetTypeTag = 0;
2471pub const GSRowSetTypeTag_GS_ROW_SET_AGGREGATION_RESULT: GSRowSetTypeTag = 1;
2472pub const GSRowSetTypeTag_GS_ROW_SET_QUERY_ANALYSIS: GSRowSetTypeTag = 2;
2473pub type GSRowSetTypeTag = ::std::os::raw::c_uint;
2474pub type GSRowSetType = GSEnum;
2475#[repr(C)]
2476#[derive(Debug, Copy, Clone)]
2477pub struct GSColumnCompressionTag {
2478 pub columnName: *const GSChar,
2479 pub relative: GSBool,
2480 pub rate: f64,
2481 pub span: f64,
2482 pub width: f64,
2483}
2484#[test]
2485fn bindgen_test_layout_GSColumnCompressionTag() {
2486 assert_eq!(
2487 ::std::mem::size_of::<GSColumnCompressionTag>(),
2488 40usize,
2489 concat!("Size of: ", stringify!(GSColumnCompressionTag))
2490 );
2491 assert_eq!(
2492 ::std::mem::align_of::<GSColumnCompressionTag>(),
2493 8usize,
2494 concat!("Alignment of ", stringify!(GSColumnCompressionTag))
2495 );
2496 assert_eq!(
2497 unsafe {
2498 &(*(::std::ptr::null::<GSColumnCompressionTag>())).columnName as *const _ as usize
2499 },
2500 0usize,
2501 concat!(
2502 "Offset of field: ",
2503 stringify!(GSColumnCompressionTag),
2504 "::",
2505 stringify!(columnName)
2506 )
2507 );
2508 assert_eq!(
2509 unsafe { &(*(::std::ptr::null::<GSColumnCompressionTag>())).relative as *const _ as usize },
2510 8usize,
2511 concat!(
2512 "Offset of field: ",
2513 stringify!(GSColumnCompressionTag),
2514 "::",
2515 stringify!(relative)
2516 )
2517 );
2518 assert_eq!(
2519 unsafe { &(*(::std::ptr::null::<GSColumnCompressionTag>())).rate as *const _ as usize },
2520 16usize,
2521 concat!(
2522 "Offset of field: ",
2523 stringify!(GSColumnCompressionTag),
2524 "::",
2525 stringify!(rate)
2526 )
2527 );
2528 assert_eq!(
2529 unsafe { &(*(::std::ptr::null::<GSColumnCompressionTag>())).span as *const _ as usize },
2530 24usize,
2531 concat!(
2532 "Offset of field: ",
2533 stringify!(GSColumnCompressionTag),
2534 "::",
2535 stringify!(span)
2536 )
2537 );
2538 assert_eq!(
2539 unsafe { &(*(::std::ptr::null::<GSColumnCompressionTag>())).width as *const _ as usize },
2540 32usize,
2541 concat!(
2542 "Offset of field: ",
2543 stringify!(GSColumnCompressionTag),
2544 "::",
2545 stringify!(width)
2546 )
2547 );
2548}
2549pub type GSColumnCompression = GSColumnCompressionTag;
2550#[repr(C)]
2551#[derive(Debug, Copy, Clone)]
2552pub struct GSCollectionPropertiesTag {
2553 pub internal: GSCollectionPropertiesTag__bindgen_ty_1,
2554}
2555#[repr(C)]
2556#[derive(Debug, Copy, Clone)]
2557pub struct GSCollectionPropertiesTag__bindgen_ty_1 {
2558 pub unused: i8,
2559}
2560#[test]
2561fn bindgen_test_layout_GSCollectionPropertiesTag__bindgen_ty_1() {
2562 assert_eq!(
2563 ::std::mem::size_of::<GSCollectionPropertiesTag__bindgen_ty_1>(),
2564 1usize,
2565 concat!(
2566 "Size of: ",
2567 stringify!(GSCollectionPropertiesTag__bindgen_ty_1)
2568 )
2569 );
2570 assert_eq!(
2571 ::std::mem::align_of::<GSCollectionPropertiesTag__bindgen_ty_1>(),
2572 1usize,
2573 concat!(
2574 "Alignment of ",
2575 stringify!(GSCollectionPropertiesTag__bindgen_ty_1)
2576 )
2577 );
2578 assert_eq!(
2579 unsafe {
2580 &(*(::std::ptr::null::<GSCollectionPropertiesTag__bindgen_ty_1>())).unused as *const _
2581 as usize
2582 },
2583 0usize,
2584 concat!(
2585 "Offset of field: ",
2586 stringify!(GSCollectionPropertiesTag__bindgen_ty_1),
2587 "::",
2588 stringify!(unused)
2589 )
2590 );
2591}
2592#[test]
2593fn bindgen_test_layout_GSCollectionPropertiesTag() {
2594 assert_eq!(
2595 ::std::mem::size_of::<GSCollectionPropertiesTag>(),
2596 1usize,
2597 concat!("Size of: ", stringify!(GSCollectionPropertiesTag))
2598 );
2599 assert_eq!(
2600 ::std::mem::align_of::<GSCollectionPropertiesTag>(),
2601 1usize,
2602 concat!("Alignment of ", stringify!(GSCollectionPropertiesTag))
2603 );
2604 assert_eq!(
2605 unsafe {
2606 &(*(::std::ptr::null::<GSCollectionPropertiesTag>())).internal as *const _ as usize
2607 },
2608 0usize,
2609 concat!(
2610 "Offset of field: ",
2611 stringify!(GSCollectionPropertiesTag),
2612 "::",
2613 stringify!(internal)
2614 )
2615 );
2616}
2617pub type GSCollectionProperties = GSCollectionPropertiesTag;
2618#[repr(C)]
2619#[derive(Debug, Copy, Clone)]
2620pub struct GSTimeSeriesPropertiesTag {
2621 pub rowExpirationTime: i32,
2622 pub rowExpirationTimeUnit: GSTimeUnit,
2623 pub compressionWindowSize: i32,
2624 pub compressionWindowSizeUnit: GSTimeUnit,
2625 pub compressionMethod: GSCompressionMethod,
2626 pub compressionListSize: size_t,
2627 pub compressionList: *mut GSColumnCompression,
2628 pub expirationDivisionCount: i32,
2629}
2630#[test]
2631fn bindgen_test_layout_GSTimeSeriesPropertiesTag() {
2632 assert_eq!(
2633 ::std::mem::size_of::<GSTimeSeriesPropertiesTag>(),
2634 48usize,
2635 concat!("Size of: ", stringify!(GSTimeSeriesPropertiesTag))
2636 );
2637 assert_eq!(
2638 ::std::mem::align_of::<GSTimeSeriesPropertiesTag>(),
2639 8usize,
2640 concat!("Alignment of ", stringify!(GSTimeSeriesPropertiesTag))
2641 );
2642 assert_eq!(
2643 unsafe {
2644 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).rowExpirationTime as *const _
2645 as usize
2646 },
2647 0usize,
2648 concat!(
2649 "Offset of field: ",
2650 stringify!(GSTimeSeriesPropertiesTag),
2651 "::",
2652 stringify!(rowExpirationTime)
2653 )
2654 );
2655 assert_eq!(
2656 unsafe {
2657 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).rowExpirationTimeUnit as *const _
2658 as usize
2659 },
2660 4usize,
2661 concat!(
2662 "Offset of field: ",
2663 stringify!(GSTimeSeriesPropertiesTag),
2664 "::",
2665 stringify!(rowExpirationTimeUnit)
2666 )
2667 );
2668 assert_eq!(
2669 unsafe {
2670 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).compressionWindowSize as *const _
2671 as usize
2672 },
2673 8usize,
2674 concat!(
2675 "Offset of field: ",
2676 stringify!(GSTimeSeriesPropertiesTag),
2677 "::",
2678 stringify!(compressionWindowSize)
2679 )
2680 );
2681 assert_eq!(
2682 unsafe {
2683 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).compressionWindowSizeUnit
2684 as *const _ as usize
2685 },
2686 12usize,
2687 concat!(
2688 "Offset of field: ",
2689 stringify!(GSTimeSeriesPropertiesTag),
2690 "::",
2691 stringify!(compressionWindowSizeUnit)
2692 )
2693 );
2694 assert_eq!(
2695 unsafe {
2696 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).compressionMethod as *const _
2697 as usize
2698 },
2699 16usize,
2700 concat!(
2701 "Offset of field: ",
2702 stringify!(GSTimeSeriesPropertiesTag),
2703 "::",
2704 stringify!(compressionMethod)
2705 )
2706 );
2707 assert_eq!(
2708 unsafe {
2709 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).compressionListSize as *const _
2710 as usize
2711 },
2712 24usize,
2713 concat!(
2714 "Offset of field: ",
2715 stringify!(GSTimeSeriesPropertiesTag),
2716 "::",
2717 stringify!(compressionListSize)
2718 )
2719 );
2720 assert_eq!(
2721 unsafe {
2722 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).compressionList as *const _
2723 as usize
2724 },
2725 32usize,
2726 concat!(
2727 "Offset of field: ",
2728 stringify!(GSTimeSeriesPropertiesTag),
2729 "::",
2730 stringify!(compressionList)
2731 )
2732 );
2733 assert_eq!(
2734 unsafe {
2735 &(*(::std::ptr::null::<GSTimeSeriesPropertiesTag>())).expirationDivisionCount
2736 as *const _ as usize
2737 },
2738 40usize,
2739 concat!(
2740 "Offset of field: ",
2741 stringify!(GSTimeSeriesPropertiesTag),
2742 "::",
2743 stringify!(expirationDivisionCount)
2744 )
2745 );
2746}
2747pub type GSTimeSeriesProperties = GSTimeSeriesPropertiesTag;
2748#[repr(C)]
2749#[derive(Debug, Copy, Clone)]
2750pub struct GSColumnInfoTag {
2751 pub name: *const GSChar,
2752 pub type_: GSType,
2753 pub indexTypeFlags: GSIndexTypeFlags,
2754 pub options: GSTypeOption,
2755}
2756#[test]
2757fn bindgen_test_layout_GSColumnInfoTag() {
2758 assert_eq!(
2759 ::std::mem::size_of::<GSColumnInfoTag>(),
2760 24usize,
2761 concat!("Size of: ", stringify!(GSColumnInfoTag))
2762 );
2763 assert_eq!(
2764 ::std::mem::align_of::<GSColumnInfoTag>(),
2765 8usize,
2766 concat!("Alignment of ", stringify!(GSColumnInfoTag))
2767 );
2768 assert_eq!(
2769 unsafe { &(*(::std::ptr::null::<GSColumnInfoTag>())).name as *const _ as usize },
2770 0usize,
2771 concat!(
2772 "Offset of field: ",
2773 stringify!(GSColumnInfoTag),
2774 "::",
2775 stringify!(name)
2776 )
2777 );
2778 assert_eq!(
2779 unsafe { &(*(::std::ptr::null::<GSColumnInfoTag>())).type_ as *const _ as usize },
2780 8usize,
2781 concat!(
2782 "Offset of field: ",
2783 stringify!(GSColumnInfoTag),
2784 "::",
2785 stringify!(type_)
2786 )
2787 );
2788 assert_eq!(
2789 unsafe { &(*(::std::ptr::null::<GSColumnInfoTag>())).indexTypeFlags as *const _ as usize },
2790 12usize,
2791 concat!(
2792 "Offset of field: ",
2793 stringify!(GSColumnInfoTag),
2794 "::",
2795 stringify!(indexTypeFlags)
2796 )
2797 );
2798 assert_eq!(
2799 unsafe { &(*(::std::ptr::null::<GSColumnInfoTag>())).options as *const _ as usize },
2800 16usize,
2801 concat!(
2802 "Offset of field: ",
2803 stringify!(GSColumnInfoTag),
2804 "::",
2805 stringify!(options)
2806 )
2807 );
2808}
2809pub type GSColumnInfo = GSColumnInfoTag;
2810pub const GSTriggerTypeTag_GS_TRIGGER_REST: GSTriggerTypeTag = 0;
2811pub const GSTriggerTypeTag_GS_TRIGGER_JMS: GSTriggerTypeTag = 1;
2812pub type GSTriggerTypeTag = ::std::os::raw::c_uint;
2813pub type GSTriggerType = GSEnum;
2814pub const GSTriggerEventTypeFlagTag_GS_TRIGGER_EVENT_PUT: GSTriggerEventTypeFlagTag = 1;
2815pub const GSTriggerEventTypeFlagTag_GS_TRIGGER_EVENT_DELETE: GSTriggerEventTypeFlagTag = 2;
2816pub type GSTriggerEventTypeFlagTag = ::std::os::raw::c_uint;
2817pub type GSTriggerEventTypeFlags = i32;
2818#[repr(C)]
2819#[derive(Debug, Copy, Clone)]
2820pub struct GSTriggerInfoTag {
2821 pub name: *const GSChar,
2822 pub type_: GSTriggerType,
2823 pub uri: *const GSChar,
2824 pub eventTypeFlags: GSTriggerEventTypeFlags,
2825 pub columnSet: *const *const GSChar,
2826 pub columnCount: size_t,
2827 pub jmsDestinationType: *const GSChar,
2828 pub jmsDestinationName: *const GSChar,
2829 pub user: *const GSChar,
2830 pub password: *const GSChar,
2831}
2832#[test]
2833fn bindgen_test_layout_GSTriggerInfoTag() {
2834 assert_eq!(
2835 ::std::mem::size_of::<GSTriggerInfoTag>(),
2836 80usize,
2837 concat!("Size of: ", stringify!(GSTriggerInfoTag))
2838 );
2839 assert_eq!(
2840 ::std::mem::align_of::<GSTriggerInfoTag>(),
2841 8usize,
2842 concat!("Alignment of ", stringify!(GSTriggerInfoTag))
2843 );
2844 assert_eq!(
2845 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).name as *const _ as usize },
2846 0usize,
2847 concat!(
2848 "Offset of field: ",
2849 stringify!(GSTriggerInfoTag),
2850 "::",
2851 stringify!(name)
2852 )
2853 );
2854 assert_eq!(
2855 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).type_ as *const _ as usize },
2856 8usize,
2857 concat!(
2858 "Offset of field: ",
2859 stringify!(GSTriggerInfoTag),
2860 "::",
2861 stringify!(type_)
2862 )
2863 );
2864 assert_eq!(
2865 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).uri as *const _ as usize },
2866 16usize,
2867 concat!(
2868 "Offset of field: ",
2869 stringify!(GSTriggerInfoTag),
2870 "::",
2871 stringify!(uri)
2872 )
2873 );
2874 assert_eq!(
2875 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).eventTypeFlags as *const _ as usize },
2876 24usize,
2877 concat!(
2878 "Offset of field: ",
2879 stringify!(GSTriggerInfoTag),
2880 "::",
2881 stringify!(eventTypeFlags)
2882 )
2883 );
2884 assert_eq!(
2885 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).columnSet as *const _ as usize },
2886 32usize,
2887 concat!(
2888 "Offset of field: ",
2889 stringify!(GSTriggerInfoTag),
2890 "::",
2891 stringify!(columnSet)
2892 )
2893 );
2894 assert_eq!(
2895 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).columnCount as *const _ as usize },
2896 40usize,
2897 concat!(
2898 "Offset of field: ",
2899 stringify!(GSTriggerInfoTag),
2900 "::",
2901 stringify!(columnCount)
2902 )
2903 );
2904 assert_eq!(
2905 unsafe {
2906 &(*(::std::ptr::null::<GSTriggerInfoTag>())).jmsDestinationType as *const _ as usize
2907 },
2908 48usize,
2909 concat!(
2910 "Offset of field: ",
2911 stringify!(GSTriggerInfoTag),
2912 "::",
2913 stringify!(jmsDestinationType)
2914 )
2915 );
2916 assert_eq!(
2917 unsafe {
2918 &(*(::std::ptr::null::<GSTriggerInfoTag>())).jmsDestinationName as *const _ as usize
2919 },
2920 56usize,
2921 concat!(
2922 "Offset of field: ",
2923 stringify!(GSTriggerInfoTag),
2924 "::",
2925 stringify!(jmsDestinationName)
2926 )
2927 );
2928 assert_eq!(
2929 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).user as *const _ as usize },
2930 64usize,
2931 concat!(
2932 "Offset of field: ",
2933 stringify!(GSTriggerInfoTag),
2934 "::",
2935 stringify!(user)
2936 )
2937 );
2938 assert_eq!(
2939 unsafe { &(*(::std::ptr::null::<GSTriggerInfoTag>())).password as *const _ as usize },
2940 72usize,
2941 concat!(
2942 "Offset of field: ",
2943 stringify!(GSTriggerInfoTag),
2944 "::",
2945 stringify!(password)
2946 )
2947 );
2948}
2949pub type GSTriggerInfo = GSTriggerInfoTag;
2950#[repr(C)]
2951#[derive(Debug, Copy, Clone)]
2952pub struct GSIndexInfoTag {
2953 pub name: *const GSChar,
2954 pub type_: GSIndexTypeFlags,
2955 pub column: i32,
2956 pub columnName: *const GSChar,
2957 pub columnCount: size_t,
2958 pub columnList: *const i32,
2959 pub columnNameCount: size_t,
2960 pub columnNameList: *const *const GSChar,
2961}
2962#[test]
2963fn bindgen_test_layout_GSIndexInfoTag() {
2964 assert_eq!(
2965 ::std::mem::size_of::<GSIndexInfoTag>(),
2966 56usize,
2967 concat!("Size of: ", stringify!(GSIndexInfoTag))
2968 );
2969 assert_eq!(
2970 ::std::mem::align_of::<GSIndexInfoTag>(),
2971 8usize,
2972 concat!("Alignment of ", stringify!(GSIndexInfoTag))
2973 );
2974 assert_eq!(
2975 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).name as *const _ as usize },
2976 0usize,
2977 concat!(
2978 "Offset of field: ",
2979 stringify!(GSIndexInfoTag),
2980 "::",
2981 stringify!(name)
2982 )
2983 );
2984 assert_eq!(
2985 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).type_ as *const _ as usize },
2986 8usize,
2987 concat!(
2988 "Offset of field: ",
2989 stringify!(GSIndexInfoTag),
2990 "::",
2991 stringify!(type_)
2992 )
2993 );
2994 assert_eq!(
2995 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).column as *const _ as usize },
2996 12usize,
2997 concat!(
2998 "Offset of field: ",
2999 stringify!(GSIndexInfoTag),
3000 "::",
3001 stringify!(column)
3002 )
3003 );
3004 assert_eq!(
3005 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).columnName as *const _ as usize },
3006 16usize,
3007 concat!(
3008 "Offset of field: ",
3009 stringify!(GSIndexInfoTag),
3010 "::",
3011 stringify!(columnName)
3012 )
3013 );
3014 assert_eq!(
3015 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).columnCount as *const _ as usize },
3016 24usize,
3017 concat!(
3018 "Offset of field: ",
3019 stringify!(GSIndexInfoTag),
3020 "::",
3021 stringify!(columnCount)
3022 )
3023 );
3024 assert_eq!(
3025 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).columnList as *const _ as usize },
3026 32usize,
3027 concat!(
3028 "Offset of field: ",
3029 stringify!(GSIndexInfoTag),
3030 "::",
3031 stringify!(columnList)
3032 )
3033 );
3034 assert_eq!(
3035 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).columnNameCount as *const _ as usize },
3036 40usize,
3037 concat!(
3038 "Offset of field: ",
3039 stringify!(GSIndexInfoTag),
3040 "::",
3041 stringify!(columnNameCount)
3042 )
3043 );
3044 assert_eq!(
3045 unsafe { &(*(::std::ptr::null::<GSIndexInfoTag>())).columnNameList as *const _ as usize },
3046 48usize,
3047 concat!(
3048 "Offset of field: ",
3049 stringify!(GSIndexInfoTag),
3050 "::",
3051 stringify!(columnNameList)
3052 )
3053 );
3054}
3055pub type GSIndexInfo = GSIndexInfoTag;
3056#[repr(C)]
3057#[derive(Debug, Copy, Clone)]
3058pub struct GSContainerInfoTag {
3059 pub name: *const GSChar,
3060 pub type_: GSContainerType,
3061 pub columnCount: size_t,
3062 pub columnInfoList: *const GSColumnInfo,
3063 pub rowKeyAssigned: GSBool,
3064 pub columnOrderIgnorable: GSBool,
3065 pub timeSeriesProperties: *const GSTimeSeriesProperties,
3066 pub triggerInfoCount: size_t,
3067 pub triggerInfoList: *const GSTriggerInfo,
3068 pub dataAffinity: *const GSChar,
3069 pub indexInfoCount: size_t,
3070 pub indexInfoList: *const GSIndexInfo,
3071 pub rowKeyColumnCount: size_t,
3072 pub rowKeyColumnList: *const i32,
3073}
3074#[test]
3075fn bindgen_test_layout_GSContainerInfoTag() {
3076 assert_eq!(
3077 ::std::mem::size_of::<GSContainerInfoTag>(),
3078 104usize,
3079 concat!("Size of: ", stringify!(GSContainerInfoTag))
3080 );
3081 assert_eq!(
3082 ::std::mem::align_of::<GSContainerInfoTag>(),
3083 8usize,
3084 concat!("Alignment of ", stringify!(GSContainerInfoTag))
3085 );
3086 assert_eq!(
3087 unsafe { &(*(::std::ptr::null::<GSContainerInfoTag>())).name as *const _ as usize },
3088 0usize,
3089 concat!(
3090 "Offset of field: ",
3091 stringify!(GSContainerInfoTag),
3092 "::",
3093 stringify!(name)
3094 )
3095 );
3096 assert_eq!(
3097 unsafe { &(*(::std::ptr::null::<GSContainerInfoTag>())).type_ as *const _ as usize },
3098 8usize,
3099 concat!(
3100 "Offset of field: ",
3101 stringify!(GSContainerInfoTag),
3102 "::",
3103 stringify!(type_)
3104 )
3105 );
3106 assert_eq!(
3107 unsafe { &(*(::std::ptr::null::<GSContainerInfoTag>())).columnCount as *const _ as usize },
3108 16usize,
3109 concat!(
3110 "Offset of field: ",
3111 stringify!(GSContainerInfoTag),
3112 "::",
3113 stringify!(columnCount)
3114 )
3115 );
3116 assert_eq!(
3117 unsafe {
3118 &(*(::std::ptr::null::<GSContainerInfoTag>())).columnInfoList as *const _ as usize
3119 },
3120 24usize,
3121 concat!(
3122 "Offset of field: ",
3123 stringify!(GSContainerInfoTag),
3124 "::",
3125 stringify!(columnInfoList)
3126 )
3127 );
3128 assert_eq!(
3129 unsafe {
3130 &(*(::std::ptr::null::<GSContainerInfoTag>())).rowKeyAssigned as *const _ as usize
3131 },
3132 32usize,
3133 concat!(
3134 "Offset of field: ",
3135 stringify!(GSContainerInfoTag),
3136 "::",
3137 stringify!(rowKeyAssigned)
3138 )
3139 );
3140 assert_eq!(
3141 unsafe {
3142 &(*(::std::ptr::null::<GSContainerInfoTag>())).columnOrderIgnorable as *const _ as usize
3143 },
3144 33usize,
3145 concat!(
3146 "Offset of field: ",
3147 stringify!(GSContainerInfoTag),
3148 "::",
3149 stringify!(columnOrderIgnorable)
3150 )
3151 );
3152 assert_eq!(
3153 unsafe {
3154 &(*(::std::ptr::null::<GSContainerInfoTag>())).timeSeriesProperties as *const _ as usize
3155 },
3156 40usize,
3157 concat!(
3158 "Offset of field: ",
3159 stringify!(GSContainerInfoTag),
3160 "::",
3161 stringify!(timeSeriesProperties)
3162 )
3163 );
3164 assert_eq!(
3165 unsafe {
3166 &(*(::std::ptr::null::<GSContainerInfoTag>())).triggerInfoCount as *const _ as usize
3167 },
3168 48usize,
3169 concat!(
3170 "Offset of field: ",
3171 stringify!(GSContainerInfoTag),
3172 "::",
3173 stringify!(triggerInfoCount)
3174 )
3175 );
3176 assert_eq!(
3177 unsafe {
3178 &(*(::std::ptr::null::<GSContainerInfoTag>())).triggerInfoList as *const _ as usize
3179 },
3180 56usize,
3181 concat!(
3182 "Offset of field: ",
3183 stringify!(GSContainerInfoTag),
3184 "::",
3185 stringify!(triggerInfoList)
3186 )
3187 );
3188 assert_eq!(
3189 unsafe { &(*(::std::ptr::null::<GSContainerInfoTag>())).dataAffinity as *const _ as usize },
3190 64usize,
3191 concat!(
3192 "Offset of field: ",
3193 stringify!(GSContainerInfoTag),
3194 "::",
3195 stringify!(dataAffinity)
3196 )
3197 );
3198 assert_eq!(
3199 unsafe {
3200 &(*(::std::ptr::null::<GSContainerInfoTag>())).indexInfoCount as *const _ as usize
3201 },
3202 72usize,
3203 concat!(
3204 "Offset of field: ",
3205 stringify!(GSContainerInfoTag),
3206 "::",
3207 stringify!(indexInfoCount)
3208 )
3209 );
3210 assert_eq!(
3211 unsafe {
3212 &(*(::std::ptr::null::<GSContainerInfoTag>())).indexInfoList as *const _ as usize
3213 },
3214 80usize,
3215 concat!(
3216 "Offset of field: ",
3217 stringify!(GSContainerInfoTag),
3218 "::",
3219 stringify!(indexInfoList)
3220 )
3221 );
3222 assert_eq!(
3223 unsafe {
3224 &(*(::std::ptr::null::<GSContainerInfoTag>())).rowKeyColumnCount as *const _ as usize
3225 },
3226 88usize,
3227 concat!(
3228 "Offset of field: ",
3229 stringify!(GSContainerInfoTag),
3230 "::",
3231 stringify!(rowKeyColumnCount)
3232 )
3233 );
3234 assert_eq!(
3235 unsafe {
3236 &(*(::std::ptr::null::<GSContainerInfoTag>())).rowKeyColumnList as *const _ as usize
3237 },
3238 96usize,
3239 concat!(
3240 "Offset of field: ",
3241 stringify!(GSContainerInfoTag),
3242 "::",
3243 stringify!(rowKeyColumnList)
3244 )
3245 );
3246}
3247pub type GSContainerInfo = GSContainerInfoTag;
3248pub type GSBindingGetterFunc = ::std::option::Option<unsafe extern "C" fn() -> *const GSBindingTag>;
3249#[repr(C)]
3250#[derive(Debug, Copy, Clone)]
3251pub struct GSBindingEntryTag {
3252 pub columnName: *const GSChar,
3253 pub elementType: GSType,
3254 pub offset: size_t,
3255 pub arraySizeOffset: size_t,
3256 pub options: GSTypeOption,
3257 pub keyBinding: *const GSBindingTag,
3258 pub keyBindingGetter: GSBindingGetterFunc,
3259}
3260#[test]
3261fn bindgen_test_layout_GSBindingEntryTag() {
3262 assert_eq!(
3263 ::std::mem::size_of::<GSBindingEntryTag>(),
3264 56usize,
3265 concat!("Size of: ", stringify!(GSBindingEntryTag))
3266 );
3267 assert_eq!(
3268 ::std::mem::align_of::<GSBindingEntryTag>(),
3269 8usize,
3270 concat!("Alignment of ", stringify!(GSBindingEntryTag))
3271 );
3272 assert_eq!(
3273 unsafe { &(*(::std::ptr::null::<GSBindingEntryTag>())).columnName as *const _ as usize },
3274 0usize,
3275 concat!(
3276 "Offset of field: ",
3277 stringify!(GSBindingEntryTag),
3278 "::",
3279 stringify!(columnName)
3280 )
3281 );
3282 assert_eq!(
3283 unsafe { &(*(::std::ptr::null::<GSBindingEntryTag>())).elementType as *const _ as usize },
3284 8usize,
3285 concat!(
3286 "Offset of field: ",
3287 stringify!(GSBindingEntryTag),
3288 "::",
3289 stringify!(elementType)
3290 )
3291 );
3292 assert_eq!(
3293 unsafe { &(*(::std::ptr::null::<GSBindingEntryTag>())).offset as *const _ as usize },
3294 16usize,
3295 concat!(
3296 "Offset of field: ",
3297 stringify!(GSBindingEntryTag),
3298 "::",
3299 stringify!(offset)
3300 )
3301 );
3302 assert_eq!(
3303 unsafe {
3304 &(*(::std::ptr::null::<GSBindingEntryTag>())).arraySizeOffset as *const _ as usize
3305 },
3306 24usize,
3307 concat!(
3308 "Offset of field: ",
3309 stringify!(GSBindingEntryTag),
3310 "::",
3311 stringify!(arraySizeOffset)
3312 )
3313 );
3314 assert_eq!(
3315 unsafe { &(*(::std::ptr::null::<GSBindingEntryTag>())).options as *const _ as usize },
3316 32usize,
3317 concat!(
3318 "Offset of field: ",
3319 stringify!(GSBindingEntryTag),
3320 "::",
3321 stringify!(options)
3322 )
3323 );
3324 assert_eq!(
3325 unsafe { &(*(::std::ptr::null::<GSBindingEntryTag>())).keyBinding as *const _ as usize },
3326 40usize,
3327 concat!(
3328 "Offset of field: ",
3329 stringify!(GSBindingEntryTag),
3330 "::",
3331 stringify!(keyBinding)
3332 )
3333 );
3334 assert_eq!(
3335 unsafe {
3336 &(*(::std::ptr::null::<GSBindingEntryTag>())).keyBindingGetter as *const _ as usize
3337 },
3338 48usize,
3339 concat!(
3340 "Offset of field: ",
3341 stringify!(GSBindingEntryTag),
3342 "::",
3343 stringify!(keyBindingGetter)
3344 )
3345 );
3346}
3347pub type GSBindingEntry = GSBindingEntryTag;
3348#[repr(C)]
3349#[derive(Debug, Copy, Clone)]
3350pub struct GSBindingTag {
3351 pub entries: *mut GSBindingEntry,
3352 pub entryCount: size_t,
3353}
3354#[test]
3355fn bindgen_test_layout_GSBindingTag() {
3356 assert_eq!(
3357 ::std::mem::size_of::<GSBindingTag>(),
3358 16usize,
3359 concat!("Size of: ", stringify!(GSBindingTag))
3360 );
3361 assert_eq!(
3362 ::std::mem::align_of::<GSBindingTag>(),
3363 8usize,
3364 concat!("Alignment of ", stringify!(GSBindingTag))
3365 );
3366 assert_eq!(
3367 unsafe { &(*(::std::ptr::null::<GSBindingTag>())).entries as *const _ as usize },
3368 0usize,
3369 concat!(
3370 "Offset of field: ",
3371 stringify!(GSBindingTag),
3372 "::",
3373 stringify!(entries)
3374 )
3375 );
3376 assert_eq!(
3377 unsafe { &(*(::std::ptr::null::<GSBindingTag>())).entryCount as *const _ as usize },
3378 8usize,
3379 concat!(
3380 "Offset of field: ",
3381 stringify!(GSBindingTag),
3382 "::",
3383 stringify!(entryCount)
3384 )
3385 );
3386}
3387pub type GSBinding = GSBindingTag;
3388#[repr(C)]
3389#[derive(Debug, Copy, Clone)]
3390pub struct GSQueryAnalysisEntryTag {
3391 pub id: i32,
3392 pub depth: i32,
3393 pub type_: *const GSChar,
3394 pub valueType: *const GSChar,
3395 pub value: *const GSChar,
3396 pub statement: *const GSChar,
3397}
3398#[test]
3399fn bindgen_test_layout_GSQueryAnalysisEntryTag() {
3400 assert_eq!(
3401 ::std::mem::size_of::<GSQueryAnalysisEntryTag>(),
3402 40usize,
3403 concat!("Size of: ", stringify!(GSQueryAnalysisEntryTag))
3404 );
3405 assert_eq!(
3406 ::std::mem::align_of::<GSQueryAnalysisEntryTag>(),
3407 8usize,
3408 concat!("Alignment of ", stringify!(GSQueryAnalysisEntryTag))
3409 );
3410 assert_eq!(
3411 unsafe { &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).id as *const _ as usize },
3412 0usize,
3413 concat!(
3414 "Offset of field: ",
3415 stringify!(GSQueryAnalysisEntryTag),
3416 "::",
3417 stringify!(id)
3418 )
3419 );
3420 assert_eq!(
3421 unsafe { &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).depth as *const _ as usize },
3422 4usize,
3423 concat!(
3424 "Offset of field: ",
3425 stringify!(GSQueryAnalysisEntryTag),
3426 "::",
3427 stringify!(depth)
3428 )
3429 );
3430 assert_eq!(
3431 unsafe { &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).type_ as *const _ as usize },
3432 8usize,
3433 concat!(
3434 "Offset of field: ",
3435 stringify!(GSQueryAnalysisEntryTag),
3436 "::",
3437 stringify!(type_)
3438 )
3439 );
3440 assert_eq!(
3441 unsafe {
3442 &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).valueType as *const _ as usize
3443 },
3444 16usize,
3445 concat!(
3446 "Offset of field: ",
3447 stringify!(GSQueryAnalysisEntryTag),
3448 "::",
3449 stringify!(valueType)
3450 )
3451 );
3452 assert_eq!(
3453 unsafe { &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).value as *const _ as usize },
3454 24usize,
3455 concat!(
3456 "Offset of field: ",
3457 stringify!(GSQueryAnalysisEntryTag),
3458 "::",
3459 stringify!(value)
3460 )
3461 );
3462 assert_eq!(
3463 unsafe {
3464 &(*(::std::ptr::null::<GSQueryAnalysisEntryTag>())).statement as *const _ as usize
3465 },
3466 32usize,
3467 concat!(
3468 "Offset of field: ",
3469 stringify!(GSQueryAnalysisEntryTag),
3470 "::",
3471 stringify!(statement)
3472 )
3473 );
3474}
3475pub type GSQueryAnalysisEntry = GSQueryAnalysisEntryTag;
3476#[repr(C)]
3477#[derive(Debug, Copy, Clone)]
3478pub struct GSContainerRowEntryTag {
3479 pub containerName: *const GSChar,
3480 pub rowList: *const *mut ::std::os::raw::c_void,
3481 pub rowCount: size_t,
3482}
3483#[test]
3484fn bindgen_test_layout_GSContainerRowEntryTag() {
3485 assert_eq!(
3486 ::std::mem::size_of::<GSContainerRowEntryTag>(),
3487 24usize,
3488 concat!("Size of: ", stringify!(GSContainerRowEntryTag))
3489 );
3490 assert_eq!(
3491 ::std::mem::align_of::<GSContainerRowEntryTag>(),
3492 8usize,
3493 concat!("Alignment of ", stringify!(GSContainerRowEntryTag))
3494 );
3495 assert_eq!(
3496 unsafe {
3497 &(*(::std::ptr::null::<GSContainerRowEntryTag>())).containerName as *const _ as usize
3498 },
3499 0usize,
3500 concat!(
3501 "Offset of field: ",
3502 stringify!(GSContainerRowEntryTag),
3503 "::",
3504 stringify!(containerName)
3505 )
3506 );
3507 assert_eq!(
3508 unsafe { &(*(::std::ptr::null::<GSContainerRowEntryTag>())).rowList as *const _ as usize },
3509 8usize,
3510 concat!(
3511 "Offset of field: ",
3512 stringify!(GSContainerRowEntryTag),
3513 "::",
3514 stringify!(rowList)
3515 )
3516 );
3517 assert_eq!(
3518 unsafe { &(*(::std::ptr::null::<GSContainerRowEntryTag>())).rowCount as *const _ as usize },
3519 16usize,
3520 concat!(
3521 "Offset of field: ",
3522 stringify!(GSContainerRowEntryTag),
3523 "::",
3524 stringify!(rowCount)
3525 )
3526 );
3527}
3528pub type GSContainerRowEntry = GSContainerRowEntryTag;
3529#[repr(C)]
3530#[derive(Debug, Copy, Clone)]
3531pub struct GSRowKeyPredicateEntryTag {
3532 pub containerName: *const GSChar,
3533 pub predicate: *mut GSRowKeyPredicate,
3534}
3535#[test]
3536fn bindgen_test_layout_GSRowKeyPredicateEntryTag() {
3537 assert_eq!(
3538 ::std::mem::size_of::<GSRowKeyPredicateEntryTag>(),
3539 16usize,
3540 concat!("Size of: ", stringify!(GSRowKeyPredicateEntryTag))
3541 );
3542 assert_eq!(
3543 ::std::mem::align_of::<GSRowKeyPredicateEntryTag>(),
3544 8usize,
3545 concat!("Alignment of ", stringify!(GSRowKeyPredicateEntryTag))
3546 );
3547 assert_eq!(
3548 unsafe {
3549 &(*(::std::ptr::null::<GSRowKeyPredicateEntryTag>())).containerName as *const _ as usize
3550 },
3551 0usize,
3552 concat!(
3553 "Offset of field: ",
3554 stringify!(GSRowKeyPredicateEntryTag),
3555 "::",
3556 stringify!(containerName)
3557 )
3558 );
3559 assert_eq!(
3560 unsafe {
3561 &(*(::std::ptr::null::<GSRowKeyPredicateEntryTag>())).predicate as *const _ as usize
3562 },
3563 8usize,
3564 concat!(
3565 "Offset of field: ",
3566 stringify!(GSRowKeyPredicateEntryTag),
3567 "::",
3568 stringify!(predicate)
3569 )
3570 );
3571}
3572pub type GSRowKeyPredicateEntry = GSRowKeyPredicateEntryTag;
3573#[repr(C)]
3574#[derive(Copy, Clone)]
3575pub union GSValueTag {
3576 pub asString: *const GSChar,
3577 pub asBool: GSBool,
3578 pub asByte: i8,
3579 pub asShort: i16,
3580 pub asInteger: i32,
3581 pub asLong: i64,
3582 pub asFloat: f32,
3583 pub asDouble: f64,
3584 pub asTimestamp: GSTimestamp,
3585 pub asGeometry: *const GSChar,
3586 pub asBlob: GSBlob,
3587 pub asArray: GSValueTag__bindgen_ty_1,
3588}
3589#[repr(C)]
3590#[derive(Copy, Clone)]
3591pub struct GSValueTag__bindgen_ty_1 {
3592 pub length: size_t,
3593 pub elements: GSValueTag__bindgen_ty_1__bindgen_ty_1,
3594}
3595#[repr(C)]
3596#[derive(Copy, Clone)]
3597pub union GSValueTag__bindgen_ty_1__bindgen_ty_1 {
3598 pub data: *const ::std::os::raw::c_void,
3599 pub asString: *const *const GSChar,
3600 pub asBool: *const GSBool,
3601 pub asByte: *const i8,
3602 pub asShort: *const i16,
3603 pub asInteger: *const i32,
3604 pub asLong: *const i64,
3605 pub asFloat: *const f32,
3606 pub asDouble: *const f64,
3607 pub asTimestamp: *const GSTimestamp,
3608}
3609#[test]
3610fn bindgen_test_layout_GSValueTag__bindgen_ty_1__bindgen_ty_1() {
3611 assert_eq!(
3612 ::std::mem::size_of::<GSValueTag__bindgen_ty_1__bindgen_ty_1>(),
3613 8usize,
3614 concat!(
3615 "Size of: ",
3616 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1)
3617 )
3618 );
3619 assert_eq!(
3620 ::std::mem::align_of::<GSValueTag__bindgen_ty_1__bindgen_ty_1>(),
3621 8usize,
3622 concat!(
3623 "Alignment of ",
3624 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1)
3625 )
3626 );
3627 assert_eq!(
3628 unsafe {
3629 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).data as *const _
3630 as usize
3631 },
3632 0usize,
3633 concat!(
3634 "Offset of field: ",
3635 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3636 "::",
3637 stringify!(data)
3638 )
3639 );
3640 assert_eq!(
3641 unsafe {
3642 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asString as *const _
3643 as usize
3644 },
3645 0usize,
3646 concat!(
3647 "Offset of field: ",
3648 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3649 "::",
3650 stringify!(asString)
3651 )
3652 );
3653 assert_eq!(
3654 unsafe {
3655 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asBool as *const _
3656 as usize
3657 },
3658 0usize,
3659 concat!(
3660 "Offset of field: ",
3661 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3662 "::",
3663 stringify!(asBool)
3664 )
3665 );
3666 assert_eq!(
3667 unsafe {
3668 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asByte as *const _
3669 as usize
3670 },
3671 0usize,
3672 concat!(
3673 "Offset of field: ",
3674 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3675 "::",
3676 stringify!(asByte)
3677 )
3678 );
3679 assert_eq!(
3680 unsafe {
3681 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asShort as *const _
3682 as usize
3683 },
3684 0usize,
3685 concat!(
3686 "Offset of field: ",
3687 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3688 "::",
3689 stringify!(asShort)
3690 )
3691 );
3692 assert_eq!(
3693 unsafe {
3694 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asInteger as *const _
3695 as usize
3696 },
3697 0usize,
3698 concat!(
3699 "Offset of field: ",
3700 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3701 "::",
3702 stringify!(asInteger)
3703 )
3704 );
3705 assert_eq!(
3706 unsafe {
3707 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asLong as *const _
3708 as usize
3709 },
3710 0usize,
3711 concat!(
3712 "Offset of field: ",
3713 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3714 "::",
3715 stringify!(asLong)
3716 )
3717 );
3718 assert_eq!(
3719 unsafe {
3720 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asFloat as *const _
3721 as usize
3722 },
3723 0usize,
3724 concat!(
3725 "Offset of field: ",
3726 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3727 "::",
3728 stringify!(asFloat)
3729 )
3730 );
3731 assert_eq!(
3732 unsafe {
3733 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asDouble as *const _
3734 as usize
3735 },
3736 0usize,
3737 concat!(
3738 "Offset of field: ",
3739 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3740 "::",
3741 stringify!(asDouble)
3742 )
3743 );
3744 assert_eq!(
3745 unsafe {
3746 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1__bindgen_ty_1>())).asTimestamp
3747 as *const _ as usize
3748 },
3749 0usize,
3750 concat!(
3751 "Offset of field: ",
3752 stringify!(GSValueTag__bindgen_ty_1__bindgen_ty_1),
3753 "::",
3754 stringify!(asTimestamp)
3755 )
3756 );
3757}
3758#[test]
3759fn bindgen_test_layout_GSValueTag__bindgen_ty_1() {
3760 assert_eq!(
3761 ::std::mem::size_of::<GSValueTag__bindgen_ty_1>(),
3762 16usize,
3763 concat!("Size of: ", stringify!(GSValueTag__bindgen_ty_1))
3764 );
3765 assert_eq!(
3766 ::std::mem::align_of::<GSValueTag__bindgen_ty_1>(),
3767 8usize,
3768 concat!("Alignment of ", stringify!(GSValueTag__bindgen_ty_1))
3769 );
3770 assert_eq!(
3771 unsafe { &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1>())).length as *const _ as usize },
3772 0usize,
3773 concat!(
3774 "Offset of field: ",
3775 stringify!(GSValueTag__bindgen_ty_1),
3776 "::",
3777 stringify!(length)
3778 )
3779 );
3780 assert_eq!(
3781 unsafe {
3782 &(*(::std::ptr::null::<GSValueTag__bindgen_ty_1>())).elements as *const _ as usize
3783 },
3784 8usize,
3785 concat!(
3786 "Offset of field: ",
3787 stringify!(GSValueTag__bindgen_ty_1),
3788 "::",
3789 stringify!(elements)
3790 )
3791 );
3792}
3793#[test]
3794fn bindgen_test_layout_GSValueTag() {
3795 assert_eq!(
3796 ::std::mem::size_of::<GSValueTag>(),
3797 16usize,
3798 concat!("Size of: ", stringify!(GSValueTag))
3799 );
3800 assert_eq!(
3801 ::std::mem::align_of::<GSValueTag>(),
3802 8usize,
3803 concat!("Alignment of ", stringify!(GSValueTag))
3804 );
3805 assert_eq!(
3806 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asString as *const _ as usize },
3807 0usize,
3808 concat!(
3809 "Offset of field: ",
3810 stringify!(GSValueTag),
3811 "::",
3812 stringify!(asString)
3813 )
3814 );
3815 assert_eq!(
3816 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asBool as *const _ as usize },
3817 0usize,
3818 concat!(
3819 "Offset of field: ",
3820 stringify!(GSValueTag),
3821 "::",
3822 stringify!(asBool)
3823 )
3824 );
3825 assert_eq!(
3826 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asByte as *const _ as usize },
3827 0usize,
3828 concat!(
3829 "Offset of field: ",
3830 stringify!(GSValueTag),
3831 "::",
3832 stringify!(asByte)
3833 )
3834 );
3835 assert_eq!(
3836 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asShort as *const _ as usize },
3837 0usize,
3838 concat!(
3839 "Offset of field: ",
3840 stringify!(GSValueTag),
3841 "::",
3842 stringify!(asShort)
3843 )
3844 );
3845 assert_eq!(
3846 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asInteger as *const _ as usize },
3847 0usize,
3848 concat!(
3849 "Offset of field: ",
3850 stringify!(GSValueTag),
3851 "::",
3852 stringify!(asInteger)
3853 )
3854 );
3855 assert_eq!(
3856 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asLong as *const _ as usize },
3857 0usize,
3858 concat!(
3859 "Offset of field: ",
3860 stringify!(GSValueTag),
3861 "::",
3862 stringify!(asLong)
3863 )
3864 );
3865 assert_eq!(
3866 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asFloat as *const _ as usize },
3867 0usize,
3868 concat!(
3869 "Offset of field: ",
3870 stringify!(GSValueTag),
3871 "::",
3872 stringify!(asFloat)
3873 )
3874 );
3875 assert_eq!(
3876 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asDouble as *const _ as usize },
3877 0usize,
3878 concat!(
3879 "Offset of field: ",
3880 stringify!(GSValueTag),
3881 "::",
3882 stringify!(asDouble)
3883 )
3884 );
3885 assert_eq!(
3886 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asTimestamp as *const _ as usize },
3887 0usize,
3888 concat!(
3889 "Offset of field: ",
3890 stringify!(GSValueTag),
3891 "::",
3892 stringify!(asTimestamp)
3893 )
3894 );
3895 assert_eq!(
3896 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asGeometry as *const _ as usize },
3897 0usize,
3898 concat!(
3899 "Offset of field: ",
3900 stringify!(GSValueTag),
3901 "::",
3902 stringify!(asGeometry)
3903 )
3904 );
3905 assert_eq!(
3906 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asBlob as *const _ as usize },
3907 0usize,
3908 concat!(
3909 "Offset of field: ",
3910 stringify!(GSValueTag),
3911 "::",
3912 stringify!(asBlob)
3913 )
3914 );
3915 assert_eq!(
3916 unsafe { &(*(::std::ptr::null::<GSValueTag>())).asArray as *const _ as usize },
3917 0usize,
3918 concat!(
3919 "Offset of field: ",
3920 stringify!(GSValueTag),
3921 "::",
3922 stringify!(asArray)
3923 )
3924 );
3925}
3926pub type GSValue = GSValueTag;
3927#[repr(C)]
3928#[derive(Debug, Copy, Clone)]
3929pub struct GSTimeZoneTag {
3930 pub internalData: GSTimeZoneTag__bindgen_ty_1,
3931}
3932#[repr(C)]
3933#[derive(Debug, Copy, Clone)]
3934pub struct GSTimeZoneTag__bindgen_ty_1 {
3935 pub offsetMillis: i64,
3936}
3937#[test]
3938fn bindgen_test_layout_GSTimeZoneTag__bindgen_ty_1() {
3939 assert_eq!(
3940 ::std::mem::size_of::<GSTimeZoneTag__bindgen_ty_1>(),
3941 8usize,
3942 concat!("Size of: ", stringify!(GSTimeZoneTag__bindgen_ty_1))
3943 );
3944 assert_eq!(
3945 ::std::mem::align_of::<GSTimeZoneTag__bindgen_ty_1>(),
3946 8usize,
3947 concat!("Alignment of ", stringify!(GSTimeZoneTag__bindgen_ty_1))
3948 );
3949 assert_eq!(
3950 unsafe {
3951 &(*(::std::ptr::null::<GSTimeZoneTag__bindgen_ty_1>())).offsetMillis as *const _
3952 as usize
3953 },
3954 0usize,
3955 concat!(
3956 "Offset of field: ",
3957 stringify!(GSTimeZoneTag__bindgen_ty_1),
3958 "::",
3959 stringify!(offsetMillis)
3960 )
3961 );
3962}
3963#[test]
3964fn bindgen_test_layout_GSTimeZoneTag() {
3965 assert_eq!(
3966 ::std::mem::size_of::<GSTimeZoneTag>(),
3967 8usize,
3968 concat!("Size of: ", stringify!(GSTimeZoneTag))
3969 );
3970 assert_eq!(
3971 ::std::mem::align_of::<GSTimeZoneTag>(),
3972 8usize,
3973 concat!("Alignment of ", stringify!(GSTimeZoneTag))
3974 );
3975 assert_eq!(
3976 unsafe { &(*(::std::ptr::null::<GSTimeZoneTag>())).internalData as *const _ as usize },
3977 0usize,
3978 concat!(
3979 "Offset of field: ",
3980 stringify!(GSTimeZoneTag),
3981 "::",
3982 stringify!(internalData)
3983 )
3984 );
3985}
3986pub type GSTimeZone = GSTimeZoneTag;
3987extern "C" {
3988 pub fn gsCloseFactory(factory: *mut *mut GSGridStoreFactory, allRelated: GSBool);
3989}
3990extern "C" {
3991 pub fn gsGetDefaultFactory() -> *mut GSGridStoreFactory;
3992}
3993extern "C" {
3994 pub fn gsGetGridStore(
3995 factory: *mut GSGridStoreFactory,
3996 properties: *const GSPropertyEntry,
3997 propertyCount: size_t,
3998 store: *mut *mut GSGridStore,
3999 ) -> GSResult;
4000}
4001extern "C" {
4002 pub fn gsCompatibleFunc_GetGridStore1(
4003 factory: *mut GSGridStoreFactory,
4004 properties: *const GSPropertyEntry,
4005 store: *mut *mut GSGridStore,
4006 ) -> GSResult;
4007}
4008extern "C" {
4009 pub fn gsSetFactoryProperties(
4010 factory: *mut GSGridStoreFactory,
4011 properties: *const GSPropertyEntry,
4012 propertyCount: size_t,
4013 ) -> GSResult;
4014}
4015extern "C" {
4016 pub fn gsCompatibleFunc_SetFactoryProperties1(
4017 factory: *mut GSGridStoreFactory,
4018 properties: *const GSPropertyEntry,
4019 ) -> GSResult;
4020}
4021extern "C" {
4022 pub fn gsCloseGridStore(store: *mut *mut GSGridStore, allRelated: GSBool);
4023}
4024extern "C" {
4025 pub fn gsDropCollection(store: *mut GSGridStore, name: *const GSChar) -> GSResult;
4026}
4027extern "C" {
4028 pub fn gsDropTimeSeries(store: *mut GSGridStore, name: *const GSChar) -> GSResult;
4029}
4030extern "C" {
4031 pub fn gsGetRowByPath(
4032 store: *mut GSGridStore,
4033 pathKey: *const GSChar,
4034 rowObj: *mut ::std::os::raw::c_void,
4035 exists: *mut GSBool,
4036 ) -> GSResult;
4037}
4038extern "C" {
4039 pub fn gsGetCollectionV4_3(
4040 store: *mut GSGridStore,
4041 name: *const GSChar,
4042 binding: *const GSBinding,
4043 collection: *mut *mut GSCollection,
4044 ) -> GSResult;
4045}
4046extern "C" {
4047 pub fn gsGetContainerInfoV4_3(
4048 store: *mut GSGridStore,
4049 name: *const GSChar,
4050 info: *mut GSContainerInfo,
4051 exists: *mut GSBool,
4052 ) -> GSResult;
4053}
4054extern "C" {
4055 pub fn gsGetTimeSeriesV4_3(
4056 store: *mut GSGridStore,
4057 name: *const GSChar,
4058 binding: *const GSBinding,
4059 timeSeries: *mut *mut GSTimeSeries,
4060 ) -> GSResult;
4061}
4062extern "C" {
4063 pub fn gsPutRowByPath(
4064 store: *mut GSGridStore,
4065 pathKey: *const GSChar,
4066 rowObj: *const ::std::os::raw::c_void,
4067 exists: *mut GSBool,
4068 ) -> GSResult;
4069}
4070extern "C" {
4071 pub fn gsPutContainerV4_3(
4072 store: *mut GSGridStore,
4073 name: *const GSChar,
4074 binding: *const GSBinding,
4075 info: *const GSContainerInfo,
4076 modifiable: GSBool,
4077 container: *mut *mut GSContainer,
4078 ) -> GSResult;
4079}
4080extern "C" {
4081 pub fn gsPutCollectionV4_3(
4082 store: *mut GSGridStore,
4083 name: *const GSChar,
4084 binding: *const GSBinding,
4085 properties: *const GSCollectionProperties,
4086 modifiable: GSBool,
4087 collection: *mut *mut GSCollection,
4088 ) -> GSResult;
4089}
4090extern "C" {
4091 pub fn gsPutTimeSeriesV4_3(
4092 store: *mut GSGridStore,
4093 name: *const GSChar,
4094 binding: *const GSBinding,
4095 properties: *const GSTimeSeriesProperties,
4096 modifiable: GSBool,
4097 timeSeries: *mut *mut GSTimeSeries,
4098 ) -> GSResult;
4099}
4100extern "C" {
4101 pub fn gsRemoveRowByPath(
4102 store: *mut GSGridStore,
4103 pathKey: *const GSChar,
4104 exists: *mut GSBool,
4105 ) -> GSResult;
4106}
4107extern "C" {
4108 pub fn gsDeleteRowByPath(
4109 store: *mut GSGridStore,
4110 pathKey: *const GSChar,
4111 exists: *mut GSBool,
4112 ) -> GSResult;
4113}
4114extern "C" {
4115 pub fn gsPutContainerGeneralV4_3(
4116 store: *mut GSGridStore,
4117 name: *const GSChar,
4118 info: *const GSContainerInfo,
4119 modifiable: GSBool,
4120 container: *mut *mut GSContainer,
4121 ) -> GSResult;
4122}
4123extern "C" {
4124 pub fn gsGetContainerGeneral(
4125 store: *mut GSGridStore,
4126 name: *const GSChar,
4127 container: *mut *mut GSContainer,
4128 ) -> GSResult;
4129}
4130extern "C" {
4131 pub fn gsPutCollectionGeneralV4_3(
4132 store: *mut GSGridStore,
4133 name: *const GSChar,
4134 info: *const GSContainerInfo,
4135 modifiable: GSBool,
4136 container: *mut *mut GSContainer,
4137 ) -> GSResult;
4138}
4139extern "C" {
4140 pub fn gsGetCollectionGeneral(
4141 store: *mut GSGridStore,
4142 name: *const GSChar,
4143 collection: *mut *mut GSCollection,
4144 ) -> GSResult;
4145}
4146extern "C" {
4147 pub fn gsPutTimeSeriesGeneralV4_3(
4148 store: *mut GSGridStore,
4149 name: *const GSChar,
4150 info: *const GSContainerInfo,
4151 modifiable: GSBool,
4152 timeSeries: *mut *mut GSTimeSeries,
4153 ) -> GSResult;
4154}
4155extern "C" {
4156 pub fn gsGetTimeSeriesGeneral(
4157 store: *mut GSGridStore,
4158 name: *const GSChar,
4159 timeSeries: *mut *mut GSTimeSeries,
4160 ) -> GSResult;
4161}
4162extern "C" {
4163 pub fn gsDropContainer(store: *mut GSGridStore, name: *const GSChar) -> GSResult;
4164}
4165extern "C" {
4166 pub fn gsCreateRowByStoreV4_3(
4167 store: *mut GSGridStore,
4168 info: *const GSContainerInfo,
4169 row: *mut *mut GSRow,
4170 ) -> GSResult;
4171}
4172extern "C" {
4173 pub fn gsCreateRowKeyByStore(
4174 store: *mut GSGridStore,
4175 info: *const GSContainerInfo,
4176 key: *mut *mut GSRowKey,
4177 ) -> GSResult;
4178}
4179extern "C" {
4180 pub fn gsFetchAll(
4181 store: *mut GSGridStore,
4182 queryList: *const *mut GSQuery,
4183 queryCount: size_t,
4184 ) -> GSResult;
4185}
4186extern "C" {
4187 pub fn gsPutMultipleContainerRows(
4188 store: *mut GSGridStore,
4189 entryList: *const GSContainerRowEntry,
4190 entryCount: size_t,
4191 ) -> GSResult;
4192}
4193extern "C" {
4194 pub fn gsGetMultipleContainerRows(
4195 store: *mut GSGridStore,
4196 predicateList: *const *const GSRowKeyPredicateEntry,
4197 predicateCount: size_t,
4198 entryList: *mut *const GSContainerRowEntry,
4199 entryCount: *mut size_t,
4200 ) -> GSResult;
4201}
4202extern "C" {
4203 pub fn gsGetPartitionController(
4204 store: *mut GSGridStore,
4205 partitionController: *mut *mut GSPartitionController,
4206 ) -> GSResult;
4207}
4208extern "C" {
4209 pub fn gsCreateRowKeyPredicate(
4210 store: *mut GSGridStore,
4211 keyType: GSType,
4212 predicate: *mut *mut GSRowKeyPredicate,
4213 ) -> GSResult;
4214}
4215extern "C" {
4216 pub fn gsCreateRowKeyPredicateGeneral(
4217 store: *mut GSGridStore,
4218 info: *const GSContainerInfo,
4219 predicate: *mut *mut GSRowKeyPredicate,
4220 ) -> GSResult;
4221}
4222extern "C" {
4223 pub fn gsCloseContainer(container: *mut *mut GSContainer, allRelated: GSBool);
4224}
4225extern "C" {
4226 pub fn gsCreateEventNotification(container: *mut GSContainer, url: *const GSChar) -> GSResult;
4227}
4228extern "C" {
4229 pub fn gsCreateTrigger(container: *mut GSContainer, info: *const GSTriggerInfo) -> GSResult;
4230}
4231extern "C" {
4232 pub fn gsCreateIndex(
4233 container: *mut GSContainer,
4234 columnName: *const GSChar,
4235 flags: GSIndexTypeFlags,
4236 ) -> GSResult;
4237}
4238extern "C" {
4239 pub fn gsCreateIndexDetailV4_3(
4240 container: *mut GSContainer,
4241 info: *const GSIndexInfo,
4242 ) -> GSResult;
4243}
4244extern "C" {
4245 pub fn gsDropEventNotification(container: *mut GSContainer, url: *const GSChar) -> GSResult;
4246}
4247extern "C" {
4248 pub fn gsDropTrigger(container: *mut GSContainer, name: *const GSChar) -> GSResult;
4249}
4250extern "C" {
4251 pub fn gsDropIndex(
4252 container: *mut GSContainer,
4253 columnName: *const GSChar,
4254 flags: GSIndexTypeFlags,
4255 ) -> GSResult;
4256}
4257extern "C" {
4258 pub fn gsDropIndexDetailV4_3(container: *mut GSContainer, info: *const GSIndexInfo)
4259 -> GSResult;
4260}
4261extern "C" {
4262 pub fn gsFlush(container: *mut GSContainer) -> GSResult;
4263}
4264extern "C" {
4265 pub fn gsGetRow(
4266 container: *mut GSContainer,
4267 key: *const ::std::os::raw::c_void,
4268 rowObj: *mut ::std::os::raw::c_void,
4269 exists: *mut GSBool,
4270 ) -> GSResult;
4271}
4272extern "C" {
4273 pub fn gsPutRow(
4274 container: *mut GSContainer,
4275 key: *const ::std::os::raw::c_void,
4276 rowObj: *const ::std::os::raw::c_void,
4277 exists: *mut GSBool,
4278 ) -> GSResult;
4279}
4280extern "C" {
4281 pub fn gsPutMultipleRows(
4282 container: *mut GSContainer,
4283 rowObjs: *const *const ::std::os::raw::c_void,
4284 rowCount: size_t,
4285 exists: *mut GSBool,
4286 ) -> GSResult;
4287}
4288extern "C" {
4289 pub fn gsCompatibleFunc_PutMultipleRows1(
4290 container: *mut GSContainer,
4291 rowCount: size_t,
4292 rowObjs: *const *const ::std::os::raw::c_void,
4293 exists: *mut GSBool,
4294 ) -> GSResult;
4295}
4296extern "C" {
4297 pub fn gsQuery(
4298 container: *mut GSContainer,
4299 queryString: *const GSChar,
4300 query: *mut *mut GSQuery,
4301 ) -> GSResult;
4302}
4303extern "C" {
4304 pub fn gsRemoveRow(
4305 container: *mut GSContainer,
4306 key: *const ::std::os::raw::c_void,
4307 exists: *mut GSBool,
4308 ) -> GSResult;
4309}
4310extern "C" {
4311 pub fn gsDeleteRow(
4312 container: *mut GSContainer,
4313 key: *const ::std::os::raw::c_void,
4314 exists: *mut GSBool,
4315 ) -> GSResult;
4316}
4317extern "C" {
4318 pub fn gsGetContainerType(container: *mut GSContainer, type_: *mut GSContainerType)
4319 -> GSResult;
4320}
4321extern "C" {
4322 pub fn gsCreateRowByContainer(container: *mut GSContainer, row: *mut *mut GSRow) -> GSResult;
4323}
4324extern "C" {
4325 pub fn gsAbort(container: *mut GSContainer) -> GSResult;
4326}
4327extern "C" {
4328 pub fn gsCommit(container: *mut GSContainer) -> GSResult;
4329}
4330extern "C" {
4331 pub fn gsGetRowForUpdate(
4332 container: *mut GSContainer,
4333 key: *const ::std::os::raw::c_void,
4334 rowObj: *mut ::std::os::raw::c_void,
4335 exists: *mut GSBool,
4336 ) -> GSResult;
4337}
4338extern "C" {
4339 pub fn gsSetAutoCommit(container: *mut GSContainer, enabled: GSBool) -> GSResult;
4340}
4341extern "C" {
4342 pub fn gsGetRowByInteger(
4343 container: *mut GSContainer,
4344 key: i32,
4345 rowObj: *mut ::std::os::raw::c_void,
4346 forUpdate: GSBool,
4347 exists: *mut GSBool,
4348 ) -> GSResult;
4349}
4350extern "C" {
4351 pub fn gsGetRowByLong(
4352 container: *mut GSContainer,
4353 key: i64,
4354 rowObj: *mut ::std::os::raw::c_void,
4355 forUpdate: GSBool,
4356 exists: *mut GSBool,
4357 ) -> GSResult;
4358}
4359extern "C" {
4360 pub fn gsGetRowByTimestamp(
4361 container: *mut GSContainer,
4362 key: GSTimestamp,
4363 rowObj: *mut ::std::os::raw::c_void,
4364 forUpdate: GSBool,
4365 exists: *mut GSBool,
4366 ) -> GSResult;
4367}
4368extern "C" {
4369 pub fn gsGetRowByString(
4370 container: *mut GSContainer,
4371 key: *const GSChar,
4372 rowObj: *mut ::std::os::raw::c_void,
4373 forUpdate: GSBool,
4374 exists: *mut GSBool,
4375 ) -> GSResult;
4376}
4377extern "C" {
4378 pub fn gsPutRowByInteger(
4379 container: *mut GSContainer,
4380 key: i32,
4381 rowObj: *const ::std::os::raw::c_void,
4382 exists: *mut GSBool,
4383 ) -> GSResult;
4384}
4385extern "C" {
4386 pub fn gsPutRowByLong(
4387 container: *mut GSContainer,
4388 key: i64,
4389 rowObj: *const ::std::os::raw::c_void,
4390 exists: *mut GSBool,
4391 ) -> GSResult;
4392}
4393extern "C" {
4394 pub fn gsPutRowByTimestamp(
4395 container: *mut GSContainer,
4396 key: GSTimestamp,
4397 rowObj: *const ::std::os::raw::c_void,
4398 exists: *mut GSBool,
4399 ) -> GSResult;
4400}
4401extern "C" {
4402 pub fn gsPutRowByString(
4403 container: *mut GSContainer,
4404 key: *const GSChar,
4405 rowObj: *const ::std::os::raw::c_void,
4406 exists: *mut GSBool,
4407 ) -> GSResult;
4408}
4409extern "C" {
4410 pub fn gsRemoveRowByInteger(
4411 container: *mut GSContainer,
4412 key: i32,
4413 exists: *mut GSBool,
4414 ) -> GSResult;
4415}
4416extern "C" {
4417 pub fn gsRemoveRowByLong(
4418 container: *mut GSContainer,
4419 key: i64,
4420 exists: *mut GSBool,
4421 ) -> GSResult;
4422}
4423extern "C" {
4424 pub fn gsRemoveRowByTimestamp(
4425 container: *mut GSContainer,
4426 key: GSTimestamp,
4427 exists: *mut GSBool,
4428 ) -> GSResult;
4429}
4430extern "C" {
4431 pub fn gsRemoveRowByString(
4432 container: *mut GSContainer,
4433 key: *const GSChar,
4434 exists: *mut GSBool,
4435 ) -> GSResult;
4436}
4437extern "C" {
4438 pub fn gsDeleteRowByInteger(
4439 container: *mut GSContainer,
4440 key: i32,
4441 exists: *mut GSBool,
4442 ) -> GSResult;
4443}
4444extern "C" {
4445 pub fn gsDeleteRowByLong(
4446 container: *mut GSContainer,
4447 key: i64,
4448 exists: *mut GSBool,
4449 ) -> GSResult;
4450}
4451extern "C" {
4452 pub fn gsDeleteRowByTimestamp(
4453 container: *mut GSContainer,
4454 key: GSTimestamp,
4455 exists: *mut GSBool,
4456 ) -> GSResult;
4457}
4458extern "C" {
4459 pub fn gsDeleteRowByString(
4460 container: *mut GSContainer,
4461 key: *const GSChar,
4462 exists: *mut GSBool,
4463 ) -> GSResult;
4464}
4465extern "C" {
4466 pub fn gsGetRowGeneral(
4467 container: *mut GSContainer,
4468 keyObj: *mut GSRowKey,
4469 rowObj: *mut GSRow,
4470 forUpdate: GSBool,
4471 exists: *mut GSBool,
4472 ) -> GSResult;
4473}
4474extern "C" {
4475 pub fn gsPutRowGeneral(
4476 container: *mut GSContainer,
4477 keyObj: *mut GSRowKey,
4478 rowObj: *mut GSRow,
4479 exists: *mut GSBool,
4480 ) -> GSResult;
4481}
4482extern "C" {
4483 pub fn gsDeleteRowGeneral(
4484 container: *mut GSContainer,
4485 keyObj: *mut GSRowKey,
4486 exists: *mut GSBool,
4487 ) -> GSResult;
4488}
4489extern "C" {
4490 pub fn gsQueryByGeometry(
4491 collection: *mut GSCollection,
4492 column: *const GSChar,
4493 geometry: *const GSChar,
4494 geometryOp: GSGeometryOperator,
4495 query: *mut *mut GSQuery,
4496 ) -> GSResult;
4497}
4498extern "C" {
4499 pub fn gsQueryByGeometryWithDisjointCondition(
4500 collection: *mut GSCollection,
4501 column: *const GSChar,
4502 geometryIntersection: *const GSChar,
4503 geometryDisjoint: *const GSChar,
4504 query: *mut *mut GSQuery,
4505 ) -> GSResult;
4506}
4507extern "C" {
4508 pub fn gsQueryByGeometryWithExclusion(
4509 collection: *mut GSCollection,
4510 column: *const GSChar,
4511 geometryIntersection: *const GSChar,
4512 geometryDisjoint: *const GSChar,
4513 query: *mut *mut GSQuery,
4514 ) -> GSResult;
4515}
4516extern "C" {
4517 pub fn gsAggregateTimeSeries(
4518 timeSeries: *mut GSTimeSeries,
4519 start: GSTimestamp,
4520 end: GSTimestamp,
4521 column: *const GSChar,
4522 aggregation: GSAggregation,
4523 aggregationResult: *mut *mut GSAggregationResult,
4524 ) -> GSResult;
4525}
4526extern "C" {
4527 pub fn gsAppendTimeSeriesRow(
4528 timeSeries: *mut GSTimeSeries,
4529 rowObj: *const ::std::os::raw::c_void,
4530 exists: *mut GSBool,
4531 ) -> GSResult;
4532}
4533extern "C" {
4534 pub fn gsGetRowByBaseTime(
4535 timeSeries: *mut GSTimeSeries,
4536 base: GSTimestamp,
4537 timeOp: GSTimeOperator,
4538 rowObj: *mut ::std::os::raw::c_void,
4539 exists: *mut GSBool,
4540 ) -> GSResult;
4541}
4542extern "C" {
4543 pub fn gsInterpolateTimeSeriesRow(
4544 timeSeries: *mut GSTimeSeries,
4545 base: GSTimestamp,
4546 column: *const GSChar,
4547 rowObj: *mut ::std::os::raw::c_void,
4548 exists: *mut GSBool,
4549 ) -> GSResult;
4550}
4551extern "C" {
4552 pub fn gsQueryByTimeSeriesRange(
4553 timeSeries: *mut GSTimeSeries,
4554 start: GSTimestamp,
4555 end: GSTimestamp,
4556 query: *mut *mut GSQuery,
4557 ) -> GSResult;
4558}
4559extern "C" {
4560 pub fn gsQueryByTimeSeriesOrderedRange(
4561 timeSeries: *mut GSTimeSeries,
4562 start: *const GSTimestamp,
4563 end: *const GSTimestamp,
4564 order: GSQueryOrder,
4565 query: *mut *mut GSQuery,
4566 ) -> GSResult;
4567}
4568extern "C" {
4569 pub fn gsQueryByTimeSeriesSampling(
4570 timeSeries: *mut GSTimeSeries,
4571 start: GSTimestamp,
4572 end: GSTimestamp,
4573 columnSet: *const *const GSChar,
4574 columnCount: size_t,
4575 mode: GSInterpolationMode,
4576 interval: i32,
4577 intervalUnit: GSTimeUnit,
4578 query: *mut *mut GSQuery,
4579 ) -> GSResult;
4580}
4581extern "C" {
4582 pub fn gsCompatibleFunc_QueryByTimeSeriesSampling1(
4583 timeSeries: *mut GSTimeSeries,
4584 start: GSTimestamp,
4585 end: GSTimestamp,
4586 columnSet: *const *const GSChar,
4587 interval: i32,
4588 intervalUnit: GSTimeUnit,
4589 query: *mut *mut GSQuery,
4590 ) -> GSResult;
4591}
4592extern "C" {
4593 pub fn gsCloseRow(row: *mut *mut GSRow);
4594}
4595extern "C" {
4596 pub fn gsGetRowSchemaV4_3(row: *mut GSRow, schemaInfo: *mut GSContainerInfo) -> GSResult;
4597}
4598extern "C" {
4599 pub fn gsSetRowFieldGeneral(
4600 row: *mut GSRow,
4601 column: i32,
4602 fieldValue: *const GSValue,
4603 type_: GSType,
4604 ) -> GSResult;
4605}
4606extern "C" {
4607 pub fn gsGetRowFieldGeneral(
4608 row: *mut GSRow,
4609 column: i32,
4610 fieldValue: *mut GSValue,
4611 type_: *mut GSType,
4612 ) -> GSResult;
4613}
4614extern "C" {
4615 pub fn gsSetRowFieldNull(row: *mut GSRow, column: i32) -> GSResult;
4616}
4617extern "C" {
4618 pub fn gsGetRowFieldNull(row: *mut GSRow, column: i32, nullValue: *mut GSBool) -> GSResult;
4619}
4620extern "C" {
4621 pub fn gsSetRowFieldByString(
4622 row: *mut GSRow,
4623 column: i32,
4624 fieldValue: *const GSChar,
4625 ) -> GSResult;
4626}
4627extern "C" {
4628 pub fn gsGetRowFieldAsString(
4629 row: *mut GSRow,
4630 column: i32,
4631 fieldValue: *mut *const GSChar,
4632 ) -> GSResult;
4633}
4634extern "C" {
4635 pub fn gsSetRowFieldByBool(row: *mut GSRow, column: i32, fieldValue: GSBool) -> GSResult;
4636}
4637extern "C" {
4638 pub fn gsGetRowFieldAsBool(row: *mut GSRow, column: i32, fieldValue: *mut GSBool) -> GSResult;
4639}
4640extern "C" {
4641 pub fn gsSetRowFieldByByte(row: *mut GSRow, column: i32, fieldValue: i8) -> GSResult;
4642}
4643extern "C" {
4644 pub fn gsGetRowFieldAsByte(row: *mut GSRow, column: i32, fieldValue: *mut i8) -> GSResult;
4645}
4646extern "C" {
4647 pub fn gsSetRowFieldByShort(row: *mut GSRow, column: i32, fieldValue: i16) -> GSResult;
4648}
4649extern "C" {
4650 pub fn gsGetRowFieldAsShort(row: *mut GSRow, column: i32, fieldValue: *mut i16) -> GSResult;
4651}
4652extern "C" {
4653 pub fn gsSetRowFieldByInteger(row: *mut GSRow, column: i32, fieldValue: i32) -> GSResult;
4654}
4655extern "C" {
4656 pub fn gsGetRowFieldAsInteger(row: *mut GSRow, column: i32, fieldValue: *mut i32) -> GSResult;
4657}
4658extern "C" {
4659 pub fn gsSetRowFieldByLong(row: *mut GSRow, column: i32, fieldValue: i64) -> GSResult;
4660}
4661extern "C" {
4662 pub fn gsGetRowFieldAsLong(row: *mut GSRow, column: i32, fieldValue: *mut i64) -> GSResult;
4663}
4664extern "C" {
4665 pub fn gsSetRowFieldByFloat(row: *mut GSRow, column: i32, fieldValue: f32) -> GSResult;
4666}
4667extern "C" {
4668 pub fn gsGetRowFieldAsFloat(row: *mut GSRow, column: i32, fieldValue: *mut f32) -> GSResult;
4669}
4670extern "C" {
4671 pub fn gsSetRowFieldByDouble(row: *mut GSRow, column: i32, fieldValue: f64) -> GSResult;
4672}
4673extern "C" {
4674 pub fn gsGetRowFieldAsDouble(row: *mut GSRow, column: i32, fieldValue: *mut f64) -> GSResult;
4675}
4676extern "C" {
4677 pub fn gsSetRowFieldByTimestamp(
4678 row: *mut GSRow,
4679 column: i32,
4680 fieldValue: GSTimestamp,
4681 ) -> GSResult;
4682}
4683extern "C" {
4684 pub fn gsGetRowFieldAsTimestamp(
4685 row: *mut GSRow,
4686 column: i32,
4687 fieldValue: *mut GSTimestamp,
4688 ) -> GSResult;
4689}
4690extern "C" {
4691 pub fn gsSetRowFieldByGeometry(
4692 row: *mut GSRow,
4693 column: i32,
4694 fieldValue: *const GSChar,
4695 ) -> GSResult;
4696}
4697extern "C" {
4698 pub fn gsGetRowFieldAsGeometry(
4699 row: *mut GSRow,
4700 column: i32,
4701 fieldValue: *mut *const GSChar,
4702 ) -> GSResult;
4703}
4704extern "C" {
4705 pub fn gsSetRowFieldByBlob(row: *mut GSRow, column: i32, fieldValue: *const GSBlob)
4706 -> GSResult;
4707}
4708extern "C" {
4709 pub fn gsGetRowFieldAsBlob(row: *mut GSRow, column: i32, fieldValue: *mut GSBlob) -> GSResult;
4710}
4711extern "C" {
4712 pub fn gsSetRowFieldByStringArray(
4713 row: *mut GSRow,
4714 column: i32,
4715 fieldValue: *const *const GSChar,
4716 size: size_t,
4717 ) -> GSResult;
4718}
4719extern "C" {
4720 pub fn gsGetRowFieldAsStringArray(
4721 row: *mut GSRow,
4722 column: i32,
4723 fieldValue: *mut *const *const GSChar,
4724 size: *mut size_t,
4725 ) -> GSResult;
4726}
4727extern "C" {
4728 pub fn gsSetRowFieldByBoolArray(
4729 row: *mut GSRow,
4730 column: i32,
4731 fieldValue: *const GSBool,
4732 size: size_t,
4733 ) -> GSResult;
4734}
4735extern "C" {
4736 pub fn gsGetRowFieldAsBoolArray(
4737 row: *mut GSRow,
4738 column: i32,
4739 fieldValue: *mut *const GSBool,
4740 size: *mut size_t,
4741 ) -> GSResult;
4742}
4743extern "C" {
4744 pub fn gsSetRowFieldByByteArray(
4745 row: *mut GSRow,
4746 column: i32,
4747 fieldValue: *const i8,
4748 size: size_t,
4749 ) -> GSResult;
4750}
4751extern "C" {
4752 pub fn gsGetRowFieldAsByteArray(
4753 row: *mut GSRow,
4754 column: i32,
4755 fieldValue: *mut *const i8,
4756 size: *mut size_t,
4757 ) -> GSResult;
4758}
4759extern "C" {
4760 pub fn gsSetRowFieldByShortArray(
4761 row: *mut GSRow,
4762 column: i32,
4763 fieldValue: *const i16,
4764 size: size_t,
4765 ) -> GSResult;
4766}
4767extern "C" {
4768 pub fn gsGetRowFieldAsShortArray(
4769 row: *mut GSRow,
4770 column: i32,
4771 fieldValue: *mut *const i16,
4772 size: *mut size_t,
4773 ) -> GSResult;
4774}
4775extern "C" {
4776 pub fn gsSetRowFieldByIntegerArray(
4777 row: *mut GSRow,
4778 column: i32,
4779 fieldValue: *const i32,
4780 size: size_t,
4781 ) -> GSResult;
4782}
4783extern "C" {
4784 pub fn gsGetRowFieldAsIntegerArray(
4785 row: *mut GSRow,
4786 column: i32,
4787 fieldValue: *mut *const i32,
4788 size: *mut size_t,
4789 ) -> GSResult;
4790}
4791extern "C" {
4792 pub fn gsSetRowFieldByLongArray(
4793 row: *mut GSRow,
4794 column: i32,
4795 fieldValue: *const i64,
4796 size: size_t,
4797 ) -> GSResult;
4798}
4799extern "C" {
4800 pub fn gsGetRowFieldAsLongArray(
4801 row: *mut GSRow,
4802 column: i32,
4803 fieldValue: *mut *const i64,
4804 size: *mut size_t,
4805 ) -> GSResult;
4806}
4807extern "C" {
4808 pub fn gsSetRowFieldByFloatArray(
4809 row: *mut GSRow,
4810 column: i32,
4811 fieldValue: *const f32,
4812 size: size_t,
4813 ) -> GSResult;
4814}
4815extern "C" {
4816 pub fn gsGetRowFieldAsFloatArray(
4817 row: *mut GSRow,
4818 column: i32,
4819 fieldValue: *mut *const f32,
4820 size: *mut size_t,
4821 ) -> GSResult;
4822}
4823extern "C" {
4824 pub fn gsSetRowFieldByDoubleArray(
4825 row: *mut GSRow,
4826 column: i32,
4827 fieldValue: *const f64,
4828 size: size_t,
4829 ) -> GSResult;
4830}
4831extern "C" {
4832 pub fn gsGetRowFieldAsDoubleArray(
4833 row: *mut GSRow,
4834 column: i32,
4835 fieldValue: *mut *const f64,
4836 size: *mut size_t,
4837 ) -> GSResult;
4838}
4839extern "C" {
4840 pub fn gsSetRowFieldByTimestampArray(
4841 row: *mut GSRow,
4842 column: i32,
4843 fieldValue: *const GSTimestamp,
4844 size: size_t,
4845 ) -> GSResult;
4846}
4847extern "C" {
4848 pub fn gsGetRowFieldAsTimestampArray(
4849 row: *mut GSRow,
4850 column: i32,
4851 fieldValue: *mut *const GSTimestamp,
4852 size: *mut size_t,
4853 ) -> GSResult;
4854}
4855extern "C" {
4856 pub fn gsCreateRowByRow(row: *mut GSRow, destRow: *mut *mut GSRow) -> GSResult;
4857}
4858extern "C" {
4859 pub fn gsCreateRowKeyByRow(row: *mut GSRow, key: *mut *mut GSRowKey) -> GSResult;
4860}
4861extern "C" {
4862 pub fn gsCloseQuery(query: *mut *mut GSQuery);
4863}
4864extern "C" {
4865 pub fn gsFetch(query: *mut GSQuery, forUpdate: GSBool, rowSet: *mut *mut GSRowSet) -> GSResult;
4866}
4867extern "C" {
4868 pub fn gsSetFetchOption(
4869 query: *mut GSQuery,
4870 fetchOption: GSFetchOption,
4871 value: *const ::std::os::raw::c_void,
4872 valueType: GSType,
4873 ) -> GSResult;
4874}
4875extern "C" {
4876 pub fn gsGetRowSet(query: *mut GSQuery, rowSet: *mut *mut GSRowSet) -> GSResult;
4877}
4878extern "C" {
4879 pub fn gsCloseRowSet(rowSet: *mut *mut GSRowSet);
4880}
4881extern "C" {
4882 pub fn gsDeleteCurrentRow(rowSet: *mut GSRowSet) -> GSResult;
4883}
4884extern "C" {
4885 pub fn gsGetNextRow(rowSet: *mut GSRowSet, rowObj: *mut ::std::os::raw::c_void) -> GSResult;
4886}
4887extern "C" {
4888 pub fn gsGetNextAggregation(
4889 rowSet: *mut GSRowSet,
4890 aggregationResult: *mut *mut GSAggregationResult,
4891 ) -> GSResult;
4892}
4893extern "C" {
4894 pub fn gsGetNextQueryAnalysis(
4895 rowSet: *mut GSRowSet,
4896 queryAnalysis: *mut GSQueryAnalysisEntry,
4897 ) -> GSResult;
4898}
4899extern "C" {
4900 pub fn gsGetRowSetType(rowSet: *mut GSRowSet) -> GSRowSetType;
4901}
4902extern "C" {
4903 pub fn gsGetRowSetSize(rowSet: *mut GSRowSet) -> i32;
4904}
4905extern "C" {
4906 pub fn gsHasNextRow(rowSet: *mut GSRowSet) -> GSBool;
4907}
4908extern "C" {
4909 pub fn gsUpdateCurrentRow(
4910 rowSet: *mut GSRowSet,
4911 rowObj: *const ::std::os::raw::c_void,
4912 ) -> GSResult;
4913}
4914extern "C" {
4915 pub fn gsCloseAggregationResult(aggregationResult: *mut *mut GSAggregationResult);
4916}
4917extern "C" {
4918 pub fn gsGetAggregationValue(
4919 aggregationResult: *mut GSAggregationResult,
4920 value: *mut ::std::os::raw::c_void,
4921 valueType: GSType,
4922 ) -> GSBool;
4923}
4924extern "C" {
4925 pub fn gsGetAggregationValueAsLong(
4926 aggregationResult: *mut GSAggregationResult,
4927 value: *mut i64,
4928 assigned: *mut GSBool,
4929 ) -> GSResult;
4930}
4931extern "C" {
4932 pub fn gsGetAggregationValueAsDouble(
4933 aggregationResult: *mut GSAggregationResult,
4934 value: *mut f64,
4935 assigned: *mut GSBool,
4936 ) -> GSResult;
4937}
4938extern "C" {
4939 pub fn gsGetAggregationValueAsTimestamp(
4940 aggregationResult: *mut GSAggregationResult,
4941 value: *mut GSTimestamp,
4942 assigned: *mut GSBool,
4943 ) -> GSResult;
4944}
4945extern "C" {
4946 pub fn gsCloseRowKeyPredicate(predicate: *mut *mut GSRowKeyPredicate);
4947}
4948extern "C" {
4949 pub fn gsGetPredicateKeyType(
4950 predicate: *mut GSRowKeyPredicate,
4951 keyType: *mut GSType,
4952 ) -> GSResult;
4953}
4954extern "C" {
4955 pub fn gsGetPredicateKeySchema(
4956 predicate: *mut GSRowKeyPredicate,
4957 info: *mut GSContainerInfo,
4958 ) -> GSResult;
4959}
4960extern "C" {
4961 pub fn gsGetPredicateStartGeneralKey(
4962 predicate: *mut GSRowKeyPredicate,
4963 keyObj: *mut *mut GSRowKey,
4964 ) -> GSResult;
4965}
4966extern "C" {
4967 pub fn gsGetPredicateStartKeyGeneral(
4968 predicate: *mut GSRowKeyPredicate,
4969 startKey: *mut *const GSValue,
4970 ) -> GSResult;
4971}
4972extern "C" {
4973 pub fn gsGetPredicateStartKeyAsString(
4974 predicate: *mut GSRowKeyPredicate,
4975 startKey: *mut *const GSChar,
4976 ) -> GSResult;
4977}
4978extern "C" {
4979 pub fn gsGetPredicateStartKeyAsInteger(
4980 predicate: *mut GSRowKeyPredicate,
4981 startKey: *mut *const i32,
4982 ) -> GSResult;
4983}
4984extern "C" {
4985 pub fn gsGetPredicateStartKeyAsLong(
4986 predicate: *mut GSRowKeyPredicate,
4987 startKey: *mut *const i64,
4988 ) -> GSResult;
4989}
4990extern "C" {
4991 pub fn gsGetPredicateStartKeyAsTimestamp(
4992 predicate: *mut GSRowKeyPredicate,
4993 startKey: *mut *const GSTimestamp,
4994 ) -> GSResult;
4995}
4996extern "C" {
4997 pub fn gsGetPredicateFinishGeneralKey(
4998 predicate: *mut GSRowKeyPredicate,
4999 keyObj: *mut *mut GSRowKey,
5000 ) -> GSResult;
5001}
5002extern "C" {
5003 pub fn gsGetPredicateFinishKeyGeneral(
5004 predicate: *mut GSRowKeyPredicate,
5005 finishKey: *mut *const GSValue,
5006 ) -> GSResult;
5007}
5008extern "C" {
5009 pub fn gsGetPredicateFinishKeyAsString(
5010 predicate: *mut GSRowKeyPredicate,
5011 finishKey: *mut *const GSChar,
5012 ) -> GSResult;
5013}
5014extern "C" {
5015 pub fn gsGetPredicateFinishKeyAsInteger(
5016 predicate: *mut GSRowKeyPredicate,
5017 finishKey: *mut *const i32,
5018 ) -> GSResult;
5019}
5020extern "C" {
5021 pub fn gsGetPredicateFinishKeyAsLong(
5022 predicate: *mut GSRowKeyPredicate,
5023 finishKey: *mut *const i64,
5024 ) -> GSResult;
5025}
5026extern "C" {
5027 pub fn gsGetPredicateFinishKeyAsTimestamp(
5028 predicate: *mut GSRowKeyPredicate,
5029 finishKey: *mut *const GSTimestamp,
5030 ) -> GSResult;
5031}
5032extern "C" {
5033 pub fn gsGetPredicateDistinctGeneralKeys(
5034 predicate: *mut GSRowKeyPredicate,
5035 keyObjList: *mut *const *mut GSRowKey,
5036 size: *mut size_t,
5037 ) -> GSResult;
5038}
5039extern "C" {
5040 pub fn gsGetPredicateDistinctKeysGeneral(
5041 predicate: *mut GSRowKeyPredicate,
5042 keyList: *mut *const GSValue,
5043 size: *mut size_t,
5044 ) -> GSResult;
5045}
5046extern "C" {
5047 pub fn gsGetPredicateDistinctKeysAsString(
5048 predicate: *mut GSRowKeyPredicate,
5049 keyList: *mut *const *const GSChar,
5050 size: *mut size_t,
5051 ) -> GSResult;
5052}
5053extern "C" {
5054 pub fn gsGetPredicateDistinctKeysAsInteger(
5055 predicate: *mut GSRowKeyPredicate,
5056 keyList: *mut *const i32,
5057 size: *mut size_t,
5058 ) -> GSResult;
5059}
5060extern "C" {
5061 pub fn gsGetPredicateDistinctKeysAsLong(
5062 predicate: *mut GSRowKeyPredicate,
5063 keyList: *mut *const i64,
5064 size: *mut size_t,
5065 ) -> GSResult;
5066}
5067extern "C" {
5068 pub fn gsGetPredicateDistinctKeysAsTimestamp(
5069 predicate: *mut GSRowKeyPredicate,
5070 keyList: *mut *const GSTimestamp,
5071 size: *mut size_t,
5072 ) -> GSResult;
5073}
5074extern "C" {
5075 pub fn gsSetPredicateStartGeneralKey(
5076 predicate: *mut GSRowKeyPredicate,
5077 keyObj: *mut GSRowKey,
5078 ) -> GSResult;
5079}
5080extern "C" {
5081 pub fn gsSetPredicateStartKeyGeneral(
5082 predicate: *mut GSRowKeyPredicate,
5083 startKey: *const GSValue,
5084 keyType: GSType,
5085 ) -> GSResult;
5086}
5087extern "C" {
5088 pub fn gsSetPredicateStartKeyByString(
5089 predicate: *mut GSRowKeyPredicate,
5090 startKey: *const GSChar,
5091 ) -> GSResult;
5092}
5093extern "C" {
5094 pub fn gsSetPredicateStartKeyByInteger(
5095 predicate: *mut GSRowKeyPredicate,
5096 startKey: *const i32,
5097 ) -> GSResult;
5098}
5099extern "C" {
5100 pub fn gsSetPredicateStartKeyByLong(
5101 predicate: *mut GSRowKeyPredicate,
5102 startKey: *const i64,
5103 ) -> GSResult;
5104}
5105extern "C" {
5106 pub fn gsSetPredicateStartKeyByTimestamp(
5107 predicate: *mut GSRowKeyPredicate,
5108 startKey: *const GSTimestamp,
5109 ) -> GSResult;
5110}
5111extern "C" {
5112 pub fn gsSetPredicateFinishGeneralKey(
5113 predicate: *mut GSRowKeyPredicate,
5114 keyObj: *mut GSRowKey,
5115 ) -> GSResult;
5116}
5117extern "C" {
5118 pub fn gsSetPredicateFinishKeyGeneral(
5119 predicate: *mut GSRowKeyPredicate,
5120 finishKey: *const GSValue,
5121 keyType: GSType,
5122 ) -> GSResult;
5123}
5124extern "C" {
5125 pub fn gsSetPredicateFinishKeyByString(
5126 predicate: *mut GSRowKeyPredicate,
5127 finishKey: *const GSChar,
5128 ) -> GSResult;
5129}
5130extern "C" {
5131 pub fn gsSetPredicateFinishKeyByInteger(
5132 predicate: *mut GSRowKeyPredicate,
5133 finishKey: *const i32,
5134 ) -> GSResult;
5135}
5136extern "C" {
5137 pub fn gsSetPredicateFinishKeyByLong(
5138 predicate: *mut GSRowKeyPredicate,
5139 finishKey: *const i64,
5140 ) -> GSResult;
5141}
5142extern "C" {
5143 pub fn gsSetPredicateFinishKeyByTimestamp(
5144 predicate: *mut GSRowKeyPredicate,
5145 finishKey: *const GSTimestamp,
5146 ) -> GSResult;
5147}
5148extern "C" {
5149 pub fn gsAddPredicateGeneralKey(
5150 predicate: *mut GSRowKeyPredicate,
5151 keyObj: *mut GSRowKey,
5152 ) -> GSResult;
5153}
5154extern "C" {
5155 pub fn gsAddPredicateKeyGeneral(
5156 predicate: *mut GSRowKeyPredicate,
5157 key: *const GSValue,
5158 keyType: GSType,
5159 ) -> GSResult;
5160}
5161extern "C" {
5162 pub fn gsAddPredicateKeyByString(
5163 predicate: *mut GSRowKeyPredicate,
5164 key: *const GSChar,
5165 ) -> GSResult;
5166}
5167extern "C" {
5168 pub fn gsAddPredicateKeyByInteger(predicate: *mut GSRowKeyPredicate, key: i32) -> GSResult;
5169}
5170extern "C" {
5171 pub fn gsAddPredicateKeyByLong(predicate: *mut GSRowKeyPredicate, key: i64) -> GSResult;
5172}
5173extern "C" {
5174 pub fn gsAddPredicateKeyByTimestamp(
5175 predicate: *mut GSRowKeyPredicate,
5176 key: GSTimestamp,
5177 ) -> GSResult;
5178}
5179extern "C" {
5180 pub fn gsClosePartitionController(controller: *mut *mut GSPartitionController);
5181}
5182extern "C" {
5183 pub fn gsGetPartitionCount(
5184 controller: *mut GSPartitionController,
5185 partitionCount: *mut i32,
5186 ) -> GSResult;
5187}
5188extern "C" {
5189 pub fn gsGetPartitionContainerCount(
5190 controller: *mut GSPartitionController,
5191 partitionIndex: i32,
5192 containerCount: *mut i64,
5193 ) -> GSResult;
5194}
5195extern "C" {
5196 pub fn gsGetPartitionContainerNames(
5197 controller: *mut GSPartitionController,
5198 partitionIndex: i32,
5199 start: i64,
5200 limit: *const i64,
5201 nameList: *mut *const *const GSChar,
5202 size: *mut size_t,
5203 ) -> GSResult;
5204}
5205extern "C" {
5206 pub fn gsGetPartitionHosts(
5207 controller: *mut GSPartitionController,
5208 partitionIndex: i32,
5209 addressList: *mut *const *const GSChar,
5210 size: *mut size_t,
5211 ) -> GSResult;
5212}
5213extern "C" {
5214 pub fn gsGetPartitionOwnerHost(
5215 controller: *mut GSPartitionController,
5216 partitionIndex: i32,
5217 address: *mut *const GSChar,
5218 ) -> GSResult;
5219}
5220extern "C" {
5221 pub fn gsGetPartitionBackupHosts(
5222 controller: *mut GSPartitionController,
5223 partitionIndex: i32,
5224 addressList: *mut *const *const GSChar,
5225 size: *mut size_t,
5226 ) -> GSResult;
5227}
5228extern "C" {
5229 pub fn gsAssignPartitionPreferableHost(
5230 controller: *mut GSPartitionController,
5231 partitionIndex: i32,
5232 host: *const GSChar,
5233 ) -> GSResult;
5234}
5235extern "C" {
5236 pub fn gsGetPartitionIndexOfContainer(
5237 controller: *mut GSPartitionController,
5238 containerName: *const GSChar,
5239 partitionIndex: *mut i32,
5240 ) -> GSResult;
5241}
5242extern "C" {
5243 pub fn gsCurrentTime() -> GSTimestamp;
5244}
5245extern "C" {
5246 pub fn gsGetTimeField(timestamp: GSTimestamp, timeUnit: GSTimeUnit) -> i64;
5247}
5248extern "C" {
5249 pub fn gsGetZonedTimeField(
5250 timestamp: GSTimestamp,
5251 timeUnit: GSTimeUnit,
5252 zone: *const GSTimeZone,
5253 ) -> i64;
5254}
5255extern "C" {
5256 pub fn gsSetTimeField(timestamp: *mut GSTimestamp, field: i64, timeUnit: GSTimeUnit) -> GSBool;
5257}
5258extern "C" {
5259 pub fn gsSetZonedTimeField(
5260 timestamp: *mut GSTimestamp,
5261 field: i64,
5262 timeUnit: GSTimeUnit,
5263 zone: *const GSTimeZone,
5264 ) -> GSBool;
5265}
5266extern "C" {
5267 pub fn gsAddTimeV4_3(timestamp: GSTimestamp, amount: i64, timeUnit: GSTimeUnit) -> GSTimestamp;
5268}
5269extern "C" {
5270 pub fn gsAddZonedTime(
5271 timestamp: GSTimestamp,
5272 amount: i64,
5273 timeUnit: GSTimeUnit,
5274 zone: *const GSTimeZone,
5275 ) -> GSTimestamp;
5276}
5277extern "C" {
5278 pub fn gsGetTimeDiff(
5279 timestamp1: GSTimestamp,
5280 timestamp2: GSTimestamp,
5281 timeUnit: GSTimeUnit,
5282 ) -> i64;
5283}
5284extern "C" {
5285 pub fn gsGetZonedTimeDiff(
5286 timestamp1: GSTimestamp,
5287 timestamp2: GSTimestamp,
5288 timeUnit: GSTimeUnit,
5289 zone: *const GSTimeZone,
5290 ) -> i64;
5291}
5292extern "C" {
5293 pub fn gsFormatTime(timestamp: GSTimestamp, strBuf: *mut GSChar, bufSize: size_t) -> size_t;
5294}
5295extern "C" {
5296 pub fn gsFormatZonedTime(
5297 timestamp: GSTimestamp,
5298 strBuf: *mut GSChar,
5299 bufSize: size_t,
5300 zone: *const GSTimeZone,
5301 ) -> size_t;
5302}
5303extern "C" {
5304 pub fn gsParseTime(str_: *const GSChar, timestamp: *mut GSTimestamp) -> GSBool;
5305}
5306extern "C" {
5307 pub fn gsGetTimeZoneOffset(zone: *const GSTimeZone, timeUnit: GSTimeUnit) -> i64;
5308}
5309extern "C" {
5310 pub fn gsSetTimeZoneOffset(zone: *mut GSTimeZone, offset: i64, timeUnit: GSTimeUnit) -> GSBool;
5311}
5312extern "C" {
5313 pub fn gsFormatTimeZone(
5314 zone: *const GSTimeZone,
5315 strBuf: *mut GSChar,
5316 bufSize: size_t,
5317 ) -> size_t;
5318}
5319extern "C" {
5320 pub fn gsParseTimeZone(str_: *const GSChar, zone: *mut GSTimeZone) -> GSBool;
5321}
5322extern "C" {
5323 pub fn gsGetErrorStackSize(gsResource: *mut ::std::os::raw::c_void) -> size_t;
5324}
5325extern "C" {
5326 pub fn gsGetErrorCode(gsResource: *mut ::std::os::raw::c_void, stackIndex: size_t) -> GSResult;
5327}
5328extern "C" {
5329 pub fn gsFormatErrorMessage(
5330 gsResource: *mut ::std::os::raw::c_void,
5331 stackIndex: size_t,
5332 strBuf: *mut GSChar,
5333 bufSize: size_t,
5334 ) -> size_t;
5335}
5336extern "C" {
5337 pub fn gsFormatErrorLocation(
5338 gsResource: *mut ::std::os::raw::c_void,
5339 stackIndex: size_t,
5340 strBuf: *mut GSChar,
5341 bufSize: size_t,
5342 ) -> size_t;
5343}
5344extern "C" {
5345 pub fn gsIsRecoverableError(result: GSResult) -> GSBool;
5346}
5347extern "C" {
5348 pub fn gsIsTimeoutError(result: GSResult) -> GSBool;
5349}
5350extern "C" {
5351 pub fn gsFormatErrorName(
5352 gsResource: *mut ::std::os::raw::c_void,
5353 stackIndex: size_t,
5354 strBuf: *mut GSChar,
5355 bufSize: size_t,
5356 ) -> size_t;
5357}
5358extern "C" {
5359 pub fn gsFormatErrorDescription(
5360 gsResource: *mut ::std::os::raw::c_void,
5361 stackIndex: size_t,
5362 strBuf: *mut GSChar,
5363 bufSize: size_t,
5364 ) -> size_t;
5365}
5366extern "C" {
5367 pub fn gsGetErrorParameterCount(
5368 gsResource: *mut ::std::os::raw::c_void,
5369 stackIndex: size_t,
5370 ) -> size_t;
5371}
5372extern "C" {
5373 pub fn gsFormatErrorParameterName(
5374 gsResource: *mut ::std::os::raw::c_void,
5375 stackIndex: size_t,
5376 parameterIndex: size_t,
5377 strBuf: *mut GSChar,
5378 bufSize: size_t,
5379 ) -> size_t;
5380}
5381extern "C" {
5382 pub fn gsFormatErrorParameterValue(
5383 gsResource: *mut ::std::os::raw::c_void,
5384 stackIndex: size_t,
5385 parameterIndex: size_t,
5386 strBuf: *mut GSChar,
5387 bufSize: size_t,
5388 ) -> size_t;
5389}