pub const _STDIO_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 31;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 1;
pub const _IONBF: u32 = 2;
pub const BUFSIZ: u32 = 8192;
pub const EOF: i32 = -1;
pub const SEEK_SET: u32 = 0;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const P_tmpdir: &[u8; 5] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const FOPEN_MAX: u32 = 16;
pub const MQTT_INVALID_PROPERTY_ID: i32 = -2;
pub const MQTTCLIENT_PERSISTENCE_DEFAULT: u32 = 0;
pub const MQTTCLIENT_PERSISTENCE_NONE: u32 = 1;
pub const MQTTCLIENT_PERSISTENCE_USER: u32 = 2;
pub const MQTTCLIENT_PERSISTENCE_ERROR: i32 = -2;
pub const MQTTASYNC_SUCCESS: u32 = 0;
pub const MQTTASYNC_FAILURE: i32 = -1;
pub const MQTTASYNC_PERSISTENCE_ERROR: i32 = -2;
pub const MQTTASYNC_DISCONNECTED: i32 = -3;
pub const MQTTASYNC_MAX_MESSAGES_INFLIGHT: i32 = -4;
pub const MQTTASYNC_BAD_UTF8_STRING: i32 = -5;
pub const MQTTASYNC_NULL_PARAMETER: i32 = -6;
pub const MQTTASYNC_TOPICNAME_TRUNCATED: i32 = -7;
pub const MQTTASYNC_BAD_STRUCTURE: i32 = -8;
pub const MQTTASYNC_BAD_QOS: i32 = -9;
pub const MQTTASYNC_NO_MORE_MSGIDS: i32 = -10;
pub const MQTTASYNC_OPERATION_INCOMPLETE: i32 = -11;
pub const MQTTASYNC_MAX_BUFFERED_MESSAGES: i32 = -12;
pub const MQTTASYNC_SSL_NOT_SUPPORTED: i32 = -13;
pub const MQTTASYNC_BAD_PROTOCOL: i32 = -14;
pub const MQTTASYNC_BAD_MQTT_OPTION: i32 = -15;
pub const MQTTASYNC_WRONG_MQTT_VERSION: i32 = -16;
pub const MQTTASYNC_0_LEN_WILL_TOPIC: i32 = -17;
pub const MQTTASYNC_COMMAND_IGNORED: i32 = -18;
pub const MQTTASYNC_MAX_BUFFERED: i32 = -19;
pub const MQTTVERSION_DEFAULT: u32 = 0;
pub const MQTTVERSION_3_1: u32 = 3;
pub const MQTTVERSION_3_1_1: u32 = 4;
pub const MQTTVERSION_5: u32 = 5;
pub const MQTT_BAD_SUBSCRIBE: u32 = 128;
pub const MQTT_SSL_VERSION_DEFAULT: u32 = 0;
pub const MQTT_SSL_VERSION_TLS_1_0: u32 = 1;
pub const MQTT_SSL_VERSION_TLS_1_1: u32 = 2;
pub const MQTT_SSL_VERSION_TLS_1_2: u32 = 3;
pub const MQTTASYNC_TRUE: u32 = 1;
pub type __gnuc_va_list = __builtin_va_list;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
pub __count: ::std::os::raw::c_int,
pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
pub __wch: ::std::os::raw::c_uint,
pub __wchb: [::std::os::raw::c_char; 4usize],
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
#[test]
fn bindgen_test_layout___mbstate_t() {
const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
8usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__value)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
pub __pos: __off_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_G_fpos_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
pub __pos: __off64_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_G_fpos64_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos64_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos64_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos64_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type va_list = __gnuc_va_list;
pub type off_t = __off_t;
pub type fpos_t = __fpos_t;
extern "C" {
pub static mut stdin: *mut FILE;
}
extern "C" {
pub static mut stdout: *mut FILE;
}
extern "C" {
pub static mut stderr: *mut FILE;
}
extern "C" {
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
__old: *const ::std::os::raw::c_char,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn renameat(
__oldfd: ::std::os::raw::c_int,
__old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tempnam(
__dir: *const ::std::os::raw::c_char,
__pfx: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn freopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
-> *mut FILE;
}
extern "C" {
pub fn fmemopen(
__s: *mut ::std::os::raw::c_void,
__len: usize,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn open_memstream(
__bufloc: *mut *mut ::std::os::raw::c_char,
__sizeloc: *mut usize,
) -> *mut FILE;
}
extern "C" {
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn setvbuf(
__stream: *mut FILE,
__buf: *mut ::std::os::raw::c_char,
__modes: ::std::os::raw::c_int,
__n: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
}
extern "C" {
pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
pub fn fprintf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfprintf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vprintf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn snprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsnprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vdprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fscanf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_fscanf"]
pub fn fscanf1(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_scanf"]
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_sscanf"]
pub fn sscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfscanf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vscanf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vfscanf"]
pub fn vfscanf1(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vscanf"]
pub fn vscanf1(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vsscanf"]
pub fn vsscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
__s: *mut ::std::os::raw::c_char,
__n: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getline(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
__ptr: *mut ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__stream: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fwrite(
__ptr: *const ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__s: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fread_unlocked(
__ptr: *mut ::std::os::raw::c_void,
__size: usize,
__n: usize,
__stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn fwrite_unlocked(
__ptr: *const ::std::os::raw::c_void,
__size: usize,
__n: usize,
__stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn fseek(
__stream: *mut FILE,
__off: ::std::os::raw::c_long,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn rewind(__stream: *mut FILE);
}
extern "C" {
pub fn fseeko(
__stream: *mut FILE,
__off: __off_t,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
pub static mut sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
extern "C" {
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn popen(
__command: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_PAYLOAD_FORMAT_INDICATOR: MQTTPropertyCodes = 1;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_MESSAGE_EXPIRY_INTERVAL: MQTTPropertyCodes = 2;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_CONTENT_TYPE: MQTTPropertyCodes = 3;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_RESPONSE_TOPIC: MQTTPropertyCodes = 8;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_CORRELATION_DATA: MQTTPropertyCodes = 9;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER: MQTTPropertyCodes = 11;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SESSION_EXPIRY_INTERVAL: MQTTPropertyCodes = 17;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_ASSIGNED_CLIENT_IDENTIFER: MQTTPropertyCodes = 18;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SERVER_KEEP_ALIVE: MQTTPropertyCodes = 19;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_AUTHENTICATION_METHOD: MQTTPropertyCodes = 21;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_AUTHENTICATION_DATA: MQTTPropertyCodes = 22;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_REQUEST_PROBLEM_INFORMATION: MQTTPropertyCodes = 23;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_WILL_DELAY_INTERVAL: MQTTPropertyCodes = 24;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_REQUEST_RESPONSE_INFORMATION: MQTTPropertyCodes = 25;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_RESPONSE_INFORMATION: MQTTPropertyCodes = 26;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SERVER_REFERENCE: MQTTPropertyCodes = 28;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_REASON_STRING: MQTTPropertyCodes = 31;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_RECEIVE_MAXIMUM: MQTTPropertyCodes = 33;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM: MQTTPropertyCodes = 34;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_TOPIC_ALIAS: MQTTPropertyCodes = 35;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_MAXIMUM_QOS: MQTTPropertyCodes = 36;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_RETAIN_AVAILABLE: MQTTPropertyCodes = 37;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_USER_PROPERTY: MQTTPropertyCodes = 38;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_MAXIMUM_PACKET_SIZE: MQTTPropertyCodes = 39;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_WILDCARD_SUBSCRIPTION_AVAILABLE: MQTTPropertyCodes =
40;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIERS_AVAILABLE:
MQTTPropertyCodes = 41;
pub const MQTTPropertyCodes_MQTTPROPERTY_CODE_SHARED_SUBSCRIPTION_AVAILABLE: MQTTPropertyCodes = 42;
pub type MQTTPropertyCodes = ::std::os::raw::c_uint;
extern "C" {
pub fn MQTTPropertyName(value: MQTTPropertyCodes) -> *const ::std::os::raw::c_char;
}
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_BYTE: MQTTPropertyTypes = 0;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_TWO_BYTE_INTEGER: MQTTPropertyTypes = 1;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_FOUR_BYTE_INTEGER: MQTTPropertyTypes = 2;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_VARIABLE_BYTE_INTEGER: MQTTPropertyTypes = 3;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_BINARY_DATA: MQTTPropertyTypes = 4;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_UTF_8_ENCODED_STRING: MQTTPropertyTypes = 5;
pub const MQTTPropertyTypes_MQTTPROPERTY_TYPE_UTF_8_STRING_PAIR: MQTTPropertyTypes = 6;
pub type MQTTPropertyTypes = ::std::os::raw::c_uint;
extern "C" {
pub fn MQTTProperty_getType(value: MQTTPropertyCodes) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTLenString {
pub len: ::std::os::raw::c_int,
pub data: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MQTTLenString() {
const UNINIT: ::std::mem::MaybeUninit<MQTTLenString> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTLenString>(),
16usize,
concat!("Size of: ", stringify!(MQTTLenString))
);
assert_eq!(
::std::mem::align_of::<MQTTLenString>(),
8usize,
concat!("Alignment of ", stringify!(MQTTLenString))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTLenString),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTLenString),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MQTTProperty {
pub identifier: MQTTPropertyCodes,
pub value: MQTTProperty__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MQTTProperty__bindgen_ty_1 {
pub byte: ::std::os::raw::c_uchar,
pub integer2: ::std::os::raw::c_ushort,
pub integer4: ::std::os::raw::c_uint,
pub __bindgen_anon_1: MQTTProperty__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTProperty__bindgen_ty_1__bindgen_ty_1 {
pub data: MQTTLenString,
pub value: MQTTLenString,
}
#[test]
fn bindgen_test_layout_MQTTProperty__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTProperty__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTProperty__bindgen_ty_1__bindgen_ty_1>(),
32usize,
concat!(
"Size of: ",
stringify!(MQTTProperty__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<MQTTProperty__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTProperty__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(value)
)
);
}
#[test]
fn bindgen_test_layout_MQTTProperty__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTProperty__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTProperty__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(MQTTProperty__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<MQTTProperty__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(MQTTProperty__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).byte) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty__bindgen_ty_1),
"::",
stringify!(byte)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integer2) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty__bindgen_ty_1),
"::",
stringify!(integer2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integer4) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty__bindgen_ty_1),
"::",
stringify!(integer4)
)
);
}
#[test]
fn bindgen_test_layout_MQTTProperty() {
const UNINIT: ::std::mem::MaybeUninit<MQTTProperty> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTProperty>(),
40usize,
concat!("Size of: ", stringify!(MQTTProperty))
);
assert_eq!(
::std::mem::align_of::<MQTTProperty>(),
8usize,
concat!("Alignment of ", stringify!(MQTTProperty))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperty),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTProperties {
pub count: ::std::os::raw::c_int,
pub max_count: ::std::os::raw::c_int,
pub length: ::std::os::raw::c_int,
pub array: *mut MQTTProperty,
}
#[test]
fn bindgen_test_layout_MQTTProperties() {
const UNINIT: ::std::mem::MaybeUninit<MQTTProperties> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTProperties>(),
24usize,
concat!("Size of: ", stringify!(MQTTProperties))
);
assert_eq!(
::std::mem::align_of::<MQTTProperties>(),
8usize,
concat!("Alignment of ", stringify!(MQTTProperties))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperties),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperties),
"::",
stringify!(max_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperties),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).array) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTProperties),
"::",
stringify!(array)
)
);
}
extern "C" {
pub fn MQTTProperties_len(props: *mut MQTTProperties) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_add(
props: *mut MQTTProperties,
prop: *const MQTTProperty,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_write(
pptr: *mut *mut ::std::os::raw::c_char,
properties: *const MQTTProperties,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_read(
properties: *mut MQTTProperties,
pptr: *mut *mut ::std::os::raw::c_char,
enddata: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_free(properties: *mut MQTTProperties);
}
extern "C" {
pub fn MQTTProperties_copy(props: *const MQTTProperties) -> MQTTProperties;
}
extern "C" {
pub fn MQTTProperties_hasProperty(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_propertyCount(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_getNumericValue(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_getNumericValueAt(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
index: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTProperties_getProperty(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
) -> *mut MQTTProperty;
}
extern "C" {
pub fn MQTTProperties_getPropertyAt(
props: *mut MQTTProperties,
propid: MQTTPropertyCodes,
index: ::std::os::raw::c_int,
) -> *mut MQTTProperty;
}
pub const MQTTReasonCodes_MQTTREASONCODE_SUCCESS: MQTTReasonCodes = 0;
pub const MQTTReasonCodes_MQTTREASONCODE_NORMAL_DISCONNECTION: MQTTReasonCodes = 0;
pub const MQTTReasonCodes_MQTTREASONCODE_GRANTED_QOS_0: MQTTReasonCodes = 0;
pub const MQTTReasonCodes_MQTTREASONCODE_GRANTED_QOS_1: MQTTReasonCodes = 1;
pub const MQTTReasonCodes_MQTTREASONCODE_GRANTED_QOS_2: MQTTReasonCodes = 2;
pub const MQTTReasonCodes_MQTTREASONCODE_DISCONNECT_WITH_WILL_MESSAGE: MQTTReasonCodes = 4;
pub const MQTTReasonCodes_MQTTREASONCODE_NO_MATCHING_SUBSCRIBERS: MQTTReasonCodes = 16;
pub const MQTTReasonCodes_MQTTREASONCODE_NO_SUBSCRIPTION_FOUND: MQTTReasonCodes = 17;
pub const MQTTReasonCodes_MQTTREASONCODE_CONTINUE_AUTHENTICATION: MQTTReasonCodes = 24;
pub const MQTTReasonCodes_MQTTREASONCODE_RE_AUTHENTICATE: MQTTReasonCodes = 25;
pub const MQTTReasonCodes_MQTTREASONCODE_UNSPECIFIED_ERROR: MQTTReasonCodes = 128;
pub const MQTTReasonCodes_MQTTREASONCODE_MALFORMED_PACKET: MQTTReasonCodes = 129;
pub const MQTTReasonCodes_MQTTREASONCODE_PROTOCOL_ERROR: MQTTReasonCodes = 130;
pub const MQTTReasonCodes_MQTTREASONCODE_IMPLEMENTATION_SPECIFIC_ERROR: MQTTReasonCodes = 131;
pub const MQTTReasonCodes_MQTTREASONCODE_UNSUPPORTED_PROTOCOL_VERSION: MQTTReasonCodes = 132;
pub const MQTTReasonCodes_MQTTREASONCODE_CLIENT_IDENTIFIER_NOT_VALID: MQTTReasonCodes = 133;
pub const MQTTReasonCodes_MQTTREASONCODE_BAD_USER_NAME_OR_PASSWORD: MQTTReasonCodes = 134;
pub const MQTTReasonCodes_MQTTREASONCODE_NOT_AUTHORIZED: MQTTReasonCodes = 135;
pub const MQTTReasonCodes_MQTTREASONCODE_SERVER_UNAVAILABLE: MQTTReasonCodes = 136;
pub const MQTTReasonCodes_MQTTREASONCODE_SERVER_BUSY: MQTTReasonCodes = 137;
pub const MQTTReasonCodes_MQTTREASONCODE_BANNED: MQTTReasonCodes = 138;
pub const MQTTReasonCodes_MQTTREASONCODE_SERVER_SHUTTING_DOWN: MQTTReasonCodes = 139;
pub const MQTTReasonCodes_MQTTREASONCODE_BAD_AUTHENTICATION_METHOD: MQTTReasonCodes = 140;
pub const MQTTReasonCodes_MQTTREASONCODE_KEEP_ALIVE_TIMEOUT: MQTTReasonCodes = 141;
pub const MQTTReasonCodes_MQTTREASONCODE_SESSION_TAKEN_OVER: MQTTReasonCodes = 142;
pub const MQTTReasonCodes_MQTTREASONCODE_TOPIC_FILTER_INVALID: MQTTReasonCodes = 143;
pub const MQTTReasonCodes_MQTTREASONCODE_TOPIC_NAME_INVALID: MQTTReasonCodes = 144;
pub const MQTTReasonCodes_MQTTREASONCODE_PACKET_IDENTIFIER_IN_USE: MQTTReasonCodes = 145;
pub const MQTTReasonCodes_MQTTREASONCODE_PACKET_IDENTIFIER_NOT_FOUND: MQTTReasonCodes = 146;
pub const MQTTReasonCodes_MQTTREASONCODE_RECEIVE_MAXIMUM_EXCEEDED: MQTTReasonCodes = 147;
pub const MQTTReasonCodes_MQTTREASONCODE_TOPIC_ALIAS_INVALID: MQTTReasonCodes = 148;
pub const MQTTReasonCodes_MQTTREASONCODE_PACKET_TOO_LARGE: MQTTReasonCodes = 149;
pub const MQTTReasonCodes_MQTTREASONCODE_MESSAGE_RATE_TOO_HIGH: MQTTReasonCodes = 150;
pub const MQTTReasonCodes_MQTTREASONCODE_QUOTA_EXCEEDED: MQTTReasonCodes = 151;
pub const MQTTReasonCodes_MQTTREASONCODE_ADMINISTRATIVE_ACTION: MQTTReasonCodes = 152;
pub const MQTTReasonCodes_MQTTREASONCODE_PAYLOAD_FORMAT_INVALID: MQTTReasonCodes = 153;
pub const MQTTReasonCodes_MQTTREASONCODE_RETAIN_NOT_SUPPORTED: MQTTReasonCodes = 154;
pub const MQTTReasonCodes_MQTTREASONCODE_QOS_NOT_SUPPORTED: MQTTReasonCodes = 155;
pub const MQTTReasonCodes_MQTTREASONCODE_USE_ANOTHER_SERVER: MQTTReasonCodes = 156;
pub const MQTTReasonCodes_MQTTREASONCODE_SERVER_MOVED: MQTTReasonCodes = 157;
pub const MQTTReasonCodes_MQTTREASONCODE_SHARED_SUBSCRIPTIONS_NOT_SUPPORTED: MQTTReasonCodes = 158;
pub const MQTTReasonCodes_MQTTREASONCODE_CONNECTION_RATE_EXCEEDED: MQTTReasonCodes = 159;
pub const MQTTReasonCodes_MQTTREASONCODE_MAXIMUM_CONNECT_TIME: MQTTReasonCodes = 160;
pub const MQTTReasonCodes_MQTTREASONCODE_SUBSCRIPTION_IDENTIFIERS_NOT_SUPPORTED: MQTTReasonCodes =
161;
pub const MQTTReasonCodes_MQTTREASONCODE_WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED: MQTTReasonCodes =
162;
pub type MQTTReasonCodes = ::std::os::raw::c_uint;
extern "C" {
pub fn MQTTReasonCode_toString(value: MQTTReasonCodes) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTSubscribe_options {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub noLocal: ::std::os::raw::c_uchar,
pub retainAsPublished: ::std::os::raw::c_uchar,
pub retainHandling: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_MQTTSubscribe_options() {
const UNINIT: ::std::mem::MaybeUninit<MQTTSubscribe_options> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTSubscribe_options>(),
12usize,
concat!("Size of: ", stringify!(MQTTSubscribe_options))
);
assert_eq!(
::std::mem::align_of::<MQTTSubscribe_options>(),
4usize,
concat!("Alignment of ", stringify!(MQTTSubscribe_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTSubscribe_options),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTSubscribe_options),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).noLocal) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTSubscribe_options),
"::",
stringify!(noLocal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retainAsPublished) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(MQTTSubscribe_options),
"::",
stringify!(retainAsPublished)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retainHandling) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(MQTTSubscribe_options),
"::",
stringify!(retainHandling)
)
);
}
pub type Persistence_open = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut *mut ::std::os::raw::c_void,
clientID: *const ::std::os::raw::c_char,
serverURI: *const ::std::os::raw::c_char,
context: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type Persistence_close = ::std::option::Option<
unsafe extern "C" fn(handle: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type Persistence_put = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
key: *mut ::std::os::raw::c_char,
bufcount: ::std::os::raw::c_int,
buffers: *mut *mut ::std::os::raw::c_char,
buflens: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type Persistence_get = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
key: *mut ::std::os::raw::c_char,
buffer: *mut *mut ::std::os::raw::c_char,
buflen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type Persistence_remove = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
key: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>;
pub type Persistence_keys = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
keys: *mut *mut *mut ::std::os::raw::c_char,
nkeys: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type Persistence_clear = ::std::option::Option<
unsafe extern "C" fn(handle: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type Persistence_containskey = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
key: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTClient_persistence {
pub context: *mut ::std::os::raw::c_void,
pub popen: Persistence_open,
pub pclose: Persistence_close,
pub pput: Persistence_put,
pub pget: Persistence_get,
pub premove: Persistence_remove,
pub pkeys: Persistence_keys,
pub pclear: Persistence_clear,
pub pcontainskey: Persistence_containskey,
}
#[test]
fn bindgen_test_layout_MQTTClient_persistence() {
const UNINIT: ::std::mem::MaybeUninit<MQTTClient_persistence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTClient_persistence>(),
72usize,
concat!("Size of: ", stringify!(MQTTClient_persistence))
);
assert_eq!(
::std::mem::align_of::<MQTTClient_persistence>(),
8usize,
concat!("Alignment of ", stringify!(MQTTClient_persistence))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).popen) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(popen)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pclose) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pclose)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pput) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pput)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pget) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pget)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).premove) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(premove)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pkeys) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pkeys)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pclear) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pclear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pcontainskey) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTClient_persistence),
"::",
stringify!(pcontainskey)
)
);
}
pub type MQTTPersistence_beforeWrite = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
bufcount: ::std::os::raw::c_int,
buffers: *mut *mut ::std::os::raw::c_char,
buflens: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type MQTTPersistence_afterRead = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
buffer: *mut *mut ::std::os::raw::c_char,
buflen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_init_options {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub do_openssl_init: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MQTTAsync_init_options() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_init_options> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_init_options>(),
12usize,
concat!("Size of: ", stringify!(MQTTAsync_init_options))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_init_options>(),
4usize,
concat!("Alignment of ", stringify!(MQTTAsync_init_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_init_options),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_init_options),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).do_openssl_init) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_init_options),
"::",
stringify!(do_openssl_init)
)
);
}
extern "C" {
pub fn MQTTAsync_global_init(inits: *mut MQTTAsync_init_options);
}
pub type MQTTAsync = *mut ::std::os::raw::c_void;
pub type MQTTAsync_token = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_message {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub payloadlen: ::std::os::raw::c_int,
pub payload: *mut ::std::os::raw::c_void,
pub qos: ::std::os::raw::c_int,
pub retained: ::std::os::raw::c_int,
pub dup: ::std::os::raw::c_int,
pub msgid: ::std::os::raw::c_int,
pub properties: MQTTProperties,
}
#[test]
fn bindgen_test_layout_MQTTAsync_message() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_message> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_message>(),
64usize,
concat!("Size of: ", stringify!(MQTTAsync_message))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_message>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_message))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).payloadlen) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(payloadlen)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(payload)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retained) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(retained)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dup) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(dup)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).msgid) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(msgid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_message),
"::",
stringify!(properties)
)
);
}
pub type MQTTAsync_messageArrived = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
topicName: *mut ::std::os::raw::c_char,
topicLen: ::std::os::raw::c_int,
message: *mut MQTTAsync_message,
) -> ::std::os::raw::c_int,
>;
pub type MQTTAsync_deliveryComplete = ::std::option::Option<
unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, token: MQTTAsync_token),
>;
pub type MQTTAsync_connectionLost = ::std::option::Option<
unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, cause: *mut ::std::os::raw::c_char),
>;
pub type MQTTAsync_connected = ::std::option::Option<
unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, cause: *mut ::std::os::raw::c_char),
>;
pub type MQTTAsync_disconnected = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
properties: *mut MQTTProperties,
reasonCode: MQTTReasonCodes,
),
>;
extern "C" {
pub fn MQTTAsync_setDisconnected(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
co: MQTTAsync_disconnected,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_connectData {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub username: *const ::std::os::raw::c_char,
pub binarypwd: MQTTAsync_connectData__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_connectData__bindgen_ty_1 {
pub len: ::std::os::raw::c_int,
pub data: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MQTTAsync_connectData__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_connectData__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_connectData__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(MQTTAsync_connectData__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_connectData__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_connectData__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData__bindgen_ty_1),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData__bindgen_ty_1),
"::",
stringify!(data)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_connectData() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_connectData> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_connectData>(),
32usize,
concat!("Size of: ", stringify!(MQTTAsync_connectData))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_connectData>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_connectData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).username) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData),
"::",
stringify!(username)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).binarypwd) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectData),
"::",
stringify!(binarypwd)
)
);
}
pub type MQTTAsync_updateConnectOptions = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
data: *mut MQTTAsync_connectData,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn MQTTAsync_setUpdateConnectOptions(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
co: MQTTAsync_updateConnectOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setBeforePersistenceWrite(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
co: MQTTPersistence_beforeWrite,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setAfterPersistenceRead(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
co: MQTTPersistence_afterRead,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_failureData {
pub token: MQTTAsync_token,
pub code: ::std::os::raw::c_int,
pub message: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MQTTAsync_failureData() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_failureData> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_failureData>(),
16usize,
concat!("Size of: ", stringify!(MQTTAsync_failureData))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_failureData>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_failureData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData),
"::",
stringify!(message)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_failureData5 {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub token: MQTTAsync_token,
pub reasonCode: MQTTReasonCodes,
pub properties: MQTTProperties,
pub code: ::std::os::raw::c_int,
pub message: *const ::std::os::raw::c_char,
pub packet_type: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MQTTAsync_failureData5() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_failureData5> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_failureData5>(),
64usize,
concat!("Size of: ", stringify!(MQTTAsync_failureData5))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_failureData5>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_failureData5))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCode) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(reasonCode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).packet_type) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_failureData5),
"::",
stringify!(packet_type)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MQTTAsync_successData {
pub token: MQTTAsync_token,
pub alt: MQTTAsync_successData__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MQTTAsync_successData__bindgen_ty_1 {
pub qos: ::std::os::raw::c_int,
pub qosList: *mut ::std::os::raw::c_int,
pub pub_: MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1,
pub connect: MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1 {
pub message: MQTTAsync_message,
pub destinationName: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1>(),
72usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destinationName) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(destinationName)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2 {
pub serverURI: *mut ::std::os::raw::c_char,
pub MQTTVersion: ::std::os::raw::c_int,
pub sessionPresent: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2>(),
16usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serverURI) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(serverURI)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).MQTTVersion) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(MQTTVersion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sessionPresent) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(sessionPresent)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData__bindgen_ty_1>(),
72usize,
concat!("Size of: ", stringify!(MQTTAsync_successData__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qosList) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1),
"::",
stringify!(qosList)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pub_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1),
"::",
stringify!(pub_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).connect) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData__bindgen_ty_1),
"::",
stringify!(connect)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData>(),
80usize,
concat!("Size of: ", stringify!(MQTTAsync_successData))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_successData))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData),
"::",
stringify!(alt)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MQTTAsync_successData5 {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub token: MQTTAsync_token,
pub reasonCode: MQTTReasonCodes,
pub properties: MQTTProperties,
pub alt: MQTTAsync_successData5__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MQTTAsync_successData5__bindgen_ty_1 {
pub sub: MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1,
pub pub_: MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2,
pub connect: MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3,
pub unsub: MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1 {
pub reasonCodeCount: ::std::os::raw::c_int,
pub reasonCodes: *mut MQTTReasonCodes,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCodeCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(reasonCodeCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCodes) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(reasonCodes)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2 {
pub message: MQTTAsync_message,
pub destinationName: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2>(),
72usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destinationName) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(destinationName)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3 {
pub serverURI: *mut ::std::os::raw::c_char,
pub MQTTVersion: ::std::os::raw::c_int,
pub sessionPresent: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3>(),
16usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serverURI) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(serverURI)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).MQTTVersion) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(MQTTVersion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sessionPresent) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(sessionPresent)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4 {
pub reasonCodeCount: ::std::os::raw::c_int,
pub reasonCodes: *mut MQTTReasonCodes,
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4>(),
16usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCodeCount) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(reasonCodeCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCodes) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(reasonCodes)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5__bindgen_ty_1>(),
72usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_successData5__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sub) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1),
"::",
stringify!(sub)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pub_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1),
"::",
stringify!(pub_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).connect) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1),
"::",
stringify!(connect)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unsub) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5__bindgen_ty_1),
"::",
stringify!(unsub)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_successData5() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_successData5> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_successData5>(),
112usize,
concat!("Size of: ", stringify!(MQTTAsync_successData5))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_successData5>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_successData5))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCode) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(reasonCode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_successData5),
"::",
stringify!(alt)
)
);
}
pub type MQTTAsync_onSuccess = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
response: *mut MQTTAsync_successData,
),
>;
pub type MQTTAsync_onSuccess5 = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
response: *mut MQTTAsync_successData5,
),
>;
pub type MQTTAsync_onFailure = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
response: *mut MQTTAsync_failureData,
),
>;
pub type MQTTAsync_onFailure5 = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
response: *mut MQTTAsync_failureData5,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_responseOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub onSuccess: MQTTAsync_onSuccess,
pub onFailure: MQTTAsync_onFailure,
pub context: *mut ::std::os::raw::c_void,
pub token: MQTTAsync_token,
pub onSuccess5: MQTTAsync_onSuccess5,
pub onFailure5: MQTTAsync_onFailure5,
pub properties: MQTTProperties,
pub subscribeOptions: MQTTSubscribe_options,
pub subscribeOptionsCount: ::std::os::raw::c_int,
pub subscribeOptionsList: *mut MQTTSubscribe_options,
}
#[test]
fn bindgen_test_layout_MQTTAsync_responseOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_responseOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_responseOptions>(),
104usize,
concat!("Size of: ", stringify!(MQTTAsync_responseOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_responseOptions>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_responseOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(onSuccess)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(onFailure)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess5) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(onSuccess5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure5) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(onFailure5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscribeOptions) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(subscribeOptions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscribeOptionsCount) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(subscribeOptionsCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscribeOptionsList) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_responseOptions),
"::",
stringify!(subscribeOptionsList)
)
);
}
pub type MQTTAsync_callOptions = MQTTAsync_responseOptions;
extern "C" {
pub fn MQTTAsync_setCallbacks(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
cl: MQTTAsync_connectionLost,
ma: MQTTAsync_messageArrived,
dc: MQTTAsync_deliveryComplete,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setConnectionLostCallback(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
cl: MQTTAsync_connectionLost,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setMessageArrivedCallback(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
ma: MQTTAsync_messageArrived,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setDeliveryCompleteCallback(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
dc: MQTTAsync_deliveryComplete,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_setConnected(
handle: MQTTAsync,
context: *mut ::std::os::raw::c_void,
co: MQTTAsync_connected,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_reconnect(handle: MQTTAsync) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_create(
handle: *mut MQTTAsync,
serverURI: *const ::std::os::raw::c_char,
clientId: *const ::std::os::raw::c_char,
persistence_type: ::std::os::raw::c_int,
persistence_context: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_createOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub sendWhileDisconnected: ::std::os::raw::c_int,
pub maxBufferedMessages: ::std::os::raw::c_int,
pub MQTTVersion: ::std::os::raw::c_int,
pub allowDisconnectedSendAtAnyTime: ::std::os::raw::c_int,
pub deleteOldestMessages: ::std::os::raw::c_int,
pub restoreMessages: ::std::os::raw::c_int,
pub persistQoS0: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MQTTAsync_createOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_createOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_createOptions>(),
36usize,
concat!("Size of: ", stringify!(MQTTAsync_createOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_createOptions>(),
4usize,
concat!("Alignment of ", stringify!(MQTTAsync_createOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sendWhileDisconnected) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(sendWhileDisconnected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxBufferedMessages) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(maxBufferedMessages)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).MQTTVersion) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(MQTTVersion)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).allowDisconnectedSendAtAnyTime) as usize - ptr as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(allowDisconnectedSendAtAnyTime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).deleteOldestMessages) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(deleteOldestMessages)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).restoreMessages) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(restoreMessages)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).persistQoS0) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_createOptions),
"::",
stringify!(persistQoS0)
)
);
}
extern "C" {
pub fn MQTTAsync_createWithOptions(
handle: *mut MQTTAsync,
serverURI: *const ::std::os::raw::c_char,
clientId: *const ::std::os::raw::c_char,
persistence_type: ::std::os::raw::c_int,
persistence_context: *mut ::std::os::raw::c_void,
options: *mut MQTTAsync_createOptions,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_willOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub topicName: *const ::std::os::raw::c_char,
pub message: *const ::std::os::raw::c_char,
pub retained: ::std::os::raw::c_int,
pub qos: ::std::os::raw::c_int,
pub payload: MQTTAsync_willOptions__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_willOptions__bindgen_ty_1 {
pub len: ::std::os::raw::c_int,
pub data: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MQTTAsync_willOptions__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_willOptions__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_willOptions__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(MQTTAsync_willOptions__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_willOptions__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_willOptions__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions__bindgen_ty_1),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions__bindgen_ty_1),
"::",
stringify!(data)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_willOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_willOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_willOptions>(),
48usize,
concat!("Size of: ", stringify!(MQTTAsync_willOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_willOptions>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_willOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).topicName) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(topicName)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retained) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(retained)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_willOptions),
"::",
stringify!(payload)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_SSLOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub trustStore: *const ::std::os::raw::c_char,
pub keyStore: *const ::std::os::raw::c_char,
pub privateKey: *const ::std::os::raw::c_char,
pub privateKeyPassword: *const ::std::os::raw::c_char,
pub enabledCipherSuites: *const ::std::os::raw::c_char,
pub enableServerCertAuth: ::std::os::raw::c_int,
pub sslVersion: ::std::os::raw::c_int,
pub verify: ::std::os::raw::c_int,
pub CApath: *const ::std::os::raw::c_char,
pub ssl_error_cb: ::std::option::Option<
unsafe extern "C" fn(
str_: *const ::std::os::raw::c_char,
len: usize,
u: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub ssl_error_context: *mut ::std::os::raw::c_void,
pub ssl_psk_cb: ::std::option::Option<
unsafe extern "C" fn(
hint: *const ::std::os::raw::c_char,
identity: *mut ::std::os::raw::c_char,
max_identity_len: ::std::os::raw::c_uint,
psk: *mut ::std::os::raw::c_uchar,
max_psk_len: ::std::os::raw::c_uint,
u: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_uint,
>,
pub ssl_psk_context: *mut ::std::os::raw::c_void,
pub disableDefaultTrustStore: ::std::os::raw::c_int,
pub protos: *const ::std::os::raw::c_uchar,
pub protos_len: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_MQTTAsync_SSLOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_SSLOptions> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_SSLOptions>(),
128usize,
concat!("Size of: ", stringify!(MQTTAsync_SSLOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_SSLOptions>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_SSLOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trustStore) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(trustStore)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keyStore) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(keyStore)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).privateKey) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(privateKey)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).privateKeyPassword) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(privateKeyPassword)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enabledCipherSuites) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(enabledCipherSuites)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enableServerCertAuth) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(enableServerCertAuth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sslVersion) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(sslVersion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).verify) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(verify)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).CApath) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(CApath)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ssl_error_cb) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(ssl_error_cb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ssl_error_context) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(ssl_error_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ssl_psk_cb) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(ssl_psk_cb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ssl_psk_context) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(ssl_psk_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).disableDefaultTrustStore) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(disableDefaultTrustStore)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).protos) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(protos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).protos_len) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_SSLOptions),
"::",
stringify!(protos_len)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_nameValue {
pub name: *const ::std::os::raw::c_char,
pub value: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MQTTAsync_nameValue() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_nameValue> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_nameValue>(),
16usize,
concat!("Size of: ", stringify!(MQTTAsync_nameValue))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_nameValue>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_nameValue))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_nameValue),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_nameValue),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_connectOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub keepAliveInterval: ::std::os::raw::c_int,
pub cleansession: ::std::os::raw::c_int,
pub maxInflight: ::std::os::raw::c_int,
pub will: *mut MQTTAsync_willOptions,
pub username: *const ::std::os::raw::c_char,
pub password: *const ::std::os::raw::c_char,
pub connectTimeout: ::std::os::raw::c_int,
pub retryInterval: ::std::os::raw::c_int,
pub ssl: *mut MQTTAsync_SSLOptions,
pub onSuccess: MQTTAsync_onSuccess,
pub onFailure: MQTTAsync_onFailure,
pub context: *mut ::std::os::raw::c_void,
pub serverURIcount: ::std::os::raw::c_int,
pub serverURIs: *const *mut ::std::os::raw::c_char,
pub MQTTVersion: ::std::os::raw::c_int,
pub automaticReconnect: ::std::os::raw::c_int,
pub minRetryInterval: ::std::os::raw::c_int,
pub maxRetryInterval: ::std::os::raw::c_int,
pub binarypwd: MQTTAsync_connectOptions__bindgen_ty_1,
pub cleanstart: ::std::os::raw::c_int,
pub connectProperties: *mut MQTTProperties,
pub willProperties: *mut MQTTProperties,
pub onSuccess5: MQTTAsync_onSuccess5,
pub onFailure5: MQTTAsync_onFailure5,
pub httpHeaders: *const MQTTAsync_nameValue,
pub httpProxy: *const ::std::os::raw::c_char,
pub httpsProxy: *const ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_connectOptions__bindgen_ty_1 {
pub len: ::std::os::raw::c_int,
pub data: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MQTTAsync_connectOptions__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_connectOptions__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_connectOptions__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(MQTTAsync_connectOptions__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_connectOptions__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(MQTTAsync_connectOptions__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions__bindgen_ty_1),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions__bindgen_ty_1),
"::",
stringify!(data)
)
);
}
#[test]
fn bindgen_test_layout_MQTTAsync_connectOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_connectOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_connectOptions>(),
200usize,
concat!("Size of: ", stringify!(MQTTAsync_connectOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_connectOptions>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_connectOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keepAliveInterval) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(keepAliveInterval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cleansession) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(cleansession)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxInflight) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(maxInflight)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).will) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(will)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).username) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(username)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).password) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(password)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).connectTimeout) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(connectTimeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retryInterval) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(retryInterval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ssl) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(ssl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(onSuccess)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(onFailure)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serverURIcount) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(serverURIcount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serverURIs) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(serverURIs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).MQTTVersion) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(MQTTVersion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).automaticReconnect) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(automaticReconnect)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minRetryInterval) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(minRetryInterval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxRetryInterval) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(maxRetryInterval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).binarypwd) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(binarypwd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cleanstart) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(cleanstart)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).connectProperties) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(connectProperties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).willProperties) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(willProperties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess5) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(onSuccess5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure5) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(onFailure5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).httpHeaders) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(httpHeaders)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).httpProxy) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(httpProxy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).httpsProxy) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_connectOptions),
"::",
stringify!(httpsProxy)
)
);
}
extern "C" {
pub fn MQTTAsync_connect(
handle: MQTTAsync,
options: *const MQTTAsync_connectOptions,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MQTTAsync_disconnectOptions {
pub struct_id: [::std::os::raw::c_char; 4usize],
pub struct_version: ::std::os::raw::c_int,
pub timeout: ::std::os::raw::c_int,
pub onSuccess: MQTTAsync_onSuccess,
pub onFailure: MQTTAsync_onFailure,
pub context: *mut ::std::os::raw::c_void,
pub properties: MQTTProperties,
pub reasonCode: MQTTReasonCodes,
pub onSuccess5: MQTTAsync_onSuccess5,
pub onFailure5: MQTTAsync_onFailure5,
}
#[test]
fn bindgen_test_layout_MQTTAsync_disconnectOptions() {
const UNINIT: ::std::mem::MaybeUninit<MQTTAsync_disconnectOptions> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<MQTTAsync_disconnectOptions>(),
88usize,
concat!("Size of: ", stringify!(MQTTAsync_disconnectOptions))
);
assert_eq!(
::std::mem::align_of::<MQTTAsync_disconnectOptions>(),
8usize,
concat!("Alignment of ", stringify!(MQTTAsync_disconnectOptions))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(struct_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(struct_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(timeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(onSuccess)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(onFailure)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reasonCode) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(reasonCode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onSuccess5) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(onSuccess5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onFailure5) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(MQTTAsync_disconnectOptions),
"::",
stringify!(onFailure5)
)
);
}
extern "C" {
pub fn MQTTAsync_disconnect(
handle: MQTTAsync,
options: *const MQTTAsync_disconnectOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_isConnected(handle: MQTTAsync) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_subscribe(
handle: MQTTAsync,
topic: *const ::std::os::raw::c_char,
qos: ::std::os::raw::c_int,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_subscribeMany(
handle: MQTTAsync,
count: ::std::os::raw::c_int,
topic: *const *mut ::std::os::raw::c_char,
qos: *const ::std::os::raw::c_int,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_unsubscribe(
handle: MQTTAsync,
topic: *const ::std::os::raw::c_char,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_unsubscribeMany(
handle: MQTTAsync,
count: ::std::os::raw::c_int,
topic: *const *mut ::std::os::raw::c_char,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_send(
handle: MQTTAsync,
destinationName: *const ::std::os::raw::c_char,
payloadlen: ::std::os::raw::c_int,
payload: *const ::std::os::raw::c_void,
qos: ::std::os::raw::c_int,
retained: ::std::os::raw::c_int,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_sendMessage(
handle: MQTTAsync,
destinationName: *const ::std::os::raw::c_char,
msg: *const MQTTAsync_message,
response: *mut MQTTAsync_responseOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_getPendingTokens(
handle: MQTTAsync,
tokens: *mut *mut MQTTAsync_token,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_isComplete(handle: MQTTAsync, token: MQTTAsync_token)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_waitForCompletion(
handle: MQTTAsync,
token: MQTTAsync_token,
timeout: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn MQTTAsync_freeMessage(msg: *mut *mut MQTTAsync_message);
}
extern "C" {
pub fn MQTTAsync_free(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn MQTTAsync_malloc(size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn MQTTAsync_destroy(handle: *mut MQTTAsync);
}
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_MAXIMUM: MQTTASYNC_TRACE_LEVELS = 1;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_MEDIUM: MQTTASYNC_TRACE_LEVELS = 2;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_MINIMUM: MQTTASYNC_TRACE_LEVELS = 3;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_PROTOCOL: MQTTASYNC_TRACE_LEVELS = 4;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_ERROR: MQTTASYNC_TRACE_LEVELS = 5;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_SEVERE: MQTTASYNC_TRACE_LEVELS = 6;
pub const MQTTASYNC_TRACE_LEVELS_MQTTASYNC_TRACE_FATAL: MQTTASYNC_TRACE_LEVELS = 7;
pub type MQTTASYNC_TRACE_LEVELS = ::std::os::raw::c_uint;
extern "C" {
pub fn MQTTAsync_setTraceLevel(level: MQTTASYNC_TRACE_LEVELS);
}
pub type MQTTAsync_traceCallback = ::std::option::Option<
unsafe extern "C" fn(level: MQTTASYNC_TRACE_LEVELS, message: *mut ::std::os::raw::c_char),
>;
extern "C" {
pub fn MQTTAsync_setTraceCallback(callback: MQTTAsync_traceCallback);
}
extern "C" {
pub fn MQTTAsync_getVersionInfo() -> *mut MQTTAsync_nameValue;
}
extern "C" {
pub fn MQTTAsync_strerror(code: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}