mirror
/
r2r
mirror of https://github.com/sequenceplanner/r2r.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
r2r/r2r_rcl/bindings/rcl_bindings.rs

9093 lines
273 KiB
Rust
Raw Blame History

/* automatically generated by rust-bindgen 0.63.0 */
pub const RCUTILS_RET_OK: u32 = 0;
pub const RCUTILS_RET_WARN: u32 = 1;
pub const RCUTILS_RET_ERROR: u32 = 2;
pub const RCUTILS_RET_BAD_ALLOC: u32 = 10;
pub const RCUTILS_RET_INVALID_ARGUMENT: u32 = 11;
pub const RCUTILS_RET_NOT_ENOUGH_SPACE: u32 = 12;
pub const RCUTILS_RET_NOT_INITIALIZED: u32 = 13;
pub const RCUTILS_RET_NOT_FOUND: u32 = 14;
pub const RCUTILS_RET_STRING_MAP_ALREADY_INIT: u32 = 30;
pub const RCUTILS_RET_STRING_MAP_INVALID: u32 = 31;
pub const RCUTILS_RET_STRING_KEY_NOT_FOUND: u32 = 32;
pub const RCUTILS_RET_LOGGING_SEVERITY_MAP_INVALID: u32 = 40;
pub const RCUTILS_RET_LOGGING_SEVERITY_STRING_INVALID: u32 = 41;
pub const RCUTILS_RET_HASH_MAP_NO_MORE_ENTRIES: u32 = 50;
pub const RMW_DEFAULT_DOMAIN_ID: i32 = -1;
pub const RMW_RET_OK: u32 = 0;
pub const RMW_RET_ERROR: u32 = 1;
pub const RMW_RET_TIMEOUT: u32 = 2;
pub const RMW_RET_UNSUPPORTED: u32 = 3;
pub const RMW_RET_BAD_ALLOC: u32 = 10;
pub const RMW_RET_INVALID_ARGUMENT: u32 = 11;
pub const RMW_RET_INCORRECT_RMW_IMPLEMENTATION: u32 = 12;
pub const RMW_RET_NODE_NAME_NON_EXISTENT: u32 = 203;
pub const RCUTILS_FAULT_INJECTION_NEVER_FAIL: i32 = -1;
pub const RCUTILS_FAULT_INJECTION_FAIL_NOW: u32 = 0;
pub const RCUTILS_ERROR_STATE_LINE_NUMBER_STR_MAX_LENGTH: u32 = 20;
pub const RCUTILS_ERROR_FORMATTING_CHARACTERS: u32 = 6;
pub const RCUTILS_ERROR_MESSAGE_MAX_LENGTH: u32 = 1024;
pub const RCUTILS_ERROR_STATE_MESSAGE_MAX_LENGTH: u32 = 768;
pub const RCUTILS_ERROR_STATE_FILE_MAX_LENGTH: u32 = 229;
pub const RCUTILS_LOGGING_SEPARATOR_STRING: &[u8; 2usize] = b".\0";
pub const RMW_GID_STORAGE_SIZE: u32 = 24;
pub const RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE_DEPRECATED_MSG : & [u8 ; 145usize] = b"RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE is deprecated. Use RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC if manually asserted liveliness is needed.\0" ;
pub const RCL_RET_OK: u32 = 0;
pub const RCL_RET_ERROR: u32 = 1;
pub const RCL_RET_TIMEOUT: u32 = 2;
pub const RCL_RET_BAD_ALLOC: u32 = 10;
pub const RCL_RET_INVALID_ARGUMENT: u32 = 11;
pub const RCL_RET_UNSUPPORTED: u32 = 3;
pub const RCL_RET_ALREADY_INIT: u32 = 100;
pub const RCL_RET_NOT_INIT: u32 = 101;
pub const RCL_RET_MISMATCHED_RMW_ID: u32 = 102;
pub const RCL_RET_TOPIC_NAME_INVALID: u32 = 103;
pub const RCL_RET_SERVICE_NAME_INVALID: u32 = 104;
pub const RCL_RET_UNKNOWN_SUBSTITUTION: u32 = 105;
pub const RCL_RET_ALREADY_SHUTDOWN: u32 = 106;
pub const RCL_RET_NODE_INVALID: u32 = 200;
pub const RCL_RET_NODE_INVALID_NAME: u32 = 201;
pub const RCL_RET_NODE_INVALID_NAMESPACE: u32 = 202;
pub const RCL_RET_NODE_NAME_NON_EXISTENT: u32 = 203;
pub const RCL_RET_PUBLISHER_INVALID: u32 = 300;
pub const RCL_RET_SUBSCRIPTION_INVALID: u32 = 400;
pub const RCL_RET_SUBSCRIPTION_TAKE_FAILED: u32 = 401;
pub const RCL_RET_CLIENT_INVALID: u32 = 500;
pub const RCL_RET_CLIENT_TAKE_FAILED: u32 = 501;
pub const RCL_RET_SERVICE_INVALID: u32 = 600;
pub const RCL_RET_SERVICE_TAKE_FAILED: u32 = 601;
pub const RCL_RET_TIMER_INVALID: u32 = 800;
pub const RCL_RET_TIMER_CANCELED: u32 = 801;
pub const RCL_RET_WAIT_SET_INVALID: u32 = 900;
pub const RCL_RET_WAIT_SET_EMPTY: u32 = 901;
pub const RCL_RET_WAIT_SET_FULL: u32 = 902;
pub const RCL_RET_INVALID_REMAP_RULE: u32 = 1001;
pub const RCL_RET_WRONG_LEXEME: u32 = 1002;
pub const RCL_RET_INVALID_ROS_ARGS: u32 = 1003;
pub const RCL_RET_INVALID_PARAM_RULE: u32 = 1010;
pub const RCL_RET_INVALID_LOG_LEVEL_RULE: u32 = 1020;
pub const RCL_RET_EVENT_INVALID: u32 = 2000;
pub const RCL_RET_EVENT_TAKE_FAILED: u32 = 2001;
pub const RCL_RET_LIFECYCLE_STATE_REGISTERED: u32 = 3000;
pub const RCL_RET_LIFECYCLE_STATE_NOT_REGISTERED: u32 = 3001;
pub const RCL_ROS_ARGS_FLAG: &[u8; 11usize] = b"--ros-args\0";
pub const RCL_ROS_ARGS_EXPLICIT_END_TOKEN: &[u8; 3usize] = b"--\0";
pub const RCL_PARAM_FLAG: &[u8; 8usize] = b"--param\0";
pub const RCL_SHORT_PARAM_FLAG: &[u8; 3usize] = b"-p\0";
pub const RCL_PARAM_FILE_FLAG: &[u8; 14usize] = b"--params-file\0";
pub const RCL_REMAP_FLAG: &[u8; 8usize] = b"--remap\0";
pub const RCL_SHORT_REMAP_FLAG: &[u8; 3usize] = b"-r\0";
pub const RCL_ENCLAVE_FLAG: &[u8; 10usize] = b"--enclave\0";
pub const RCL_SHORT_ENCLAVE_FLAG: &[u8; 3usize] = b"-e\0";
pub const RCL_LOG_LEVEL_FLAG: &[u8; 12usize] = b"--log-level\0";
pub const RCL_EXTERNAL_LOG_CONFIG_FLAG: &[u8; 18usize] = b"--log-config-file\0";
pub const RCL_LOG_STDOUT_FLAG_SUFFIX: &[u8; 12usize] = b"stdout-logs\0";
pub const RCL_LOG_ROSOUT_FLAG_SUFFIX: &[u8; 12usize] = b"rosout-logs\0";
pub const RCL_LOG_EXT_LIB_FLAG_SUFFIX: &[u8; 18usize] = b"external-lib-logs\0";
pub const RCL_DEFAULT_DOMAIN_ID: i32 = -1;
pub const RCL_NODE_OPTIONS_DEFAULT_DOMAIN_ID: i32 = -1;
pub type rcutils_ret_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_allocator_t {
pub allocate: ::std::option::Option<
unsafe extern "C" fn(
size: usize,
state: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>,
pub deallocate: ::std::option::Option<
unsafe extern "C" fn(
pointer: *mut ::std::os::raw::c_void,
state: *mut ::std::os::raw::c_void,
),
>,
pub reallocate: ::std::option::Option<
unsafe extern "C" fn(
pointer: *mut ::std::os::raw::c_void,
size: usize,
state: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>,
pub zero_allocate: ::std::option::Option<
unsafe extern "C" fn(
number_of_elements: usize,
size_of_element: usize,
state: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>,
pub state: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rcutils_allocator_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_allocator_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_allocator_t>(),
40usize,
concat!("Size of: ", stringify!(rcutils_allocator_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_allocator_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_allocator_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocate) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_allocator_t),
"::",
stringify!(allocate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).deallocate) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcutils_allocator_t),
"::",
stringify!(deallocate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reallocate) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcutils_allocator_t),
"::",
stringify!(reallocate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).zero_allocate) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcutils_allocator_t),
"::",
stringify!(zero_allocate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcutils_allocator_t),
"::",
stringify!(state)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_allocator() -> rcutils_allocator_t;
}
extern "C" {
pub fn rcutils_get_default_allocator() -> rcutils_allocator_t;
}
extern "C" {
pub fn rcutils_allocator_is_valid(allocator: *const rcutils_allocator_t) -> bool;
}
extern "C" {
pub fn rcutils_reallocf(
pointer: *mut ::std::os::raw::c_void,
size: usize,
allocator: *mut rcutils_allocator_t,
) -> *mut ::std::os::raw::c_void;
}
pub type rcl_allocator_t = rcutils_allocator_t;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint_least16_t = __uint16_t;
pub type __int_least64_t = __int64_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least16_t = __uint_least16_t;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_localhost_only_t {
RMW_LOCALHOST_ONLY_DEFAULT = 0,
RMW_LOCALHOST_ONLY_ENABLED = 1,
RMW_LOCALHOST_ONLY_DISABLED = 2,
}
pub type rmw_ret_t = i32;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_security_enforcement_policy_t {
RMW_SECURITY_ENFORCEMENT_PERMISSIVE = 0,
RMW_SECURITY_ENFORCEMENT_ENFORCE = 1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_security_options_t {
pub enforce_security: rmw_security_enforcement_policy_t,
pub security_root_path: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_rmw_security_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_security_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_security_options_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_security_options_t))
);
assert_eq!(
::std::mem::align_of::<rmw_security_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_security_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enforce_security) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_security_options_t),
"::",
stringify!(enforce_security)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).security_root_path) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_security_options_t),
"::",
stringify!(security_root_path)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_security_options() -> rmw_security_options_t;
}
extern "C" {
pub fn rmw_get_default_security_options() -> rmw_security_options_t;
}
extern "C" {
pub fn rmw_security_options_copy(
src: *const rmw_security_options_t,
allocator: *const rcutils_allocator_t,
dst: *mut rmw_security_options_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_security_options_set_root_path(
security_root_path: *const ::std::os::raw::c_char,
allocator: *const rcutils_allocator_t,
security_options: *mut rmw_security_options_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_security_options_fini(
security_options: *mut rmw_security_options_t,
allocator: *const rcutils_allocator_t,
) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rmw_init_options_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_init_options_t {
pub instance_id: u64,
pub implementation_identifier: *const ::std::os::raw::c_char,
pub domain_id: usize,
pub security_options: rmw_security_options_t,
pub localhost_only: rmw_localhost_only_t,
pub enclave: *mut ::std::os::raw::c_char,
pub allocator: rcutils_allocator_t,
pub impl_: *mut rmw_init_options_impl_t,
}
#[test]
fn bindgen_test_layout_rmw_init_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_init_options_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_init_options_t>(),
104usize,
concat!("Size of: ", stringify!(rmw_init_options_t))
);
assert_eq!(
::std::mem::align_of::<rmw_init_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_init_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instance_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(instance_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).domain_id) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(domain_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).security_options) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(security_options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).localhost_only) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(localhost_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enclave) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(enclave)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(allocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(rmw_init_options_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_init_options() -> rmw_init_options_t;
}
extern "C" {
pub fn rmw_init_options_init(
init_options: *mut rmw_init_options_t,
allocator: rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_init_options_copy(
src: *const rmw_init_options_t,
dst: *mut rmw_init_options_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_init_options_fini(init_options: *mut rmw_init_options_t) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rmw_context_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_context_t {
pub instance_id: u64,
pub implementation_identifier: *const ::std::os::raw::c_char,
pub options: rmw_init_options_t,
pub actual_domain_id: usize,
pub impl_: *mut rmw_context_impl_t,
}
#[test]
fn bindgen_test_layout_rmw_context_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_context_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_context_t>(),
136usize,
concat!("Size of: ", stringify!(rmw_context_t))
);
assert_eq!(
::std::mem::align_of::<rmw_context_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_context_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instance_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_context_t),
"::",
stringify!(instance_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_context_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_context_t),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).actual_domain_id) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(rmw_context_t),
"::",
stringify!(actual_domain_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(rmw_context_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_context() -> rmw_context_t;
}
extern "C" {
pub fn rmw_init(options: *const rmw_init_options_t, context: *mut rmw_context_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_shutdown(context: *mut rmw_context_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_context_fini(context: *mut rmw_context_t) -> rmw_ret_t;
}
pub type va_list = __builtin_va_list;
extern "C" {
pub fn rcutils_snprintf(
buffer: *mut ::std::os::raw::c_char,
buffer_size: usize,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_vsnprintf(
buffer: *mut ::std::os::raw::c_char,
buffer_size: usize,
format: *const ::std::os::raw::c_char,
args: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_fault_injection_is_test_complete() -> bool;
}
extern "C" {
pub fn rcutils_fault_injection_set_count(count: int_least64_t);
}
extern "C" {
pub fn rcutils_fault_injection_get_count() -> int_least64_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_error_string_t {
pub str_: [::std::os::raw::c_char; 1024usize],
}
#[test]
fn bindgen_test_layout_rcutils_error_string_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_error_string_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_error_string_t>(),
1024usize,
concat!("Size of: ", stringify!(rcutils_error_string_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_error_string_t>(),
1usize,
concat!("Alignment of ", stringify!(rcutils_error_string_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_error_string_t),
"::",
stringify!(str_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_error_state_t {
pub message: [::std::os::raw::c_char; 768usize],
pub file: [::std::os::raw::c_char; 229usize],
pub line_number: u64,
}
#[test]
fn bindgen_test_layout_rcutils_error_state_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_error_state_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_error_state_t>(),
1008usize,
concat!("Size of: ", stringify!(rcutils_error_state_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_error_state_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_error_state_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_error_state_t),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(rcutils_error_state_t),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line_number) as usize - ptr as usize },
1000usize,
concat!(
"Offset of field: ",
stringify!(rcutils_error_state_t),
"::",
stringify!(line_number)
)
);
}
extern "C" {
pub fn rcutils_initialize_error_handling_thread_local_storage(
allocator: rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_set_error_state(
error_string: *const ::std::os::raw::c_char,
file: *const ::std::os::raw::c_char,
line_number: usize,
);
}
extern "C" {
pub fn rcutils_error_is_set() -> bool;
}
extern "C" {
pub fn rcutils_get_error_state() -> *const rcutils_error_state_t;
}
extern "C" {
pub fn rcutils_get_error_string() -> rcutils_error_string_t;
}
extern "C" {
pub fn rcutils_reset_error();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcutils_array_list_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_array_list_t {
pub impl_: *mut rcutils_array_list_impl_t,
}
#[test]
fn bindgen_test_layout_rcutils_array_list_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_array_list_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_array_list_t>(),
8usize,
concat!("Size of: ", stringify!(rcutils_array_list_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_array_list_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_array_list_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_array_list_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_array_list() -> rcutils_array_list_t;
}
extern "C" {
pub fn rcutils_array_list_init(
array_list: *mut rcutils_array_list_t,
initial_capacity: usize,
data_size: usize,
allocator: *const rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_fini(array_list: *mut rcutils_array_list_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_add(
array_list: *mut rcutils_array_list_t,
data: *const ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_set(
array_list: *mut rcutils_array_list_t,
index: usize,
data: *const ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_remove(
array_list: *mut rcutils_array_list_t,
index: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_get(
array_list: *const rcutils_array_list_t,
index: usize,
data: *mut ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_array_list_get_size(
array_list: *const rcutils_array_list_t,
size: *mut usize,
) -> rcutils_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_char_array_t {
pub buffer: *mut ::std::os::raw::c_char,
pub owns_buffer: bool,
pub buffer_length: usize,
pub buffer_capacity: usize,
pub allocator: rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rcutils_char_array_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_char_array_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_char_array_t>(),
72usize,
concat!("Size of: ", stringify!(rcutils_char_array_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_char_array_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_char_array_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_char_array_t),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).owns_buffer) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcutils_char_array_t),
"::",
stringify!(owns_buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_length) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcutils_char_array_t),
"::",
stringify!(buffer_length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_capacity) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcutils_char_array_t),
"::",
stringify!(buffer_capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcutils_char_array_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_char_array() -> rcutils_char_array_t;
}
extern "C" {
pub fn rcutils_char_array_init(
char_array: *mut rcutils_char_array_t,
buffer_capacity: usize,
allocator: *const rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_fini(char_array: *mut rcutils_char_array_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_resize(
char_array: *mut rcutils_char_array_t,
new_size: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_expand_as_needed(
char_array: *mut rcutils_char_array_t,
new_size: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_vsprintf(
char_array: *mut rcutils_char_array_t,
format: *const ::std::os::raw::c_char,
args: *mut __va_list_tag,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_strncat(
char_array: *mut rcutils_char_array_t,
src: *const ::std::os::raw::c_char,
n: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_strcat(
char_array: *mut rcutils_char_array_t,
src: *const ::std::os::raw::c_char,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_memcpy(
char_array: *mut rcutils_char_array_t,
src: *const ::std::os::raw::c_char,
n: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_char_array_strcpy(
char_array: *mut rcutils_char_array_t,
src: *const ::std::os::raw::c_char,
) -> rcutils_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcutils_hash_map_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_hash_map_t {
pub impl_: *mut rcutils_hash_map_impl_t,
}
#[test]
fn bindgen_test_layout_rcutils_hash_map_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_hash_map_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_hash_map_t>(),
8usize,
concat!("Size of: ", stringify!(rcutils_hash_map_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_hash_map_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_hash_map_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_hash_map_t),
"::",
stringify!(impl_)
)
);
}
pub type rcutils_hash_map_key_hasher_t =
::std::option::Option<unsafe extern "C" fn(arg1: *const ::std::os::raw::c_void) -> usize>;
pub type rcutils_hash_map_key_cmp_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn rcutils_hash_map_string_hash_func(key_str: *const ::std::os::raw::c_void) -> usize;
}
extern "C" {
pub fn rcutils_hash_map_string_cmp_func(
val1: *const ::std::os::raw::c_void,
val2: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_get_zero_initialized_hash_map() -> rcutils_hash_map_t;
}
extern "C" {
pub fn rcutils_hash_map_init(
hash_map: *mut rcutils_hash_map_t,
initial_capacity: usize,
key_size: usize,
data_size: usize,
key_hashing_func: rcutils_hash_map_key_hasher_t,
key_cmp_func: rcutils_hash_map_key_cmp_t,
allocator: *const rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_fini(hash_map: *mut rcutils_hash_map_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_get_capacity(
hash_map: *const rcutils_hash_map_t,
capacity: *mut usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_get_size(
hash_map: *const rcutils_hash_map_t,
size: *mut usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_set(
hash_map: *mut rcutils_hash_map_t,
key: *const ::std::os::raw::c_void,
value: *const ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_unset(
hash_map: *mut rcutils_hash_map_t,
key: *const ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_key_exists(
hash_map: *const rcutils_hash_map_t,
key: *const ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn rcutils_hash_map_get(
hash_map: *const rcutils_hash_map_t,
key: *const ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_hash_map_get_next_key_and_data(
hash_map: *const rcutils_hash_map_t,
previous_key: *const ::std::os::raw::c_void,
key: *mut ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_void,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_qsort(
ptr: *mut ::std::os::raw::c_void,
count: usize,
size: usize,
comp: ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
) -> rcutils_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_string_array_t {
pub size: usize,
pub data: *mut *mut ::std::os::raw::c_char,
pub allocator: rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rcutils_string_array_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_string_array_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_string_array_t>(),
56usize,
concat!("Size of: ", stringify!(rcutils_string_array_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_string_array_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_string_array_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_string_array_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcutils_string_array_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcutils_string_array_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_string_array() -> rcutils_string_array_t;
}
extern "C" {
pub fn rcutils_string_array_init(
string_array: *mut rcutils_string_array_t,
size: usize,
allocator: *const rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_array_fini(string_array: *mut rcutils_string_array_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_array_cmp(
lhs: *const rcutils_string_array_t,
rhs: *const rcutils_string_array_t,
res: *mut ::std::os::raw::c_int,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_array_resize(
string_array: *mut rcutils_string_array_t,
new_size: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_array_sort_compare(
lhs: *const ::std::os::raw::c_void,
rhs: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcutils_string_map_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_string_map_t {
pub impl_: *mut rcutils_string_map_impl_t,
}
#[test]
fn bindgen_test_layout_rcutils_string_map_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_string_map_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_string_map_t>(),
8usize,
concat!("Size of: ", stringify!(rcutils_string_map_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_string_map_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_string_map_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_string_map_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_string_map() -> rcutils_string_map_t;
}
extern "C" {
pub fn rcutils_string_map_init(
string_map: *mut rcutils_string_map_t,
initial_capacity: usize,
allocator: rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_fini(string_map: *mut rcutils_string_map_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_get_capacity(
string_map: *const rcutils_string_map_t,
capacity: *mut usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_get_size(
string_map: *const rcutils_string_map_t,
size: *mut usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_reserve(
string_map: *mut rcutils_string_map_t,
capacity: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_clear(string_map: *mut rcutils_string_map_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_set(
string_map: *mut rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_set_no_resize(
string_map: *mut rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_unset(
string_map: *mut rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_string_map_key_exists(
string_map: *const rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn rcutils_string_map_key_existsn(
string_map: *const rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
key_length: usize,
) -> bool;
}
extern "C" {
pub fn rcutils_string_map_get(
string_map: *const rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcutils_string_map_getn(
string_map: *const rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
key_length: usize,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcutils_string_map_get_next_key(
string_map: *const rcutils_string_map_t,
key: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcutils_string_map_copy(
src_string_map: *const rcutils_string_map_t,
dst_string_map: *mut rcutils_string_map_t,
) -> rcutils_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_uint8_array_t {
pub buffer: *mut u8,
pub buffer_length: usize,
pub buffer_capacity: usize,
pub allocator: rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rcutils_uint8_array_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_uint8_array_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_uint8_array_t>(),
64usize,
concat!("Size of: ", stringify!(rcutils_uint8_array_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_uint8_array_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_uint8_array_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_uint8_array_t),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_length) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcutils_uint8_array_t),
"::",
stringify!(buffer_length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer_capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcutils_uint8_array_t),
"::",
stringify!(buffer_capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcutils_uint8_array_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcutils_get_zero_initialized_uint8_array() -> rcutils_uint8_array_t;
}
extern "C" {
pub fn rcutils_uint8_array_init(
uint8_array: *mut rcutils_uint8_array_t,
buffer_capacity: usize,
allocator: *const rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_uint8_array_fini(uint8_array: *mut rcutils_uint8_array_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_uint8_array_resize(
uint8_array: *mut rcutils_uint8_array_t,
new_size: usize,
) -> rcutils_ret_t;
}
pub type rcutils_time_point_value_t = i64;
pub type rcutils_duration_value_t = i64;
extern "C" {
pub fn rcutils_system_time_now(now: *mut rcutils_time_point_value_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_steady_time_now(now: *mut rcutils_time_point_value_t) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_time_point_value_as_nanoseconds_string(
time_point: *const rcutils_time_point_value_t,
str_: *mut ::std::os::raw::c_char,
str_size: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_time_point_value_as_seconds_string(
time_point: *const rcutils_time_point_value_t,
str_: *mut ::std::os::raw::c_char,
str_size: usize,
) -> rcutils_ret_t;
}
extern "C" {
pub static mut g_rcutils_logging_initialized: bool;
}
extern "C" {
pub fn rcutils_logging_initialize_with_allocator(
allocator: rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_logging_initialize() -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_logging_shutdown() -> rcutils_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcutils_log_location_t {
pub function_name: *const ::std::os::raw::c_char,
pub file_name: *const ::std::os::raw::c_char,
pub line_number: usize,
}
#[test]
fn bindgen_test_layout_rcutils_log_location_t() {
const UNINIT: ::std::mem::MaybeUninit<rcutils_log_location_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcutils_log_location_t>(),
24usize,
concat!("Size of: ", stringify!(rcutils_log_location_t))
);
assert_eq!(
::std::mem::align_of::<rcutils_log_location_t>(),
8usize,
concat!("Alignment of ", stringify!(rcutils_log_location_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).function_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcutils_log_location_t),
"::",
stringify!(function_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file_name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcutils_log_location_t),
"::",
stringify!(file_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line_number) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcutils_log_location_t),
"::",
stringify!(line_number)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum RCUTILS_LOG_SEVERITY {
RCUTILS_LOG_SEVERITY_UNSET = 0,
RCUTILS_LOG_SEVERITY_DEBUG = 10,
RCUTILS_LOG_SEVERITY_INFO = 20,
RCUTILS_LOG_SEVERITY_WARN = 30,
RCUTILS_LOG_SEVERITY_ERROR = 40,
RCUTILS_LOG_SEVERITY_FATAL = 50,
}
extern "C" {
pub static g_rcutils_log_severity_names: [*const ::std::os::raw::c_char; 51usize];
}
extern "C" {
pub fn rcutils_logging_severity_level_from_string(
severity_string: *const ::std::os::raw::c_char,
allocator: rcutils_allocator_t,
severity: *mut ::std::os::raw::c_int,
) -> rcutils_ret_t;
}
pub type rcutils_logging_output_handler_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const rcutils_log_location_t,
arg2: ::std::os::raw::c_int,
arg3: *const ::std::os::raw::c_char,
arg4: rcutils_time_point_value_t,
arg5: *const ::std::os::raw::c_char,
arg6: *mut va_list,
),
>;
extern "C" {
pub static mut g_rcutils_logging_output_handler: rcutils_logging_output_handler_t;
}
extern "C" {
pub fn rcutils_logging_get_output_handler() -> rcutils_logging_output_handler_t;
}
extern "C" {
pub fn rcutils_logging_set_output_handler(function: rcutils_logging_output_handler_t);
}
extern "C" {
pub fn rcutils_logging_format_message(
location: *const rcutils_log_location_t,
severity: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
timestamp: rcutils_time_point_value_t,
msg: *const ::std::os::raw::c_char,
logging_output: *mut rcutils_char_array_t,
) -> rcutils_ret_t;
}
extern "C" {
pub static mut g_rcutils_logging_default_logger_level: ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_logging_get_default_logger_level() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_logging_set_default_logger_level(level: ::std::os::raw::c_int);
}
extern "C" {
pub fn rcutils_logging_get_logger_level(
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_logging_get_logger_leveln(
name: *const ::std::os::raw::c_char,
name_length: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_logging_set_logger_level(
name: *const ::std::os::raw::c_char,
level: ::std::os::raw::c_int,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcutils_logging_logger_is_enabled_for(
name: *const ::std::os::raw::c_char,
severity: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn rcutils_logging_get_logger_effective_level(
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcutils_log(
location: *const rcutils_log_location_t,
severity: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
format: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn rcutils_logging_console_output_handler(
location: *const rcutils_log_location_t,
severity: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
timestamp: rcutils_time_point_value_t,
format: *const ::std::os::raw::c_char,
args: *mut va_list,
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_policy_kind_t {
RMW_QOS_POLICY_INVALID = 1,
RMW_QOS_POLICY_DURABILITY = 2,
RMW_QOS_POLICY_DEADLINE = 4,
RMW_QOS_POLICY_LIVELINESS = 8,
RMW_QOS_POLICY_RELIABILITY = 16,
RMW_QOS_POLICY_HISTORY = 32,
RMW_QOS_POLICY_LIFESPAN = 64,
RMW_QOS_POLICY_DEPTH = 128,
RMW_QOS_POLICY_LIVELINESS_LEASE_DURATION = 256,
RMW_QOS_POLICY_AVOID_ROS_NAMESPACE_CONVENTIONS = 512,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_qos_incompatible_event_status_t {
pub total_count: i32,
pub total_count_change: i32,
pub last_policy_kind: rmw_qos_policy_kind_t,
}
#[test]
fn bindgen_test_layout_rmw_qos_incompatible_event_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_qos_incompatible_event_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_qos_incompatible_event_status_t>(),
12usize,
concat!("Size of: ", stringify!(rmw_qos_incompatible_event_status_t))
);
assert_eq!(
::std::mem::align_of::<rmw_qos_incompatible_event_status_t>(),
4usize,
concat!(
"Alignment of ",
stringify!(rmw_qos_incompatible_event_status_t)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_incompatible_event_status_t),
"::",
stringify!(total_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count_change) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_incompatible_event_status_t),
"::",
stringify!(total_count_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_policy_kind) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_incompatible_event_status_t),
"::",
stringify!(last_policy_kind)
)
);
}
pub type rmw_requested_qos_incompatible_event_status_t = rmw_qos_incompatible_event_status_t;
pub type rmw_offered_qos_incompatible_event_status_t = rmw_qos_incompatible_event_status_t;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_liveliness_changed_status_t {
pub alive_count: i32,
pub not_alive_count: i32,
pub alive_count_change: i32,
pub not_alive_count_change: i32,
}
#[test]
fn bindgen_test_layout_rmw_liveliness_changed_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_liveliness_changed_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_liveliness_changed_status_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_liveliness_changed_status_t))
);
assert_eq!(
::std::mem::align_of::<rmw_liveliness_changed_status_t>(),
4usize,
concat!("Alignment of ", stringify!(rmw_liveliness_changed_status_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alive_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_changed_status_t),
"::",
stringify!(alive_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).not_alive_count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_changed_status_t),
"::",
stringify!(not_alive_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alive_count_change) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_changed_status_t),
"::",
stringify!(alive_count_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).not_alive_count_change) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_changed_status_t),
"::",
stringify!(not_alive_count_change)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_liveliness_lost_status_t {
pub total_count: i32,
pub total_count_change: i32,
}
#[test]
fn bindgen_test_layout_rmw_liveliness_lost_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_liveliness_lost_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_liveliness_lost_status_t>(),
8usize,
concat!("Size of: ", stringify!(rmw_liveliness_lost_status_t))
);
assert_eq!(
::std::mem::align_of::<rmw_liveliness_lost_status_t>(),
4usize,
concat!("Alignment of ", stringify!(rmw_liveliness_lost_status_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_lost_status_t),
"::",
stringify!(total_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count_change) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rmw_liveliness_lost_status_t),
"::",
stringify!(total_count_change)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_message_lost_status_t {
pub total_count: usize,
pub total_count_change: usize,
}
#[test]
fn bindgen_test_layout_rmw_message_lost_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_message_lost_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_message_lost_status_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_message_lost_status_t))
);
assert_eq!(
::std::mem::align_of::<rmw_message_lost_status_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_message_lost_status_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_lost_status_t),
"::",
stringify!(total_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count_change) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_lost_status_t),
"::",
stringify!(total_count_change)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_offered_deadline_missed_status_t {
pub total_count: i32,
pub total_count_change: i32,
}
#[test]
fn bindgen_test_layout_rmw_offered_deadline_missed_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_offered_deadline_missed_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_offered_deadline_missed_status_t>(),
8usize,
concat!(
"Size of: ",
stringify!(rmw_offered_deadline_missed_status_t)
)
);
assert_eq!(
::std::mem::align_of::<rmw_offered_deadline_missed_status_t>(),
4usize,
concat!(
"Alignment of ",
stringify!(rmw_offered_deadline_missed_status_t)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_offered_deadline_missed_status_t),
"::",
stringify!(total_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count_change) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rmw_offered_deadline_missed_status_t),
"::",
stringify!(total_count_change)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_requested_deadline_missed_status_t {
pub total_count: i32,
pub total_count_change: i32,
}
#[test]
fn bindgen_test_layout_rmw_requested_deadline_missed_status_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_requested_deadline_missed_status_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_requested_deadline_missed_status_t>(),
8usize,
concat!(
"Size of: ",
stringify!(rmw_requested_deadline_missed_status_t)
)
);
assert_eq!(
::std::mem::align_of::<rmw_requested_deadline_missed_status_t>(),
4usize,
concat!(
"Alignment of ",
stringify!(rmw_requested_deadline_missed_status_t)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_requested_deadline_missed_status_t),
"::",
stringify!(total_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_count_change) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rmw_requested_deadline_missed_status_t),
"::",
stringify!(total_count_change)
)
);
}
pub type rmw_serialized_message_t = rcutils_uint8_array_t;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_time_t {
pub sec: u64,
pub nsec: u64,
}
#[test]
fn bindgen_test_layout_rmw_time_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_time_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_time_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_time_t))
);
assert_eq!(
::std::mem::align_of::<rmw_time_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_time_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_time_t),
"::",
stringify!(sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_time_t),
"::",
stringify!(nsec)
)
);
}
pub type rmw_time_point_value_t = rcutils_time_point_value_t;
pub type rmw_duration_t = rcutils_duration_value_t;
extern "C" {
pub fn rmw_time_equal(left: rmw_time_t, right: rmw_time_t) -> bool;
}
extern "C" {
pub fn rmw_time_total_nsec(time: rmw_time_t) -> rmw_duration_t;
}
extern "C" {
pub fn rmw_time_from_nsec(nanoseconds: rmw_duration_t) -> rmw_time_t;
}
extern "C" {
pub fn rmw_time_normalize(time: rmw_time_t) -> rmw_time_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_node_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub name: *const ::std::os::raw::c_char,
pub namespace_: *const ::std::os::raw::c_char,
pub context: *mut rmw_context_t,
}
#[test]
fn bindgen_test_layout_rmw_node_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_node_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_node_t>(),
40usize,
concat!("Size of: ", stringify!(rmw_node_t))
);
assert_eq!(
::std::mem::align_of::<rmw_node_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_node_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_node_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_node_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_node_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).namespace_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_node_t),
"::",
stringify!(namespace_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rmw_node_t),
"::",
stringify!(context)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_endpoint_type_t {
RMW_ENDPOINT_INVALID = 0,
RMW_ENDPOINT_PUBLISHER = 1,
RMW_ENDPOINT_SUBSCRIPTION = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_unique_network_flow_endpoints_requirement_t {
RMW_UNIQUE_NETWORK_FLOW_ENDPOINTS_NOT_REQUIRED = 0,
RMW_UNIQUE_NETWORK_FLOW_ENDPOINTS_STRICTLY_REQUIRED = 1,
RMW_UNIQUE_NETWORK_FLOW_ENDPOINTS_OPTIONALLY_REQUIRED = 2,
RMW_UNIQUE_NETWORK_FLOW_ENDPOINTS_SYSTEM_DEFAULT = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_publisher_options_t {
pub rmw_specific_publisher_payload: *mut ::std::os::raw::c_void,
pub require_unique_network_flow_endpoints: rmw_unique_network_flow_endpoints_requirement_t,
}
#[test]
fn bindgen_test_layout_rmw_publisher_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_publisher_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_publisher_options_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_publisher_options_t))
);
assert_eq!(
::std::mem::align_of::<rmw_publisher_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_publisher_options_t))
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).rmw_specific_publisher_payload) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_options_t),
"::",
stringify!(rmw_specific_publisher_payload)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).require_unique_network_flow_endpoints) as usize
- ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_options_t),
"::",
stringify!(require_unique_network_flow_endpoints)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_publisher_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub topic_name: *const ::std::os::raw::c_char,
pub options: rmw_publisher_options_t,
pub can_loan_messages: bool,
}
#[test]
fn bindgen_test_layout_rmw_publisher_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_publisher_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_publisher_t>(),
48usize,
concat!("Size of: ", stringify!(rmw_publisher_t))
);
assert_eq!(
::std::mem::align_of::<rmw_publisher_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_publisher_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).topic_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_t),
"::",
stringify!(topic_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_t),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).can_loan_messages) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_t),
"::",
stringify!(can_loan_messages)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_subscription_options_t {
pub rmw_specific_subscription_payload: *mut ::std::os::raw::c_void,
pub ignore_local_publications: bool,
pub require_unique_network_flow_endpoints: rmw_unique_network_flow_endpoints_requirement_t,
}
#[test]
fn bindgen_test_layout_rmw_subscription_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_subscription_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_subscription_options_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_subscription_options_t))
);
assert_eq!(
::std::mem::align_of::<rmw_subscription_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_subscription_options_t))
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).rmw_specific_subscription_payload) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_options_t),
"::",
stringify!(rmw_specific_subscription_payload)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_local_publications) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_options_t),
"::",
stringify!(ignore_local_publications)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).require_unique_network_flow_endpoints) as usize
- ptr as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_options_t),
"::",
stringify!(require_unique_network_flow_endpoints)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_subscription_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub topic_name: *const ::std::os::raw::c_char,
pub options: rmw_subscription_options_t,
pub can_loan_messages: bool,
}
#[test]
fn bindgen_test_layout_rmw_subscription_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_subscription_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_subscription_t>(),
48usize,
concat!("Size of: ", stringify!(rmw_subscription_t))
);
assert_eq!(
::std::mem::align_of::<rmw_subscription_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_subscription_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).topic_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_t),
"::",
stringify!(topic_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_t),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).can_loan_messages) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_t),
"::",
stringify!(can_loan_messages)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_service_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub service_name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_rmw_service_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_service_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_service_t>(),
24usize,
concat!("Size of: ", stringify!(rmw_service_t))
);
assert_eq!(
::std::mem::align_of::<rmw_service_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_service_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).service_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_t),
"::",
stringify!(service_name)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_client_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub service_name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_rmw_client_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_client_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_client_t>(),
24usize,
concat!("Size of: ", stringify!(rmw_client_t))
);
assert_eq!(
::std::mem::align_of::<rmw_client_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_client_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_client_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_client_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).service_name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_client_t),
"::",
stringify!(service_name)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_guard_condition_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub context: *mut rmw_context_t,
}
#[test]
fn bindgen_test_layout_rmw_guard_condition_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_guard_condition_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_guard_condition_t>(),
24usize,
concat!("Size of: ", stringify!(rmw_guard_condition_t))
);
assert_eq!(
::std::mem::align_of::<rmw_guard_condition_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_guard_condition_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_guard_condition_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_guard_condition_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_guard_condition_t),
"::",
stringify!(context)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_publisher_allocation_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_publisher_allocation_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_publisher_allocation_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_publisher_allocation_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_publisher_allocation_t))
);
assert_eq!(
::std::mem::align_of::<rmw_publisher_allocation_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_publisher_allocation_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_allocation_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_publisher_allocation_t),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_subscription_allocation_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_subscription_allocation_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_subscription_allocation_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_subscription_allocation_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_subscription_allocation_t))
);
assert_eq!(
::std::mem::align_of::<rmw_subscription_allocation_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_subscription_allocation_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_allocation_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscription_allocation_t),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_subscriptions_t {
pub subscriber_count: usize,
pub subscribers: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_subscriptions_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_subscriptions_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_subscriptions_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_subscriptions_t))
);
assert_eq!(
::std::mem::align_of::<rmw_subscriptions_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_subscriptions_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscriber_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscriptions_t),
"::",
stringify!(subscriber_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscribers) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_subscriptions_t),
"::",
stringify!(subscribers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_services_t {
pub service_count: usize,
pub services: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_services_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_services_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_services_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_services_t))
);
assert_eq!(
::std::mem::align_of::<rmw_services_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_services_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).service_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_services_t),
"::",
stringify!(service_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).services) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_services_t),
"::",
stringify!(services)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_clients_t {
pub client_count: usize,
pub clients: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_clients_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_clients_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_clients_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_clients_t))
);
assert_eq!(
::std::mem::align_of::<rmw_clients_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_clients_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).client_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_clients_t),
"::",
stringify!(client_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).clients) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_clients_t),
"::",
stringify!(clients)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_events_t {
pub event_count: usize,
pub events: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_events_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_events_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_events_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_events_t))
);
assert_eq!(
::std::mem::align_of::<rmw_events_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_events_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).event_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_events_t),
"::",
stringify!(event_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_events_t),
"::",
stringify!(events)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_guard_conditions_t {
pub guard_condition_count: usize,
pub guard_conditions: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_guard_conditions_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_guard_conditions_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_guard_conditions_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_guard_conditions_t))
);
assert_eq!(
::std::mem::align_of::<rmw_guard_conditions_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_guard_conditions_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).guard_condition_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_guard_conditions_t),
"::",
stringify!(guard_condition_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).guard_conditions) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_guard_conditions_t),
"::",
stringify!(guard_conditions)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_wait_set_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub guard_conditions: *mut rmw_guard_conditions_t,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rmw_wait_set_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_wait_set_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_wait_set_t>(),
24usize,
concat!("Size of: ", stringify!(rmw_wait_set_t))
);
assert_eq!(
::std::mem::align_of::<rmw_wait_set_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_wait_set_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_wait_set_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).guard_conditions) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_wait_set_t),
"::",
stringify!(guard_conditions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_wait_set_t),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_request_id_t {
pub writer_guid: [i8; 16usize],
pub sequence_number: i64,
}
#[test]
fn bindgen_test_layout_rmw_request_id_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_request_id_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_request_id_t>(),
24usize,
concat!("Size of: ", stringify!(rmw_request_id_t))
);
assert_eq!(
::std::mem::align_of::<rmw_request_id_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_request_id_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).writer_guid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_request_id_t),
"::",
stringify!(writer_guid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sequence_number) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_request_id_t),
"::",
stringify!(sequence_number)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_service_info_t {
pub source_timestamp: rmw_time_point_value_t,
pub received_timestamp: rmw_time_point_value_t,
pub request_id: rmw_request_id_t,
}
#[test]
fn bindgen_test_layout_rmw_service_info_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_service_info_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_service_info_t>(),
40usize,
concat!("Size of: ", stringify!(rmw_service_info_t))
);
assert_eq!(
::std::mem::align_of::<rmw_service_info_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_service_info_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_timestamp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_info_t),
"::",
stringify!(source_timestamp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).received_timestamp) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_info_t),
"::",
stringify!(received_timestamp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).request_id) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_service_info_t),
"::",
stringify!(request_id)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_reliability_policy_t {
RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT = 0,
RMW_QOS_POLICY_RELIABILITY_RELIABLE = 1,
RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT = 2,
RMW_QOS_POLICY_RELIABILITY_UNKNOWN = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_history_policy_t {
RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT = 0,
RMW_QOS_POLICY_HISTORY_KEEP_LAST = 1,
RMW_QOS_POLICY_HISTORY_KEEP_ALL = 2,
RMW_QOS_POLICY_HISTORY_UNKNOWN = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_durability_policy_t {
RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT = 0,
RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL = 1,
RMW_QOS_POLICY_DURABILITY_VOLATILE = 2,
RMW_QOS_POLICY_DURABILITY_UNKNOWN = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_liveliness_policy_t {
RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT = 0,
RMW_QOS_POLICY_LIVELINESS_AUTOMATIC = 1,
RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE = 2,
RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC = 3,
RMW_QOS_POLICY_LIVELINESS_UNKNOWN = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_qos_profile_t {
pub history: rmw_qos_history_policy_t,
pub depth: usize,
pub reliability: rmw_qos_reliability_policy_t,
pub durability: rmw_qos_durability_policy_t,
pub deadline: rmw_time_t,
pub lifespan: rmw_time_t,
pub liveliness: rmw_qos_liveliness_policy_t,
pub liveliness_lease_duration: rmw_time_t,
pub avoid_ros_namespace_conventions: bool,
}
#[test]
fn bindgen_test_layout_rmw_qos_profile_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_qos_profile_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_qos_profile_t>(),
88usize,
concat!("Size of: ", stringify!(rmw_qos_profile_t))
);
assert_eq!(
::std::mem::align_of::<rmw_qos_profile_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_qos_profile_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).history) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(history)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reliability) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(reliability)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).durability) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(durability)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).deadline) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(deadline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lifespan) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(lifespan)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).liveliness) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(liveliness)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).liveliness_lease_duration) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(liveliness_lease_duration)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).avoid_ros_namespace_conventions) as usize - ptr as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(rmw_qos_profile_t),
"::",
stringify!(avoid_ros_namespace_conventions)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_gid_t {
pub implementation_identifier: *const ::std::os::raw::c_char,
pub data: [u8; 24usize],
}
#[test]
fn bindgen_test_layout_rmw_gid_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_gid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_gid_t>(),
32usize,
concat!("Size of: ", stringify!(rmw_gid_t))
);
assert_eq!(
::std::mem::align_of::<rmw_gid_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_gid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).implementation_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_gid_t),
"::",
stringify!(implementation_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_gid_t),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_message_info_t {
pub source_timestamp: rmw_time_point_value_t,
pub received_timestamp: rmw_time_point_value_t,
pub publisher_gid: rmw_gid_t,
pub from_intra_process: bool,
}
#[test]
fn bindgen_test_layout_rmw_message_info_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_message_info_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_message_info_t>(),
56usize,
concat!("Size of: ", stringify!(rmw_message_info_t))
);
assert_eq!(
::std::mem::align_of::<rmw_message_info_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_message_info_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_timestamp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_t),
"::",
stringify!(source_timestamp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).received_timestamp) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_t),
"::",
stringify!(received_timestamp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).publisher_gid) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_t),
"::",
stringify!(publisher_gid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).from_intra_process) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_t),
"::",
stringify!(from_intra_process)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_message_info() -> rmw_message_info_t;
}
pub const RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT: _bindgen_ty_1 =
_bindgen_ty_1::RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_1 {
RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT = 0,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_log_severity_t {
RMW_LOG_SEVERITY_DEBUG = 10,
RMW_LOG_SEVERITY_INFO = 20,
RMW_LOG_SEVERITY_WARN = 30,
RMW_LOG_SEVERITY_ERROR = 40,
RMW_LOG_SEVERITY_FATAL = 50,
}
pub type rcl_ret_t = rmw_ret_t;
pub type rcl_serialized_message_t = rmw_serialized_message_t;
pub use self::RCUTILS_LOG_SEVERITY as rcl_log_severity_t;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_logger_setting_t {
pub name: *const ::std::os::raw::c_char,
pub level: rcl_log_severity_t,
}
#[test]
fn bindgen_test_layout_rcl_logger_setting_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_logger_setting_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_logger_setting_t>(),
16usize,
concat!("Size of: ", stringify!(rcl_logger_setting_t))
);
assert_eq!(
::std::mem::align_of::<rcl_logger_setting_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_logger_setting_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_logger_setting_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_logger_setting_t),
"::",
stringify!(level)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_log_levels_t {
pub default_logger_level: rcl_log_severity_t,
pub logger_settings: *mut rcl_logger_setting_t,
pub num_logger_settings: usize,
pub capacity_logger_settings: usize,
pub allocator: rcl_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_log_levels_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_log_levels_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_log_levels_t>(),
72usize,
concat!("Size of: ", stringify!(rcl_log_levels_t))
);
assert_eq!(
::std::mem::align_of::<rcl_log_levels_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_log_levels_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_logger_level) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_log_levels_t),
"::",
stringify!(default_logger_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).logger_settings) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_log_levels_t),
"::",
stringify!(logger_settings)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_logger_settings) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_log_levels_t),
"::",
stringify!(num_logger_settings)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity_logger_settings) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_log_levels_t),
"::",
stringify!(capacity_logger_settings)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_log_levels_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_log_levels() -> rcl_log_levels_t;
}
extern "C" {
pub fn rcl_log_levels_init(
log_levels: *mut rcl_log_levels_t,
allocator: *const rcl_allocator_t,
logger_count: usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_log_levels_copy(
src: *const rcl_log_levels_t,
dst: *mut rcl_log_levels_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_log_levels_fini(log_levels: *mut rcl_log_levels_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_log_levels_shrink_to_size(log_levels: *mut rcl_log_levels_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_log_levels_add_logger_setting(
log_levels: *mut rcl_log_levels_t,
logger_name: *const ::std::os::raw::c_char,
log_level: rcl_log_severity_t,
) -> rcl_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_bool_array_s {
pub values: *mut bool,
pub size: usize,
}
#[test]
fn bindgen_test_layout_rcl_bool_array_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_bool_array_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_bool_array_s>(),
16usize,
concat!("Size of: ", stringify!(rcl_bool_array_s))
);
assert_eq!(
::std::mem::align_of::<rcl_bool_array_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_bool_array_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_bool_array_s),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_bool_array_s),
"::",
stringify!(size)
)
);
}
pub type rcl_bool_array_t = rcl_bool_array_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_int64_array_s {
pub values: *mut i64,
pub size: usize,
}
#[test]
fn bindgen_test_layout_rcl_int64_array_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_int64_array_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_int64_array_s>(),
16usize,
concat!("Size of: ", stringify!(rcl_int64_array_s))
);
assert_eq!(
::std::mem::align_of::<rcl_int64_array_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_int64_array_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_int64_array_s),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_int64_array_s),
"::",
stringify!(size)
)
);
}
pub type rcl_int64_array_t = rcl_int64_array_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_double_array_s {
pub values: *mut f64,
pub size: usize,
}
#[test]
fn bindgen_test_layout_rcl_double_array_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_double_array_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_double_array_s>(),
16usize,
concat!("Size of: ", stringify!(rcl_double_array_s))
);
assert_eq!(
::std::mem::align_of::<rcl_double_array_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_double_array_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_double_array_s),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_double_array_s),
"::",
stringify!(size)
)
);
}
pub type rcl_double_array_t = rcl_double_array_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_byte_array_s {
pub values: *mut u8,
pub size: usize,
}
#[test]
fn bindgen_test_layout_rcl_byte_array_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_byte_array_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_byte_array_s>(),
16usize,
concat!("Size of: ", stringify!(rcl_byte_array_s))
);
assert_eq!(
::std::mem::align_of::<rcl_byte_array_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_byte_array_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_byte_array_s),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_byte_array_s),
"::",
stringify!(size)
)
);
}
pub type rcl_byte_array_t = rcl_byte_array_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_variant_s {
pub bool_value: *mut bool,
pub integer_value: *mut i64,
pub double_value: *mut f64,
pub string_value: *mut ::std::os::raw::c_char,
pub byte_array_value: *mut rcl_byte_array_t,
pub bool_array_value: *mut rcl_bool_array_t,
pub integer_array_value: *mut rcl_int64_array_t,
pub double_array_value: *mut rcl_double_array_t,
pub string_array_value: *mut rcutils_string_array_t,
}
#[test]
fn bindgen_test_layout_rcl_variant_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_variant_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_variant_s>(),
72usize,
concat!("Size of: ", stringify!(rcl_variant_s))
);
assert_eq!(
::std::mem::align_of::<rcl_variant_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_variant_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(bool_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integer_value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(integer_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).double_value) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(double_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_value) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(string_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).byte_array_value) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(byte_array_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bool_array_value) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(bool_array_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integer_array_value) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(integer_array_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).double_array_value) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(double_array_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_array_value) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rcl_variant_s),
"::",
stringify!(string_array_value)
)
);
}
pub type rcl_variant_t = rcl_variant_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_node_params_s {
pub parameter_names: *mut *mut ::std::os::raw::c_char,
pub parameter_values: *mut rcl_variant_t,
pub num_params: usize,
pub capacity_params: usize,
}
#[test]
fn bindgen_test_layout_rcl_node_params_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_node_params_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_node_params_s>(),
32usize,
concat!("Size of: ", stringify!(rcl_node_params_s))
);
assert_eq!(
::std::mem::align_of::<rcl_node_params_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_node_params_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parameter_names) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_params_s),
"::",
stringify!(parameter_names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parameter_values) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_params_s),
"::",
stringify!(parameter_values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_params) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_params_s),
"::",
stringify!(num_params)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity_params) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_params_s),
"::",
stringify!(capacity_params)
)
);
}
pub type rcl_node_params_t = rcl_node_params_s;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_params_s {
pub node_names: *mut *mut ::std::os::raw::c_char,
pub params: *mut rcl_node_params_t,
pub num_nodes: usize,
pub capacity_nodes: usize,
pub allocator: rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_params_s() {
const UNINIT: ::std::mem::MaybeUninit<rcl_params_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_params_s>(),
72usize,
concat!("Size of: ", stringify!(rcl_params_s))
);
assert_eq!(
::std::mem::align_of::<rcl_params_s>(),
8usize,
concat!("Alignment of ", stringify!(rcl_params_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_names) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_params_s),
"::",
stringify!(node_names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_params_s),
"::",
stringify!(params)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_nodes) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_params_s),
"::",
stringify!(num_nodes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity_nodes) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_params_s),
"::",
stringify!(capacity_nodes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_params_s),
"::",
stringify!(allocator)
)
);
}
pub type rcl_params_t = rcl_params_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_arguments_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_arguments_t {
pub impl_: *mut rcl_arguments_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_arguments_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_arguments_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_arguments_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_arguments_t))
);
assert_eq!(
::std::mem::align_of::<rcl_arguments_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_arguments_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_arguments_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_arguments() -> rcl_arguments_t;
}
extern "C" {
pub fn rcl_parse_arguments(
argc: ::std::os::raw::c_int,
argv: *const *const ::std::os::raw::c_char,
allocator: rcl_allocator_t,
args_output: *mut rcl_arguments_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_get_count_unparsed(args: *const rcl_arguments_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcl_arguments_get_unparsed(
args: *const rcl_arguments_t,
allocator: rcl_allocator_t,
output_unparsed_indices: *mut *mut ::std::os::raw::c_int,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_get_count_unparsed_ros(
args: *const rcl_arguments_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcl_arguments_get_unparsed_ros(
args: *const rcl_arguments_t,
allocator: rcl_allocator_t,
output_unparsed_ros_indices: *mut *mut ::std::os::raw::c_int,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_get_param_files_count(
args: *const rcl_arguments_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rcl_arguments_get_param_files(
arguments: *const rcl_arguments_t,
allocator: rcl_allocator_t,
parameter_files: *mut *mut *mut ::std::os::raw::c_char,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_get_param_overrides(
arguments: *const rcl_arguments_t,
parameter_overrides: *mut *mut rcl_params_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_remove_ros_arguments(
argv: *const *const ::std::os::raw::c_char,
args: *const rcl_arguments_t,
allocator: rcl_allocator_t,
nonros_argc: *mut ::std::os::raw::c_int,
nonros_argv: *mut *mut *const ::std::os::raw::c_char,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_get_log_levels(
arguments: *const rcl_arguments_t,
log_levels: *mut rcl_log_levels_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_copy(
args: *const rcl_arguments_t,
args_out: *mut rcl_arguments_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_arguments_fini(args: *mut rcl_arguments_t) -> rcl_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_init_options_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_init_options_t {
pub impl_: *mut rcl_init_options_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_init_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_init_options_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_init_options_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_init_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_init_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_init_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_init_options_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_init_options() -> rcl_init_options_t;
}
extern "C" {
pub fn rcl_init_options_init(
init_options: *mut rcl_init_options_t,
allocator: rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_init_options_copy(
src: *const rcl_init_options_t,
dst: *mut rcl_init_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_init_options_fini(init_options: *mut rcl_init_options_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_init_options_get_domain_id(
init_options: *const rcl_init_options_t,
domain_id: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_init_options_set_domain_id(
init_options: *mut rcl_init_options_t,
domain_id: usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_init_options_get_rmw_init_options(
init_options: *mut rcl_init_options_t,
) -> *mut rmw_init_options_t;
}
extern "C" {
pub fn rcl_init_options_get_allocator(
init_options: *const rcl_init_options_t,
) -> *const rcl_allocator_t;
}
pub type rcl_context_instance_id_t = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_context_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_context_t {
pub global_arguments: rcl_arguments_t,
pub impl_: *mut rcl_context_impl_t,
pub instance_id_storage: [u8; 8usize],
}
#[test]
fn bindgen_test_layout_rcl_context_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_context_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_context_t>(),
24usize,
concat!("Size of: ", stringify!(rcl_context_t))
);
assert_eq!(
::std::mem::align_of::<rcl_context_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_context_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).global_arguments) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_context_t),
"::",
stringify!(global_arguments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_context_t),
"::",
stringify!(impl_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instance_id_storage) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_context_t),
"::",
stringify!(instance_id_storage)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_context() -> rcl_context_t;
}
extern "C" {
pub fn rcl_context_fini(context: *mut rcl_context_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_context_get_init_options(context: *const rcl_context_t)
-> *const rcl_init_options_t;
}
extern "C" {
pub fn rcl_context_get_instance_id(context: *const rcl_context_t) -> rcl_context_instance_id_t;
}
extern "C" {
pub fn rcl_context_get_domain_id(
context: *mut rcl_context_t,
domain_id: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_context_is_valid(context: *const rcl_context_t) -> bool;
}
extern "C" {
pub fn rcl_context_get_rmw_context(context: *mut rcl_context_t) -> *mut rmw_context_t;
}
extern "C" {
pub fn rcl_init(
argc: ::std::os::raw::c_int,
argv: *const *const ::std::os::raw::c_char,
options: *const rcl_init_options_t,
context: *mut rcl_context_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_shutdown(context: *mut rcl_context_t) -> rcl_ret_t;
}
extern "C" {
pub static RCL_DOMAIN_ID_ENV_VAR: *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_get_default_domain_id(domain_id: *mut usize) -> rcl_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_node_options_t {
pub allocator: rcl_allocator_t,
pub use_global_arguments: bool,
pub arguments: rcl_arguments_t,
pub enable_rosout: bool,
pub rosout_qos: rmw_qos_profile_t,
}
#[test]
fn bindgen_test_layout_rcl_node_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_node_options_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_node_options_t>(),
152usize,
concat!("Size of: ", stringify!(rcl_node_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_node_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_node_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_options_t),
"::",
stringify!(allocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).use_global_arguments) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_options_t),
"::",
stringify!(use_global_arguments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arguments) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_options_t),
"::",
stringify!(arguments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enable_rosout) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_options_t),
"::",
stringify!(enable_rosout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rosout_qos) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_options_t),
"::",
stringify!(rosout_qos)
)
);
}
extern "C" {
pub fn rcl_node_get_default_options() -> rcl_node_options_t;
}
extern "C" {
pub fn rcl_node_options_copy(
options: *const rcl_node_options_t,
options_out: *mut rcl_node_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_node_options_fini(options: *mut rcl_node_options_t) -> rcl_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_node_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_node_t {
pub context: *mut rcl_context_t,
pub impl_: *mut rcl_node_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_node_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_node_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_node_t>(),
16usize,
concat!("Size of: ", stringify!(rcl_node_t))
);
assert_eq!(
::std::mem::align_of::<rcl_node_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_node_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_t),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_node_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_node() -> rcl_node_t;
}
extern "C" {
pub fn rcl_node_init(
node: *mut rcl_node_t,
name: *const ::std::os::raw::c_char,
namespace_: *const ::std::os::raw::c_char,
context: *mut rcl_context_t,
options: *const rcl_node_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_node_fini(node: *mut rcl_node_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_node_is_valid(node: *const rcl_node_t) -> bool;
}
extern "C" {
pub fn rcl_node_is_valid_except_context(node: *const rcl_node_t) -> bool;
}
extern "C" {
pub fn rcl_node_get_name(node: *const rcl_node_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_node_get_namespace(node: *const rcl_node_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_node_get_fully_qualified_name(
node: *const rcl_node_t,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_node_get_options(node: *const rcl_node_t) -> *const rcl_node_options_t;
}
extern "C" {
pub fn rcl_node_get_domain_id(node: *const rcl_node_t, domain_id: *mut usize) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_node_get_rmw_handle(node: *const rcl_node_t) -> *mut rmw_node_t;
}
extern "C" {
pub fn rcl_node_get_rcl_instance_id(node: *const rcl_node_t) -> u64;
}
extern "C" {
pub fn rcl_node_get_graph_guard_condition(
node: *const rcl_node_t,
) -> *const rcl_guard_condition_t;
}
extern "C" {
pub fn rcl_node_get_logger_name(node: *const rcl_node_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_node_resolve_name(
node: *const rcl_node_t,
input_name: *const ::std::os::raw::c_char,
allocator: rcl_allocator_t,
is_service: bool,
only_expand: bool,
output_name: *mut *mut ::std::os::raw::c_char,
) -> rcl_ret_t;
}
pub type rosidl_message_typesupport_handle_function = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const rosidl_message_type_support_t,
arg2: *const ::std::os::raw::c_char,
) -> *const rosidl_message_type_support_t,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_message_type_support_t {
pub typesupport_identifier: *const ::std::os::raw::c_char,
pub data: *const ::std::os::raw::c_void,
pub func: rosidl_message_typesupport_handle_function,
}
#[test]
fn bindgen_test_layout_rosidl_message_type_support_t() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_message_type_support_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_message_type_support_t>(),
24usize,
concat!("Size of: ", stringify!(rosidl_message_type_support_t))
);
assert_eq!(
::std::mem::align_of::<rosidl_message_type_support_t>(),
8usize,
concat!("Alignment of ", stringify!(rosidl_message_type_support_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typesupport_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_message_type_support_t),
"::",
stringify!(typesupport_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_message_type_support_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_message_type_support_t),
"::",
stringify!(func)
)
);
}
extern "C" {
pub fn get_message_typesupport_handle(
handle: *const rosidl_message_type_support_t,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_message_type_support_t;
}
extern "C" {
pub fn get_message_typesupport_handle_function(
handle: *const rosidl_message_type_support_t,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_message_type_support_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_publisher_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_publisher_t {
pub impl_: *mut rcl_publisher_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_publisher_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_publisher_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_publisher_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_publisher_t))
);
assert_eq!(
::std::mem::align_of::<rcl_publisher_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_publisher_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_publisher_t),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_publisher_options_t {
pub qos: rmw_qos_profile_t,
pub allocator: rcl_allocator_t,
pub rmw_publisher_options: rmw_publisher_options_t,
}
#[test]
fn bindgen_test_layout_rcl_publisher_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_publisher_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_publisher_options_t>(),
144usize,
concat!("Size of: ", stringify!(rcl_publisher_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_publisher_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_publisher_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_publisher_options_t),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rcl_publisher_options_t),
"::",
stringify!(allocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rmw_publisher_options) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(rcl_publisher_options_t),
"::",
stringify!(rmw_publisher_options)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_publisher() -> rcl_publisher_t;
}
extern "C" {
pub fn rcl_publisher_init(
publisher: *mut rcl_publisher_t,
node: *const rcl_node_t,
type_support: *const rosidl_message_type_support_t,
topic_name: *const ::std::os::raw::c_char,
options: *const rcl_publisher_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publisher_fini(publisher: *mut rcl_publisher_t, node: *mut rcl_node_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publisher_get_default_options() -> rcl_publisher_options_t;
}
extern "C" {
pub fn rcl_borrow_loaned_message(
publisher: *const rcl_publisher_t,
type_support: *const rosidl_message_type_support_t,
ros_message: *mut *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_return_loaned_message_from_publisher(
publisher: *const rcl_publisher_t,
loaned_message: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publish(
publisher: *const rcl_publisher_t,
ros_message: *const ::std::os::raw::c_void,
allocation: *mut rmw_publisher_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publish_serialized_message(
publisher: *const rcl_publisher_t,
serialized_message: *const rcl_serialized_message_t,
allocation: *mut rmw_publisher_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publish_loaned_message(
publisher: *const rcl_publisher_t,
ros_message: *mut ::std::os::raw::c_void,
allocation: *mut rmw_publisher_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publisher_assert_liveliness(publisher: *const rcl_publisher_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publisher_get_topic_name(
publisher: *const rcl_publisher_t,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_publisher_get_options(
publisher: *const rcl_publisher_t,
) -> *const rcl_publisher_options_t;
}
extern "C" {
pub fn rcl_publisher_get_rmw_handle(publisher: *const rcl_publisher_t) -> *mut rmw_publisher_t;
}
extern "C" {
pub fn rcl_publisher_get_context(publisher: *const rcl_publisher_t) -> *mut rcl_context_t;
}
extern "C" {
pub fn rcl_publisher_is_valid(publisher: *const rcl_publisher_t) -> bool;
}
extern "C" {
pub fn rcl_publisher_is_valid_except_context(publisher: *const rcl_publisher_t) -> bool;
}
extern "C" {
pub fn rcl_publisher_get_subscription_count(
publisher: *const rcl_publisher_t,
subscription_count: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_publisher_get_actual_qos(
publisher: *const rcl_publisher_t,
) -> *const rmw_qos_profile_t;
}
extern "C" {
pub fn rcl_publisher_can_loan_messages(publisher: *const rcl_publisher_t) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_message_sequence_t {
pub data: *mut *mut ::std::os::raw::c_void,
pub size: usize,
pub capacity: usize,
pub allocator: *mut rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rmw_message_sequence_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_message_sequence_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_message_sequence_t>(),
32usize,
concat!("Size of: ", stringify!(rmw_message_sequence_t))
);
assert_eq!(
::std::mem::align_of::<rmw_message_sequence_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_message_sequence_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_sequence_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_sequence_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_sequence_t),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_sequence_t),
"::",
stringify!(allocator)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_message_info_sequence_t {
pub data: *mut rmw_message_info_t,
pub size: usize,
pub capacity: usize,
pub allocator: *mut rcutils_allocator_t,
}
#[test]
fn bindgen_test_layout_rmw_message_info_sequence_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_message_info_sequence_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_message_info_sequence_t>(),
32usize,
concat!("Size of: ", stringify!(rmw_message_info_sequence_t))
);
assert_eq!(
::std::mem::align_of::<rmw_message_info_sequence_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_message_info_sequence_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_sequence_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_sequence_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_sequence_t),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_message_info_sequence_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_message_sequence() -> rmw_message_sequence_t;
}
extern "C" {
pub fn rmw_message_sequence_init(
sequence: *mut rmw_message_sequence_t,
size: usize,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_message_sequence_fini(sequence: *mut rmw_message_sequence_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_zero_initialized_message_info_sequence() -> rmw_message_info_sequence_t;
}
extern "C" {
pub fn rmw_message_info_sequence_init(
sequence: *mut rmw_message_info_sequence_t,
size: usize,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_message_info_sequence_fini(sequence: *mut rmw_message_info_sequence_t) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_subscription_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_subscription_t {
pub impl_: *mut rcl_subscription_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_subscription_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_subscription_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_subscription_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_subscription_t))
);
assert_eq!(
::std::mem::align_of::<rcl_subscription_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_subscription_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_subscription_t),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_subscription_options_t {
pub qos: rmw_qos_profile_t,
pub allocator: rcl_allocator_t,
pub rmw_subscription_options: rmw_subscription_options_t,
}
#[test]
fn bindgen_test_layout_rcl_subscription_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_subscription_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_subscription_options_t>(),
144usize,
concat!("Size of: ", stringify!(rcl_subscription_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_subscription_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_subscription_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_subscription_options_t),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rcl_subscription_options_t),
"::",
stringify!(allocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rmw_subscription_options) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(rcl_subscription_options_t),
"::",
stringify!(rmw_subscription_options)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_subscription() -> rcl_subscription_t;
}
extern "C" {
pub fn rcl_subscription_init(
subscription: *mut rcl_subscription_t,
node: *const rcl_node_t,
type_support: *const rosidl_message_type_support_t,
topic_name: *const ::std::os::raw::c_char,
options: *const rcl_subscription_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_subscription_fini(
subscription: *mut rcl_subscription_t,
node: *mut rcl_node_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_subscription_get_default_options() -> rcl_subscription_options_t;
}
extern "C" {
pub fn rcl_take(
subscription: *const rcl_subscription_t,
ros_message: *mut ::std::os::raw::c_void,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_sequence(
subscription: *const rcl_subscription_t,
count: usize,
message_sequence: *mut rmw_message_sequence_t,
message_info_sequence: *mut rmw_message_info_sequence_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_serialized_message(
subscription: *const rcl_subscription_t,
serialized_message: *mut rcl_serialized_message_t,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_loaned_message(
subscription: *const rcl_subscription_t,
loaned_message: *mut *mut ::std::os::raw::c_void,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_return_loaned_message_from_subscription(
subscription: *const rcl_subscription_t,
loaned_message: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_subscription_get_topic_name(
subscription: *const rcl_subscription_t,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_subscription_get_options(
subscription: *const rcl_subscription_t,
) -> *const rcl_subscription_options_t;
}
extern "C" {
pub fn rcl_subscription_get_rmw_handle(
subscription: *const rcl_subscription_t,
) -> *mut rmw_subscription_t;
}
extern "C" {
pub fn rcl_subscription_is_valid(subscription: *const rcl_subscription_t) -> bool;
}
extern "C" {
pub fn rcl_subscription_get_publisher_count(
subscription: *const rcl_subscription_t,
publisher_count: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rcl_subscription_get_actual_qos(
subscription: *const rcl_subscription_t,
) -> *const rmw_qos_profile_t;
}
extern "C" {
pub fn rcl_subscription_can_loan_messages(subscription: *const rcl_subscription_t) -> bool;
}
pub type rosidl_service_typesupport_handle_function = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const rosidl_service_type_support_t,
arg2: *const ::std::os::raw::c_char,
) -> *const rosidl_service_type_support_t,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_service_type_support_t {
pub typesupport_identifier: *const ::std::os::raw::c_char,
pub data: *const ::std::os::raw::c_void,
pub func: rosidl_service_typesupport_handle_function,
}
#[test]
fn bindgen_test_layout_rosidl_service_type_support_t() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_service_type_support_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_service_type_support_t>(),
24usize,
concat!("Size of: ", stringify!(rosidl_service_type_support_t))
);
assert_eq!(
::std::mem::align_of::<rosidl_service_type_support_t>(),
8usize,
concat!("Alignment of ", stringify!(rosidl_service_type_support_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typesupport_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_service_type_support_t),
"::",
stringify!(typesupport_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_service_type_support_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_service_type_support_t),
"::",
stringify!(func)
)
);
}
extern "C" {
pub fn get_service_typesupport_handle(
handle: *const rosidl_service_type_support_t,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_service_type_support_t;
}
extern "C" {
pub fn get_service_typesupport_handle_function(
handle: *const rosidl_service_type_support_t,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_service_type_support_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_client_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_client_t {
pub impl_: *mut rcl_client_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_client_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_client_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_client_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_client_t))
);
assert_eq!(
::std::mem::align_of::<rcl_client_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_client_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_client_t),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_client_options_t {
pub qos: rmw_qos_profile_t,
pub allocator: rcl_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_client_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_client_options_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_client_options_t>(),
128usize,
concat!("Size of: ", stringify!(rcl_client_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_client_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_client_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_client_options_t),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rcl_client_options_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_client() -> rcl_client_t;
}
extern "C" {
pub fn rcl_client_init(
client: *mut rcl_client_t,
node: *const rcl_node_t,
type_support: *const rosidl_service_type_support_t,
service_name: *const ::std::os::raw::c_char,
options: *const rcl_client_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_client_fini(client: *mut rcl_client_t, node: *mut rcl_node_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_client_get_default_options() -> rcl_client_options_t;
}
extern "C" {
pub fn rcl_send_request(
client: *const rcl_client_t,
ros_request: *const ::std::os::raw::c_void,
sequence_number: *mut i64,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_response_with_info(
client: *const rcl_client_t,
request_header: *mut rmw_service_info_t,
ros_response: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_response(
client: *const rcl_client_t,
request_header: *mut rmw_request_id_t,
ros_response: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_client_get_service_name(
client: *const rcl_client_t,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_client_get_options(client: *const rcl_client_t) -> *const rcl_client_options_t;
}
extern "C" {
pub fn rcl_client_get_rmw_handle(client: *const rcl_client_t) -> *mut rmw_client_t;
}
extern "C" {
pub fn rcl_client_is_valid(client: *const rcl_client_t) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_guard_condition_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_guard_condition_t {
pub context: *mut rcl_context_t,
pub impl_: *mut rcl_guard_condition_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_guard_condition_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_guard_condition_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_guard_condition_t>(),
16usize,
concat!("Size of: ", stringify!(rcl_guard_condition_t))
);
assert_eq!(
::std::mem::align_of::<rcl_guard_condition_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_guard_condition_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_guard_condition_t),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_guard_condition_t),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_guard_condition_options_t {
pub allocator: rcl_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_guard_condition_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_guard_condition_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_guard_condition_options_t>(),
40usize,
concat!("Size of: ", stringify!(rcl_guard_condition_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_guard_condition_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_guard_condition_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_guard_condition_options_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_guard_condition() -> rcl_guard_condition_t;
}
extern "C" {
pub fn rcl_guard_condition_init(
guard_condition: *mut rcl_guard_condition_t,
context: *mut rcl_context_t,
options: rcl_guard_condition_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_guard_condition_init_from_rmw(
guard_condition: *mut rcl_guard_condition_t,
rmw_guard_condition: *const rmw_guard_condition_t,
context: *mut rcl_context_t,
options: rcl_guard_condition_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_guard_condition_fini(guard_condition: *mut rcl_guard_condition_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_guard_condition_get_default_options() -> rcl_guard_condition_options_t;
}
extern "C" {
pub fn rcl_trigger_guard_condition(guard_condition: *mut rcl_guard_condition_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_guard_condition_get_options(
guard_condition: *const rcl_guard_condition_t,
) -> *const rcl_guard_condition_options_t;
}
extern "C" {
pub fn rcl_guard_condition_get_rmw_handle(
guard_condition: *const rcl_guard_condition_t,
) -> *mut rmw_guard_condition_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_service_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_service_t {
pub impl_: *mut rcl_service_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_service_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_service_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_service_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_service_t))
);
assert_eq!(
::std::mem::align_of::<rcl_service_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_service_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_service_t),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_service_options_t {
pub qos: rmw_qos_profile_t,
pub allocator: rcl_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_service_options_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_service_options_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_service_options_t>(),
128usize,
concat!("Size of: ", stringify!(rcl_service_options_t))
);
assert_eq!(
::std::mem::align_of::<rcl_service_options_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_service_options_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_service_options_t),
"::",
stringify!(qos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rcl_service_options_t),
"::",
stringify!(allocator)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_service() -> rcl_service_t;
}
extern "C" {
pub fn rcl_service_init(
service: *mut rcl_service_t,
node: *const rcl_node_t,
type_support: *const rosidl_service_type_support_t,
service_name: *const ::std::os::raw::c_char,
options: *const rcl_service_options_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_service_fini(service: *mut rcl_service_t, node: *mut rcl_node_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_service_get_default_options() -> rcl_service_options_t;
}
extern "C" {
pub fn rcl_take_request_with_info(
service: *const rcl_service_t,
request_header: *mut rmw_service_info_t,
ros_request: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_request(
service: *const rcl_service_t,
request_header: *mut rmw_request_id_t,
ros_request: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_send_response(
service: *const rcl_service_t,
response_header: *mut rmw_request_id_t,
ros_response: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_service_get_service_name(
service: *const rcl_service_t,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rcl_service_get_options(service: *const rcl_service_t) -> *const rcl_service_options_t;
}
extern "C" {
pub fn rcl_service_get_rmw_handle(service: *const rcl_service_t) -> *mut rmw_service_t;
}
extern "C" {
pub fn rcl_service_is_valid(service: *const rcl_service_t) -> bool;
}
pub type rcl_time_point_value_t = rcutils_time_point_value_t;
pub type rcl_duration_value_t = rcutils_duration_value_t;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rcl_clock_type_t {
RCL_CLOCK_UNINITIALIZED = 0,
RCL_ROS_TIME = 1,
RCL_SYSTEM_TIME = 2,
RCL_STEADY_TIME = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_duration_t {
pub nanoseconds: rcl_duration_value_t,
}
#[test]
fn bindgen_test_layout_rcl_duration_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_duration_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_duration_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_duration_t))
);
assert_eq!(
::std::mem::align_of::<rcl_duration_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_duration_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nanoseconds) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_duration_t),
"::",
stringify!(nanoseconds)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rcl_clock_change_t {
RCL_ROS_TIME_NO_CHANGE = 1,
RCL_ROS_TIME_ACTIVATED = 2,
RCL_ROS_TIME_DEACTIVATED = 3,
RCL_SYSTEM_TIME_NO_CHANGE = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_time_jump_t {
pub clock_change: rcl_clock_change_t,
pub delta: rcl_duration_t,
}
#[test]
fn bindgen_test_layout_rcl_time_jump_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_time_jump_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_time_jump_t>(),
16usize,
concat!("Size of: ", stringify!(rcl_time_jump_t))
);
assert_eq!(
::std::mem::align_of::<rcl_time_jump_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_time_jump_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).clock_change) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_time_jump_t),
"::",
stringify!(clock_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_time_jump_t),
"::",
stringify!(delta)
)
);
}
pub type rcl_jump_callback_t = ::std::option::Option<
unsafe extern "C" fn(
time_jump: *const rcl_time_jump_t,
before_jump: bool,
user_data: *mut ::std::os::raw::c_void,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_jump_threshold_t {
pub on_clock_change: bool,
pub min_forward: rcl_duration_t,
pub min_backward: rcl_duration_t,
}
#[test]
fn bindgen_test_layout_rcl_jump_threshold_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_jump_threshold_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_jump_threshold_t>(),
24usize,
concat!("Size of: ", stringify!(rcl_jump_threshold_t))
);
assert_eq!(
::std::mem::align_of::<rcl_jump_threshold_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_jump_threshold_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).on_clock_change) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_threshold_t),
"::",
stringify!(on_clock_change)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_forward) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_threshold_t),
"::",
stringify!(min_forward)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_backward) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_threshold_t),
"::",
stringify!(min_backward)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_jump_callback_info_t {
pub callback: rcl_jump_callback_t,
pub threshold: rcl_jump_threshold_t,
pub user_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_rcl_jump_callback_info_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_jump_callback_info_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_jump_callback_info_t>(),
40usize,
concat!("Size of: ", stringify!(rcl_jump_callback_info_t))
);
assert_eq!(
::std::mem::align_of::<rcl_jump_callback_info_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_jump_callback_info_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_callback_info_t),
"::",
stringify!(callback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).threshold) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_callback_info_t),
"::",
stringify!(threshold)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_jump_callback_info_t),
"::",
stringify!(user_data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_clock_t {
pub type_: rcl_clock_type_t,
pub jump_callbacks: *mut rcl_jump_callback_info_t,
pub num_jump_callbacks: usize,
pub get_now: ::std::option::Option<
unsafe extern "C" fn(
data: *mut ::std::os::raw::c_void,
now: *mut rcl_time_point_value_t,
) -> rcl_ret_t,
>,
pub data: *mut ::std::os::raw::c_void,
pub allocator: rcl_allocator_t,
}
#[test]
fn bindgen_test_layout_rcl_clock_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_clock_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_clock_t>(),
80usize,
concat!("Size of: ", stringify!(rcl_clock_t))
);
assert_eq!(
::std::mem::align_of::<rcl_clock_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_clock_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).jump_callbacks) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(jump_callbacks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_jump_callbacks) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(num_jump_callbacks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_now) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(get_now)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rcl_clock_t),
"::",
stringify!(allocator)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_time_point_t {
pub nanoseconds: rcl_time_point_value_t,
pub clock_type: rcl_clock_type_t,
}
#[test]
fn bindgen_test_layout_rcl_time_point_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_time_point_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_time_point_t>(),
16usize,
concat!("Size of: ", stringify!(rcl_time_point_t))
);
assert_eq!(
::std::mem::align_of::<rcl_time_point_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_time_point_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nanoseconds) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_time_point_t),
"::",
stringify!(nanoseconds)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).clock_type) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_time_point_t),
"::",
stringify!(clock_type)
)
);
}
extern "C" {
pub fn rcl_clock_valid(clock: *mut rcl_clock_t) -> bool;
}
extern "C" {
pub fn rcl_clock_init(
clock_type: rcl_clock_type_t,
clock: *mut rcl_clock_t,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_clock_fini(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_ros_clock_init(
clock: *mut rcl_clock_t,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_ros_clock_fini(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_steady_clock_init(
clock: *mut rcl_clock_t,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_steady_clock_fini(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_system_clock_init(
clock: *mut rcl_clock_t,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_system_clock_fini(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_difference_times(
start: *mut rcl_time_point_t,
finish: *mut rcl_time_point_t,
delta: *mut rcl_duration_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_clock_get_now(
clock: *mut rcl_clock_t,
time_point_value: *mut rcl_time_point_value_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_enable_ros_time_override(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_disable_ros_time_override(clock: *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_is_enabled_ros_time_override(
clock: *mut rcl_clock_t,
is_enabled: *mut bool,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_set_ros_time_override(
clock: *mut rcl_clock_t,
time_value: rcl_time_point_value_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_clock_add_jump_callback(
clock: *mut rcl_clock_t,
threshold: rcl_jump_threshold_t,
callback: rcl_jump_callback_t,
user_data: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_clock_remove_jump_callback(
clock: *mut rcl_clock_t,
callback: rcl_jump_callback_t,
user_data: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
pub type rosidl_runtime_c__bound_handle_function = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const rosidl_runtime_c__Sequence__bound,
arg2: *const ::std::os::raw::c_char,
) -> *const rosidl_runtime_c__Sequence__bound,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__Sequence__bound {
pub typesupport_identifier: *const ::std::os::raw::c_char,
pub data: *const ::std::os::raw::c_void,
pub func: rosidl_runtime_c__bound_handle_function,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__Sequence__bound() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__Sequence__bound> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__Sequence__bound>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__Sequence__bound))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__Sequence__bound>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__Sequence__bound)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typesupport_identifier) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__Sequence__bound),
"::",
stringify!(typesupport_identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__Sequence__bound),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__Sequence__bound),
"::",
stringify!(func)
)
);
}
extern "C" {
pub fn get_sequence_bound_handle(
handle: *const rosidl_runtime_c__Sequence__bound,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_runtime_c__Sequence__bound;
}
extern "C" {
pub fn get_sequence_bound_handle_function(
handle: *const rosidl_runtime_c__Sequence__bound,
identifier: *const ::std::os::raw::c_char,
) -> *const rosidl_runtime_c__Sequence__bound;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rmw_qos_compatibility_type_t {
RMW_QOS_COMPATIBILITY_OK = 0,
RMW_QOS_COMPATIBILITY_WARNING = 1,
RMW_QOS_COMPATIBILITY_ERROR = 2,
}
extern "C" {
pub fn rmw_qos_profile_check_compatible(
publisher_profile: rmw_qos_profile_t,
subscription_profile: rmw_qos_profile_t,
compatibility: *mut rmw_qos_compatibility_type_t,
reason: *mut ::std::os::raw::c_char,
reason_size: usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_default_subscription_options() -> rmw_subscription_options_t;
}
extern "C" {
pub fn rmw_get_implementation_identifier() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rmw_get_serialization_format() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rmw_create_node(
context: *mut rmw_context_t,
name: *const ::std::os::raw::c_char,
namespace_: *const ::std::os::raw::c_char,
) -> *mut rmw_node_t;
}
extern "C" {
pub fn rmw_destroy_node(node: *mut rmw_node_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_node_assert_liveliness(node: *const rmw_node_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_node_get_graph_guard_condition(
node: *const rmw_node_t,
) -> *const rmw_guard_condition_t;
}
extern "C" {
pub fn rmw_init_publisher_allocation(
type_support: *const rosidl_message_type_support_t,
message_bounds: *const rosidl_runtime_c__Sequence__bound,
allocation: *mut rmw_publisher_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_fini_publisher_allocation(allocation: *mut rmw_publisher_allocation_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_default_publisher_options() -> rmw_publisher_options_t;
}
extern "C" {
pub fn rmw_create_publisher(
node: *const rmw_node_t,
type_support: *const rosidl_message_type_support_t,
topic_name: *const ::std::os::raw::c_char,
qos_profile: *const rmw_qos_profile_t,
publisher_options: *const rmw_publisher_options_t,
) -> *mut rmw_publisher_t;
}
extern "C" {
pub fn rmw_destroy_publisher(
node: *mut rmw_node_t,
publisher: *mut rmw_publisher_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_borrow_loaned_message(
publisher: *const rmw_publisher_t,
type_support: *const rosidl_message_type_support_t,
ros_message: *mut *mut ::std::os::raw::c_void,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_return_loaned_message_from_publisher(
publisher: *const rmw_publisher_t,
loaned_message: *mut ::std::os::raw::c_void,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publish(
publisher: *const rmw_publisher_t,
ros_message: *const ::std::os::raw::c_void,
allocation: *mut rmw_publisher_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publish_loaned_message(
publisher: *const rmw_publisher_t,
ros_message: *mut ::std::os::raw::c_void,
allocation: *mut rmw_publisher_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publisher_count_matched_subscriptions(
publisher: *const rmw_publisher_t,
subscription_count: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publisher_get_actual_qos(
publisher: *const rmw_publisher_t,
qos: *mut rmw_qos_profile_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publish_serialized_message(
publisher: *const rmw_publisher_t,
serialized_message: *const rmw_serialized_message_t,
allocation: *mut rmw_publisher_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_serialized_message_size(
type_support: *const rosidl_message_type_support_t,
message_bounds: *const rosidl_runtime_c__Sequence__bound,
size: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_publisher_assert_liveliness(publisher: *const rmw_publisher_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_serialize(
ros_message: *const ::std::os::raw::c_void,
type_support: *const rosidl_message_type_support_t,
serialized_message: *mut rmw_serialized_message_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_deserialize(
serialized_message: *const rmw_serialized_message_t,
type_support: *const rosidl_message_type_support_t,
ros_message: *mut ::std::os::raw::c_void,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_init_subscription_allocation(
type_support: *const rosidl_message_type_support_t,
message_bounds: *const rosidl_runtime_c__Sequence__bound,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_fini_subscription_allocation(
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_create_subscription(
node: *const rmw_node_t,
type_support: *const rosidl_message_type_support_t,
topic_name: *const ::std::os::raw::c_char,
qos_policies: *const rmw_qos_profile_t,
subscription_options: *const rmw_subscription_options_t,
) -> *mut rmw_subscription_t;
}
extern "C" {
pub fn rmw_destroy_subscription(
node: *mut rmw_node_t,
subscription: *mut rmw_subscription_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_subscription_count_matched_publishers(
subscription: *const rmw_subscription_t,
publisher_count: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_subscription_get_actual_qos(
subscription: *const rmw_subscription_t,
qos: *mut rmw_qos_profile_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take(
subscription: *const rmw_subscription_t,
ros_message: *mut ::std::os::raw::c_void,
taken: *mut bool,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_with_info(
subscription: *const rmw_subscription_t,
ros_message: *mut ::std::os::raw::c_void,
taken: *mut bool,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_sequence(
subscription: *const rmw_subscription_t,
count: usize,
message_sequence: *mut rmw_message_sequence_t,
message_info_sequence: *mut rmw_message_info_sequence_t,
taken: *mut usize,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_serialized_message(
subscription: *const rmw_subscription_t,
serialized_message: *mut rmw_serialized_message_t,
taken: *mut bool,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_serialized_message_with_info(
subscription: *const rmw_subscription_t,
serialized_message: *mut rmw_serialized_message_t,
taken: *mut bool,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_loaned_message(
subscription: *const rmw_subscription_t,
loaned_message: *mut *mut ::std::os::raw::c_void,
taken: *mut bool,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_loaned_message_with_info(
subscription: *const rmw_subscription_t,
loaned_message: *mut *mut ::std::os::raw::c_void,
taken: *mut bool,
message_info: *mut rmw_message_info_t,
allocation: *mut rmw_subscription_allocation_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_return_loaned_message_from_subscription(
subscription: *const rmw_subscription_t,
loaned_message: *mut ::std::os::raw::c_void,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_create_client(
node: *const rmw_node_t,
type_support: *const rosidl_service_type_support_t,
service_name: *const ::std::os::raw::c_char,
qos_policies: *const rmw_qos_profile_t,
) -> *mut rmw_client_t;
}
extern "C" {
pub fn rmw_destroy_client(node: *mut rmw_node_t, client: *mut rmw_client_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_send_request(
client: *const rmw_client_t,
ros_request: *const ::std::os::raw::c_void,
sequence_id: *mut i64,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_response(
client: *const rmw_client_t,
request_header: *mut rmw_service_info_t,
ros_response: *mut ::std::os::raw::c_void,
taken: *mut bool,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_create_service(
node: *const rmw_node_t,
type_support: *const rosidl_service_type_support_t,
service_name: *const ::std::os::raw::c_char,
qos_profile: *const rmw_qos_profile_t,
) -> *mut rmw_service_t;
}
extern "C" {
pub fn rmw_destroy_service(node: *mut rmw_node_t, service: *mut rmw_service_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_take_request(
service: *const rmw_service_t,
request_header: *mut rmw_service_info_t,
ros_request: *mut ::std::os::raw::c_void,
taken: *mut bool,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_send_response(
service: *const rmw_service_t,
request_header: *mut rmw_request_id_t,
ros_response: *mut ::std::os::raw::c_void,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_create_guard_condition(context: *mut rmw_context_t) -> *mut rmw_guard_condition_t;
}
extern "C" {
pub fn rmw_destroy_guard_condition(guard_condition: *mut rmw_guard_condition_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_trigger_guard_condition(guard_condition: *const rmw_guard_condition_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_create_wait_set(
context: *mut rmw_context_t,
max_conditions: usize,
) -> *mut rmw_wait_set_t;
}
extern "C" {
pub fn rmw_destroy_wait_set(wait_set: *mut rmw_wait_set_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_wait(
subscriptions: *mut rmw_subscriptions_t,
guard_conditions: *mut rmw_guard_conditions_t,
services: *mut rmw_services_t,
clients: *mut rmw_clients_t,
events: *mut rmw_events_t,
wait_set: *mut rmw_wait_set_t,
wait_timeout: *const rmw_time_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_node_names(
node: *const rmw_node_t,
node_names: *mut rcutils_string_array_t,
node_namespaces: *mut rcutils_string_array_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_node_names_with_enclaves(
node: *const rmw_node_t,
node_names: *mut rcutils_string_array_t,
node_namespaces: *mut rcutils_string_array_t,
enclaves: *mut rcutils_string_array_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_count_publishers(
node: *const rmw_node_t,
topic_name: *const ::std::os::raw::c_char,
count: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_count_subscribers(
node: *const rmw_node_t,
topic_name: *const ::std::os::raw::c_char,
count: *mut usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_gid_for_publisher(
publisher: *const rmw_publisher_t,
gid: *mut rmw_gid_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_compare_gids_equal(
gid1: *const rmw_gid_t,
gid2: *const rmw_gid_t,
result: *mut bool,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_service_server_is_available(
node: *const rmw_node_t,
client: *const rmw_client_t,
is_available: *mut bool,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_set_log_severity(severity: rmw_log_severity_t) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_timer_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_timer_t {
pub impl_: *mut rcl_timer_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_timer_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_timer_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_timer_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_timer_t))
);
assert_eq!(
::std::mem::align_of::<rcl_timer_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_timer_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_timer_t),
"::",
stringify!(impl_)
)
);
}
pub type rcl_timer_callback_t =
::std::option::Option<unsafe extern "C" fn(arg1: *mut rcl_timer_t, arg2: i64)>;
extern "C" {
pub fn rcl_get_zero_initialized_timer() -> rcl_timer_t;
}
extern "C" {
pub fn rcl_timer_init(
timer: *mut rcl_timer_t,
clock: *mut rcl_clock_t,
context: *mut rcl_context_t,
period: i64,
callback: rcl_timer_callback_t,
allocator: rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_fini(timer: *mut rcl_timer_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_call(timer: *mut rcl_timer_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_clock(timer: *mut rcl_timer_t, clock: *mut *mut rcl_clock_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_is_ready(timer: *const rcl_timer_t, is_ready: *mut bool) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_get_time_until_next_call(
timer: *const rcl_timer_t,
time_until_next_call: *mut i64,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_get_time_since_last_call(
timer: *const rcl_timer_t,
time_since_last_call: *mut i64,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_get_period(timer: *const rcl_timer_t, period: *mut i64) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_exchange_period(
timer: *const rcl_timer_t,
new_period: i64,
old_period: *mut i64,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_get_callback(timer: *const rcl_timer_t) -> rcl_timer_callback_t;
}
extern "C" {
pub fn rcl_timer_exchange_callback(
timer: *mut rcl_timer_t,
new_callback: rcl_timer_callback_t,
) -> rcl_timer_callback_t;
}
extern "C" {
pub fn rcl_timer_cancel(timer: *mut rcl_timer_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_is_canceled(timer: *const rcl_timer_t, is_canceled: *mut bool) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_reset(timer: *mut rcl_timer_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_timer_get_allocator(timer: *const rcl_timer_t) -> *const rcl_allocator_t;
}
extern "C" {
pub fn rcl_timer_get_guard_condition(timer: *const rcl_timer_t) -> *mut rcl_guard_condition_t;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rcl_publisher_event_type_t {
RCL_PUBLISHER_OFFERED_DEADLINE_MISSED = 0,
RCL_PUBLISHER_LIVELINESS_LOST = 1,
RCL_PUBLISHER_OFFERED_INCOMPATIBLE_QOS = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rcl_subscription_event_type_t {
RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED = 0,
RCL_SUBSCRIPTION_LIVELINESS_CHANGED = 1,
RCL_SUBSCRIPTION_REQUESTED_INCOMPATIBLE_QOS = 2,
RCL_SUBSCRIPTION_MESSAGE_LOST = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rmw_event_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_event_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_event_t {
pub impl_: *mut rcl_event_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_event_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_event_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_event_t>(),
8usize,
concat!("Size of: ", stringify!(rcl_event_t))
);
assert_eq!(
::std::mem::align_of::<rcl_event_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_event_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_event_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_event() -> rcl_event_t;
}
extern "C" {
pub fn rcl_publisher_event_init(
event: *mut rcl_event_t,
publisher: *const rcl_publisher_t,
event_type: rcl_publisher_event_type_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_subscription_event_init(
event: *mut rcl_event_t,
subscription: *const rcl_subscription_t,
event_type: rcl_subscription_event_type_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_take_event(
event: *const rcl_event_t,
event_info: *mut ::std::os::raw::c_void,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_event_fini(event: *mut rcl_event_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_event_get_rmw_handle(event: *const rcl_event_t) -> *mut rmw_event_t;
}
extern "C" {
pub fn rcl_event_is_valid(event: *const rcl_event_t) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcl_wait_set_impl_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rcl_wait_set_t {
pub subscriptions: *mut *const rcl_subscription_t,
pub size_of_subscriptions: usize,
pub guard_conditions: *mut *const rcl_guard_condition_t,
pub size_of_guard_conditions: usize,
pub timers: *mut *const rcl_timer_t,
pub size_of_timers: usize,
pub clients: *mut *const rcl_client_t,
pub size_of_clients: usize,
pub services: *mut *const rcl_service_t,
pub size_of_services: usize,
pub events: *mut *const rcl_event_t,
pub size_of_events: usize,
pub impl_: *mut rcl_wait_set_impl_t,
}
#[test]
fn bindgen_test_layout_rcl_wait_set_t() {
const UNINIT: ::std::mem::MaybeUninit<rcl_wait_set_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rcl_wait_set_t>(),
104usize,
concat!("Size of: ", stringify!(rcl_wait_set_t))
);
assert_eq!(
::std::mem::align_of::<rcl_wait_set_t>(),
8usize,
concat!("Alignment of ", stringify!(rcl_wait_set_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subscriptions) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(subscriptions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_subscriptions) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_subscriptions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).guard_conditions) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(guard_conditions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_guard_conditions) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_guard_conditions)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timers) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(timers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_timers) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_timers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).clients) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(clients)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_clients) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_clients)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).services) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(services)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_services) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_services)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(events)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_events) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(size_of_events)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).impl_) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(rcl_wait_set_t),
"::",
stringify!(impl_)
)
);
}
extern "C" {
pub fn rcl_get_zero_initialized_wait_set() -> rcl_wait_set_t;
}
extern "C" {
pub fn rcl_wait_set_init(
wait_set: *mut rcl_wait_set_t,
number_of_subscriptions: usize,
number_of_guard_conditions: usize,
number_of_timers: usize,
number_of_clients: usize,
number_of_services: usize,
number_of_events: usize,
context: *mut rcl_context_t,
allocator: rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_fini(wait_set: *mut rcl_wait_set_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_get_allocator(
wait_set: *const rcl_wait_set_t,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_subscription(
wait_set: *mut rcl_wait_set_t,
subscription: *const rcl_subscription_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_clear(wait_set: *mut rcl_wait_set_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_resize(
wait_set: *mut rcl_wait_set_t,
subscriptions_size: usize,
guard_conditions_size: usize,
timers_size: usize,
clients_size: usize,
services_size: usize,
events_size: usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_guard_condition(
wait_set: *mut rcl_wait_set_t,
guard_condition: *const rcl_guard_condition_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_timer(
wait_set: *mut rcl_wait_set_t,
timer: *const rcl_timer_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_client(
wait_set: *mut rcl_wait_set_t,
client: *const rcl_client_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_service(
wait_set: *mut rcl_wait_set_t,
service: *const rcl_service_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_add_event(
wait_set: *mut rcl_wait_set_t,
event: *const rcl_event_t,
index: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait(wait_set: *mut rcl_wait_set_t, timeout: i64) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_set_is_valid(wait_set: *const rcl_wait_set_t) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_names_and_types_t {
pub names: rcutils_string_array_t,
pub types: *mut rcutils_string_array_t,
}
#[test]
fn bindgen_test_layout_rmw_names_and_types_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_names_and_types_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_names_and_types_t>(),
64usize,
concat!("Size of: ", stringify!(rmw_names_and_types_t))
);
assert_eq!(
::std::mem::align_of::<rmw_names_and_types_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_names_and_types_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_names_and_types_t),
"::",
stringify!(names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).types) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rmw_names_and_types_t),
"::",
stringify!(types)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_names_and_types() -> rmw_names_and_types_t;
}
extern "C" {
pub fn rmw_names_and_types_check_zero(names_and_types: *mut rmw_names_and_types_t)
-> rmw_ret_t;
}
extern "C" {
pub fn rmw_names_and_types_init(
names_and_types: *mut rmw_names_and_types_t,
size: usize,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_names_and_types_fini(names_and_types: *mut rmw_names_and_types_t) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_get_topic_names_and_types(
node: *const rmw_node_t,
allocator: *mut rcutils_allocator_t,
no_demangle: bool,
topic_names_and_types: *mut rmw_names_and_types_t,
) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_topic_endpoint_info_t {
pub node_name: *const ::std::os::raw::c_char,
pub node_namespace: *const ::std::os::raw::c_char,
pub topic_type: *const ::std::os::raw::c_char,
pub endpoint_type: rmw_endpoint_type_t,
pub endpoint_gid: [u8; 24usize],
pub qos_profile: rmw_qos_profile_t,
}
#[test]
fn bindgen_test_layout_rmw_topic_endpoint_info_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_topic_endpoint_info_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_topic_endpoint_info_t>(),
144usize,
concat!("Size of: ", stringify!(rmw_topic_endpoint_info_t))
);
assert_eq!(
::std::mem::align_of::<rmw_topic_endpoint_info_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_topic_endpoint_info_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(node_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_namespace) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(node_namespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).topic_type) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(topic_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endpoint_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(endpoint_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endpoint_gid) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(endpoint_gid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qos_profile) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_t),
"::",
stringify!(qos_profile)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_topic_endpoint_info() -> rmw_topic_endpoint_info_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_fini(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_topic_type(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
topic_type: *const ::std::os::raw::c_char,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_node_name(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
node_name: *const ::std::os::raw::c_char,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_node_namespace(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
node_namespace: *const ::std::os::raw::c_char,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_endpoint_type(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
type_: rmw_endpoint_type_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_gid(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
gid: *const u8,
size: usize,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_set_qos_profile(
topic_endpoint_info: *mut rmw_topic_endpoint_info_t,
qos_profile: *const rmw_qos_profile_t,
) -> rmw_ret_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rmw_topic_endpoint_info_array_t {
pub size: usize,
pub info_array: *mut rmw_topic_endpoint_info_t,
}
#[test]
fn bindgen_test_layout_rmw_topic_endpoint_info_array_t() {
const UNINIT: ::std::mem::MaybeUninit<rmw_topic_endpoint_info_array_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rmw_topic_endpoint_info_array_t>(),
16usize,
concat!("Size of: ", stringify!(rmw_topic_endpoint_info_array_t))
);
assert_eq!(
::std::mem::align_of::<rmw_topic_endpoint_info_array_t>(),
8usize,
concat!("Alignment of ", stringify!(rmw_topic_endpoint_info_array_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_array_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).info_array) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rmw_topic_endpoint_info_array_t),
"::",
stringify!(info_array)
)
);
}
extern "C" {
pub fn rmw_get_zero_initialized_topic_endpoint_info_array() -> rmw_topic_endpoint_info_array_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_array_check_zero(
topic_endpoint_info_array: *mut rmw_topic_endpoint_info_array_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_array_init_with_size(
topic_endpoint_info_array: *mut rmw_topic_endpoint_info_array_t,
size: usize,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
extern "C" {
pub fn rmw_topic_endpoint_info_array_fini(
topic_endpoint_info_array: *mut rmw_topic_endpoint_info_array_t,
allocator: *mut rcutils_allocator_t,
) -> rmw_ret_t;
}
pub type rcl_names_and_types_t = rmw_names_and_types_t;
pub type rcl_topic_endpoint_info_t = rmw_topic_endpoint_info_t;
pub type rcl_topic_endpoint_info_array_t = rmw_topic_endpoint_info_array_t;
extern "C" {
pub fn rcl_get_publisher_names_and_types_by_node(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
no_demangle: bool,
node_name: *const ::std::os::raw::c_char,
node_namespace: *const ::std::os::raw::c_char,
topic_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_subscriber_names_and_types_by_node(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
no_demangle: bool,
node_name: *const ::std::os::raw::c_char,
node_namespace: *const ::std::os::raw::c_char,
topic_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_service_names_and_types_by_node(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
node_name: *const ::std::os::raw::c_char,
node_namespace: *const ::std::os::raw::c_char,
service_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_client_names_and_types_by_node(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
node_name: *const ::std::os::raw::c_char,
node_namespace: *const ::std::os::raw::c_char,
service_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_topic_names_and_types(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
no_demangle: bool,
topic_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_service_names_and_types(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
service_names_and_types: *mut rcl_names_and_types_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_names_and_types_init(
names_and_types: *mut rcl_names_and_types_t,
size: usize,
allocator: *mut rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_names_and_types_fini(names_and_types: *mut rcl_names_and_types_t) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_node_names(
node: *const rcl_node_t,
allocator: rcl_allocator_t,
node_names: *mut rcutils_string_array_t,
node_namespaces: *mut rcutils_string_array_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_node_names_with_enclaves(
node: *const rcl_node_t,
allocator: rcl_allocator_t,
node_names: *mut rcutils_string_array_t,
node_namespaces: *mut rcutils_string_array_t,
enclaves: *mut rcutils_string_array_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_count_publishers(
node: *const rcl_node_t,
topic_name: *const ::std::os::raw::c_char,
count: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_count_subscribers(
node: *const rcl_node_t,
topic_name: *const ::std::os::raw::c_char,
count: *mut usize,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_for_publishers(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
topic_name: *const ::std::os::raw::c_char,
count: usize,
timeout: rcutils_duration_value_t,
success: *mut bool,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_wait_for_subscribers(
node: *const rcl_node_t,
allocator: *mut rcl_allocator_t,
topic_name: *const ::std::os::raw::c_char,
count: usize,
timeout: rcutils_duration_value_t,
success: *mut bool,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_publishers_info_by_topic(
node: *const rcl_node_t,
allocator: *mut rcutils_allocator_t,
topic_name: *const ::std::os::raw::c_char,
no_mangle: bool,
publishers_info: *mut rcl_topic_endpoint_info_array_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_get_subscriptions_info_by_topic(
node: *const rcl_node_t,
allocator: *mut rcutils_allocator_t,
topic_name: *const ::std::os::raw::c_char,
no_mangle: bool,
subscriptions_info: *mut rcl_topic_endpoint_info_array_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_service_server_is_available(
node: *const rcl_node_t,
client: *const rcl_client_t,
is_available: *mut bool,
) -> rcl_ret_t;
}
pub type rcl_logging_output_handler_t = rcutils_logging_output_handler_t;
extern "C" {
pub fn rcl_logging_configure(
global_args: *const rcl_arguments_t,
allocator: *const rcl_allocator_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_logging_configure_with_output_handler(
global_args: *const rcl_arguments_t,
allocator: *const rcl_allocator_t,
output_handler: rcl_logging_output_handler_t,
) -> rcl_ret_t;
}
extern "C" {
pub fn rcl_logging_fini() -> rcl_ret_t;
}
extern "C" {
pub fn rcl_logging_rosout_enabled() -> bool;
}
extern "C" {
pub fn rcl_logging_multiple_output_handler(
location: *const rcutils_log_location_t,
severity: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
timestamp: rcutils_time_point_value_t,
format: *const ::std::os::raw::c_char,
args: *mut va_list,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__float__Sequence {
pub data: *mut f32,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__float__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__float__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__float__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__float__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__float__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__float__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__float__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__float__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__float__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__double__Sequence {
pub data: *mut f64,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__double__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__double__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__double__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__double__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__double__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__double__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__double__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__double__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__double__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__long_double__Sequence {
pub data: *mut u128,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__long_double__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__long_double__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__long_double__Sequence>(),
24usize,
concat!(
"Size of: ",
stringify!(rosidl_runtime_c__long_double__Sequence)
)
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__long_double__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__long_double__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__long_double__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__long_double__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__long_double__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__char__Sequence {
pub data: *mut ::std::os::raw::c_schar,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__char__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__char__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__char__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__char__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__char__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__char__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__char__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__char__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__char__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__wchar__Sequence {
pub data: *mut u16,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__wchar__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__wchar__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__wchar__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__wchar__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__wchar__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__wchar__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__wchar__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__wchar__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__wchar__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__boolean__Sequence {
pub data: *mut bool,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__boolean__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__boolean__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__boolean__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__boolean__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__boolean__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__boolean__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__boolean__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__boolean__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__boolean__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__octet__Sequence {
pub data: *mut u8,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__octet__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__octet__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__octet__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__octet__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__octet__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__octet__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__octet__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__octet__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__octet__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__uint8__Sequence {
pub data: *mut u8,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__uint8__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__uint8__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__uint8__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__uint8__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__uint8__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__uint8__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint8__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint8__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint8__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__int8__Sequence {
pub data: *mut i8,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__int8__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__int8__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__int8__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__int8__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__int8__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__int8__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int8__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int8__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int8__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__uint16__Sequence {
pub data: *mut u16,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__uint16__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__uint16__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__uint16__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__uint16__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__uint16__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__uint16__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint16__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint16__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint16__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__int16__Sequence {
pub data: *mut i16,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__int16__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__int16__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__int16__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__int16__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__int16__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__int16__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int16__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int16__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int16__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__uint32__Sequence {
pub data: *mut u32,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__uint32__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__uint32__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__uint32__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__uint32__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__uint32__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__uint32__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint32__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint32__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint32__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__int32__Sequence {
pub data: *mut i32,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__int32__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__int32__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__int32__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__int32__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__int32__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__int32__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int32__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int32__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int32__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__uint64__Sequence {
pub data: *mut u64,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__uint64__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__uint64__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__uint64__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__uint64__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__uint64__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__uint64__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint64__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint64__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__uint64__Sequence),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__int64__Sequence {
pub data: *mut i64,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__int64__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__int64__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__int64__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__int64__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__int64__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__int64__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int64__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int64__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__int64__Sequence),
"::",
stringify!(capacity)
)
);
}
pub type rosidl_runtime_c__bool__Sequence = rosidl_runtime_c__boolean__Sequence;
pub type rosidl_runtime_c__byte__Sequence = rosidl_runtime_c__octet__Sequence;
pub type rosidl_runtime_c__float32__Sequence = rosidl_runtime_c__float__Sequence;
pub type rosidl_runtime_c__float64__Sequence = rosidl_runtime_c__double__Sequence;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__String {
pub data: *mut ::std::os::raw::c_char,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__String() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__String> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__String>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__String))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__String>(),
8usize,
concat!("Alignment of ", stringify!(rosidl_runtime_c__String))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__String__Sequence {
pub data: *mut rosidl_runtime_c__String,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__String__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__String__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__String__Sequence>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__String__Sequence))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__String__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__String__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__String__Sequence),
"::",
stringify!(capacity)
)
);
}
extern "C" {
pub fn rosidl_runtime_c__String__init(str_: *mut rosidl_runtime_c__String) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__fini(str_: *mut rosidl_runtime_c__String);
}
extern "C" {
pub fn rosidl_runtime_c__String__copy(
input: *const rosidl_runtime_c__String,
output: *mut rosidl_runtime_c__String,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__are_equal(
lhs: *const rosidl_runtime_c__String,
rhs: *const rosidl_runtime_c__String,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__assignn(
str_: *mut rosidl_runtime_c__String,
value: *const ::std::os::raw::c_char,
n: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__assign(
str_: *mut rosidl_runtime_c__String,
value: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__init(
sequence: *mut rosidl_runtime_c__String__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__fini(
sequence: *mut rosidl_runtime_c__String__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__are_equal(
lhs: *const rosidl_runtime_c__String__Sequence,
rhs: *const rosidl_runtime_c__String__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__copy(
input: *const rosidl_runtime_c__String__Sequence,
output: *mut rosidl_runtime_c__String__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__create(
size: usize,
) -> *mut rosidl_runtime_c__String__Sequence;
}
extern "C" {
pub fn rosidl_runtime_c__String__Sequence__destroy(
sequence: *mut rosidl_runtime_c__String__Sequence,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__U16String {
pub data: *mut uint_least16_t,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__U16String() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__U16String> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__U16String>(),
24usize,
concat!("Size of: ", stringify!(rosidl_runtime_c__U16String))
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__U16String>(),
8usize,
concat!("Alignment of ", stringify!(rosidl_runtime_c__U16String))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String),
"::",
stringify!(capacity)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_runtime_c__U16String__Sequence {
pub data: *mut rosidl_runtime_c__U16String,
pub size: usize,
pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosidl_runtime_c__U16String__Sequence() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_runtime_c__U16String__Sequence> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_runtime_c__U16String__Sequence>(),
24usize,
concat!(
"Size of: ",
stringify!(rosidl_runtime_c__U16String__Sequence)
)
);
assert_eq!(
::std::mem::align_of::<rosidl_runtime_c__U16String__Sequence>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_runtime_c__U16String__Sequence)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String__Sequence),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String__Sequence),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_runtime_c__U16String__Sequence),
"::",
stringify!(capacity)
)
);
}
extern "C" {
pub fn rosidl_runtime_c__U16String__init(str_: *mut rosidl_runtime_c__U16String) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__fini(str_: *mut rosidl_runtime_c__U16String);
}
extern "C" {
pub fn rosidl_runtime_c__U16String__are_equal(
lhs: *const rosidl_runtime_c__U16String,
rhs: *const rosidl_runtime_c__U16String,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__copy(
input: *const rosidl_runtime_c__U16String,
output: *mut rosidl_runtime_c__U16String,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__assignn(
str_: *mut rosidl_runtime_c__U16String,
value: *const u16,
n: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__assignn_from_char(
str_: *mut rosidl_runtime_c__U16String,
value: *const ::std::os::raw::c_char,
n: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__assign(
str_: *mut rosidl_runtime_c__U16String,
value: *const u16,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__len(value: *const u16) -> usize;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__resize(
str_: *mut rosidl_runtime_c__U16String,
n: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__init(
sequence: *mut rosidl_runtime_c__U16String__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__fini(
sequence: *mut rosidl_runtime_c__U16String__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__are_equal(
lhs: *const rosidl_runtime_c__U16String__Sequence,
rhs: *const rosidl_runtime_c__U16String__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__copy(
input: *const rosidl_runtime_c__U16String__Sequence,
output: *mut rosidl_runtime_c__U16String__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__create(
size: usize,
) -> *mut rosidl_runtime_c__U16String__Sequence;
}
extern "C" {
pub fn rosidl_runtime_c__U16String__Sequence__destroy(
sequence: *mut rosidl_runtime_c__U16String__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__float__Sequence__init(
sequence: *mut rosidl_runtime_c__float__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float__Sequence__fini(
sequence: *mut rosidl_runtime_c__float__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__float__Sequence__are_equal(
lhs: *const rosidl_runtime_c__float__Sequence,
rhs: *const rosidl_runtime_c__float__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float__Sequence__copy(
input: *const rosidl_runtime_c__float__Sequence,
output: *mut rosidl_runtime_c__float__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__double__Sequence__init(
sequence: *mut rosidl_runtime_c__double__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__double__Sequence__fini(
sequence: *mut rosidl_runtime_c__double__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__double__Sequence__are_equal(
lhs: *const rosidl_runtime_c__double__Sequence,
rhs: *const rosidl_runtime_c__double__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__double__Sequence__copy(
input: *const rosidl_runtime_c__double__Sequence,
output: *mut rosidl_runtime_c__double__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__long_double__Sequence__init(
sequence: *mut rosidl_runtime_c__long_double__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__long_double__Sequence__fini(
sequence: *mut rosidl_runtime_c__long_double__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__long_double__Sequence__are_equal(
lhs: *const rosidl_runtime_c__long_double__Sequence,
rhs: *const rosidl_runtime_c__long_double__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__long_double__Sequence__copy(
input: *const rosidl_runtime_c__long_double__Sequence,
output: *mut rosidl_runtime_c__long_double__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__char__Sequence__init(
sequence: *mut rosidl_runtime_c__char__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__char__Sequence__fini(sequence: *mut rosidl_runtime_c__char__Sequence);
}
extern "C" {
pub fn rosidl_runtime_c__char__Sequence__are_equal(
lhs: *const rosidl_runtime_c__char__Sequence,
rhs: *const rosidl_runtime_c__char__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__char__Sequence__copy(
input: *const rosidl_runtime_c__char__Sequence,
output: *mut rosidl_runtime_c__char__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__wchar__Sequence__init(
sequence: *mut rosidl_runtime_c__wchar__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__wchar__Sequence__fini(
sequence: *mut rosidl_runtime_c__wchar__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__wchar__Sequence__are_equal(
lhs: *const rosidl_runtime_c__wchar__Sequence,
rhs: *const rosidl_runtime_c__wchar__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__wchar__Sequence__copy(
input: *const rosidl_runtime_c__wchar__Sequence,
output: *mut rosidl_runtime_c__wchar__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__boolean__Sequence__init(
sequence: *mut rosidl_runtime_c__boolean__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__boolean__Sequence__fini(
sequence: *mut rosidl_runtime_c__boolean__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__boolean__Sequence__are_equal(
lhs: *const rosidl_runtime_c__boolean__Sequence,
rhs: *const rosidl_runtime_c__boolean__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__boolean__Sequence__copy(
input: *const rosidl_runtime_c__boolean__Sequence,
output: *mut rosidl_runtime_c__boolean__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__octet__Sequence__init(
sequence: *mut rosidl_runtime_c__octet__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__octet__Sequence__fini(
sequence: *mut rosidl_runtime_c__octet__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__octet__Sequence__are_equal(
lhs: *const rosidl_runtime_c__octet__Sequence,
rhs: *const rosidl_runtime_c__octet__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__octet__Sequence__copy(
input: *const rosidl_runtime_c__octet__Sequence,
output: *mut rosidl_runtime_c__octet__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint8__Sequence__init(
sequence: *mut rosidl_runtime_c__uint8__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint8__Sequence__fini(
sequence: *mut rosidl_runtime_c__uint8__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__uint8__Sequence__are_equal(
lhs: *const rosidl_runtime_c__uint8__Sequence,
rhs: *const rosidl_runtime_c__uint8__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint8__Sequence__copy(
input: *const rosidl_runtime_c__uint8__Sequence,
output: *mut rosidl_runtime_c__uint8__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int8__Sequence__init(
sequence: *mut rosidl_runtime_c__int8__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int8__Sequence__fini(sequence: *mut rosidl_runtime_c__int8__Sequence);
}
extern "C" {
pub fn rosidl_runtime_c__int8__Sequence__are_equal(
lhs: *const rosidl_runtime_c__int8__Sequence,
rhs: *const rosidl_runtime_c__int8__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int8__Sequence__copy(
input: *const rosidl_runtime_c__int8__Sequence,
output: *mut rosidl_runtime_c__int8__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint16__Sequence__init(
sequence: *mut rosidl_runtime_c__uint16__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint16__Sequence__fini(
sequence: *mut rosidl_runtime_c__uint16__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__uint16__Sequence__are_equal(
lhs: *const rosidl_runtime_c__uint16__Sequence,
rhs: *const rosidl_runtime_c__uint16__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint16__Sequence__copy(
input: *const rosidl_runtime_c__uint16__Sequence,
output: *mut rosidl_runtime_c__uint16__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int16__Sequence__init(
sequence: *mut rosidl_runtime_c__int16__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int16__Sequence__fini(
sequence: *mut rosidl_runtime_c__int16__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__int16__Sequence__are_equal(
lhs: *const rosidl_runtime_c__int16__Sequence,
rhs: *const rosidl_runtime_c__int16__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int16__Sequence__copy(
input: *const rosidl_runtime_c__int16__Sequence,
output: *mut rosidl_runtime_c__int16__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint32__Sequence__init(
sequence: *mut rosidl_runtime_c__uint32__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint32__Sequence__fini(
sequence: *mut rosidl_runtime_c__uint32__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__uint32__Sequence__are_equal(
lhs: *const rosidl_runtime_c__uint32__Sequence,
rhs: *const rosidl_runtime_c__uint32__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint32__Sequence__copy(
input: *const rosidl_runtime_c__uint32__Sequence,
output: *mut rosidl_runtime_c__uint32__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int32__Sequence__init(
sequence: *mut rosidl_runtime_c__int32__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int32__Sequence__fini(
sequence: *mut rosidl_runtime_c__int32__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__int32__Sequence__are_equal(
lhs: *const rosidl_runtime_c__int32__Sequence,
rhs: *const rosidl_runtime_c__int32__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int32__Sequence__copy(
input: *const rosidl_runtime_c__int32__Sequence,
output: *mut rosidl_runtime_c__int32__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint64__Sequence__init(
sequence: *mut rosidl_runtime_c__uint64__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint64__Sequence__fini(
sequence: *mut rosidl_runtime_c__uint64__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__uint64__Sequence__are_equal(
lhs: *const rosidl_runtime_c__uint64__Sequence,
rhs: *const rosidl_runtime_c__uint64__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__uint64__Sequence__copy(
input: *const rosidl_runtime_c__uint64__Sequence,
output: *mut rosidl_runtime_c__uint64__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int64__Sequence__init(
sequence: *mut rosidl_runtime_c__int64__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int64__Sequence__fini(
sequence: *mut rosidl_runtime_c__int64__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__int64__Sequence__are_equal(
lhs: *const rosidl_runtime_c__int64__Sequence,
rhs: *const rosidl_runtime_c__int64__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__int64__Sequence__copy(
input: *const rosidl_runtime_c__int64__Sequence,
output: *mut rosidl_runtime_c__int64__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__bool__Sequence__init(
sequence: *mut rosidl_runtime_c__boolean__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__bool__Sequence__fini(
sequence: *mut rosidl_runtime_c__boolean__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__bool__Sequence__are_equal(
lhs: *const rosidl_runtime_c__boolean__Sequence,
rhs: *const rosidl_runtime_c__boolean__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__bool__Sequence__copy(
input: *const rosidl_runtime_c__boolean__Sequence,
output: *mut rosidl_runtime_c__boolean__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__byte__Sequence__init(
sequence: *mut rosidl_runtime_c__octet__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__byte__Sequence__fini(sequence: *mut rosidl_runtime_c__octet__Sequence);
}
extern "C" {
pub fn rosidl_runtime_c__byte__Sequence__are_equal(
lhs: *const rosidl_runtime_c__octet__Sequence,
rhs: *const rosidl_runtime_c__octet__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__byte__Sequence__copy(
input: *const rosidl_runtime_c__octet__Sequence,
output: *mut rosidl_runtime_c__octet__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float32__Sequence__init(
sequence: *mut rosidl_runtime_c__float__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float32__Sequence__fini(
sequence: *mut rosidl_runtime_c__float__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__float32__Sequence__are_equal(
lhs: *const rosidl_runtime_c__float__Sequence,
rhs: *const rosidl_runtime_c__float__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float32__Sequence__copy(
input: *const rosidl_runtime_c__float__Sequence,
output: *mut rosidl_runtime_c__float__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float64__Sequence__init(
sequence: *mut rosidl_runtime_c__double__Sequence,
size: usize,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float64__Sequence__fini(
sequence: *mut rosidl_runtime_c__double__Sequence,
);
}
extern "C" {
pub fn rosidl_runtime_c__float64__Sequence__are_equal(
lhs: *const rosidl_runtime_c__double__Sequence,
rhs: *const rosidl_runtime_c__double__Sequence,
) -> bool;
}
extern "C" {
pub fn rosidl_runtime_c__float64__Sequence__copy(
input: *const rosidl_runtime_c__double__Sequence,
output: *mut rosidl_runtime_c__double__Sequence,
) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_action_type_support_t {
pub goal_service_type_support: *const rosidl_service_type_support_t,
pub result_service_type_support: *const rosidl_service_type_support_t,
pub cancel_service_type_support: *const rosidl_service_type_support_t,
pub feedback_message_type_support: *const rosidl_message_type_support_t,
pub status_message_type_support: *const rosidl_message_type_support_t,
}
#[test]
fn bindgen_test_layout_rosidl_action_type_support_t() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_action_type_support_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_action_type_support_t>(),
40usize,
concat!("Size of: ", stringify!(rosidl_action_type_support_t))
);
assert_eq!(
::std::mem::align_of::<rosidl_action_type_support_t>(),
8usize,
concat!("Alignment of ", stringify!(rosidl_action_type_support_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).goal_service_type_support) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_action_type_support_t),
"::",
stringify!(goal_service_type_support)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).result_service_type_support) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_action_type_support_t),
"::",
stringify!(result_service_type_support)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cancel_service_type_support) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_action_type_support_t),
"::",
stringify!(cancel_service_type_support)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).feedback_message_type_support) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(rosidl_action_type_support_t),
"::",
stringify!(feedback_message_type_support)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).status_message_type_support) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rosidl_action_type_support_t),
"::",
stringify!(status_message_type_support)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum rosidl_runtime_c__message_initialization {
ROSIDL_RUNTIME_C_MSG_INIT_ALL = 0,
ROSIDL_RUNTIME_C_MSG_INIT_SKIP = 1,
ROSIDL_RUNTIME_C_MSG_INIT_ZERO = 2,
ROSIDL_RUNTIME_C_MSG_INIT_DEFAULTS_ONLY = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_typesupport_introspection_c__MessageMember {
pub name_: *const ::std::os::raw::c_char,
pub type_id_: u8,
pub string_upper_bound_: usize,
pub members_: *const rosidl_message_type_support_t,
pub is_array_: bool,
pub array_size_: usize,
pub is_upper_bound_: bool,
pub offset_: u32,
pub default_value_: *const ::std::os::raw::c_void,
pub size_function:
::std::option::Option<unsafe extern "C" fn(arg1: *const ::std::os::raw::c_void) -> usize>,
pub get_const_function: ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
index: usize,
) -> *const ::std::os::raw::c_void,
>,
pub get_function: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
index: usize,
) -> *mut ::std::os::raw::c_void,
>,
pub resize_function: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, size: usize) -> bool,
>,
}
#[test]
fn bindgen_test_layout_rosidl_typesupport_introspection_c__MessageMember() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_typesupport_introspection_c__MessageMember> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_typesupport_introspection_c__MessageMember>(),
96usize,
concat!(
"Size of: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember)
)
);
assert_eq!(
::std::mem::align_of::<rosidl_typesupport_introspection_c__MessageMember>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_typesupport_introspection_c__MessageMember)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(name_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_id_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(type_id_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_upper_bound_) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(string_upper_bound_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).members_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(members_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_array_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(is_array_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).array_size_) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(array_size_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_upper_bound_) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(is_upper_bound_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset_) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(offset_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_value_) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(default_value_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_function) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(size_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_const_function) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(get_const_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).get_function) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(get_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resize_function) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMember),
"::",
stringify!(resize_function)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct rosidl_typesupport_introspection_c__MessageMembers {
pub message_namespace_: *const ::std::os::raw::c_char,
pub message_name_: *const ::std::os::raw::c_char,
pub member_count_: u32,
pub size_of_: usize,
pub members_: *const rosidl_typesupport_introspection_c__MessageMember,
pub init_function: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: rosidl_runtime_c__message_initialization,
),
>,
pub fini_function:
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
}
#[test]
fn bindgen_test_layout_rosidl_typesupport_introspection_c__MessageMembers() {
const UNINIT: ::std::mem::MaybeUninit<rosidl_typesupport_introspection_c__MessageMembers> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rosidl_typesupport_introspection_c__MessageMembers>(),
56usize,
concat!(
"Size of: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers)
)
);
assert_eq!(
::std::mem::align_of::<rosidl_typesupport_introspection_c__MessageMembers>(),
8usize,
concat!(
"Alignment of ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message_namespace_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(message_namespace_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message_name_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(message_name_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).member_count_) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(member_count_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_of_) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(size_of_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).members_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(members_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).init_function) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(init_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fini_function) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rosidl_typesupport_introspection_c__MessageMembers),
"::",
stringify!(fini_function)
)
);
}
pub const rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_DOUBLE: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_DOUBLE;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_LONG_DOUBLE: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_LONG_DOUBLE;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_CHAR: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_CHAR;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_WCHAR: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_WCHAR;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_OCTET: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_OCTET;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_UINT8: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_UINT8;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_INT8: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_INT8;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_UINT16: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_UINT16;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_INT16: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_INT16;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_UINT32: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_UINT32;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_INT32: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_INT32;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_UINT64: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_UINT64;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_INT64: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_INT64;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_STRING: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_STRING;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_WSTRING: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_WSTRING;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT32: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT64: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_DOUBLE;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_BOOL: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN;
pub const rosidl_typesupport_introspection_c__ROS_TYPE_BYTE: _bindgen_ty_2 =
_bindgen_ty_2::rosidl_typesupport_introspection_c__ROS_TYPE_OCTET;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_2 {
rosidl_typesupport_introspection_c__ROS_TYPE_FLOAT = 1,
rosidl_typesupport_introspection_c__ROS_TYPE_DOUBLE = 2,
rosidl_typesupport_introspection_c__ROS_TYPE_LONG_DOUBLE = 3,
rosidl_typesupport_introspection_c__ROS_TYPE_CHAR = 4,
rosidl_typesupport_introspection_c__ROS_TYPE_WCHAR = 5,
rosidl_typesupport_introspection_c__ROS_TYPE_BOOLEAN = 6,
rosidl_typesupport_introspection_c__ROS_TYPE_OCTET = 7,
rosidl_typesupport_introspection_c__ROS_TYPE_UINT8 = 8,
rosidl_typesupport_introspection_c__ROS_TYPE_INT8 = 9,
rosidl_typesupport_introspection_c__ROS_TYPE_UINT16 = 10,
rosidl_typesupport_introspection_c__ROS_TYPE_INT16 = 11,
rosidl_typesupport_introspection_c__ROS_TYPE_UINT32 = 12,
rosidl_typesupport_introspection_c__ROS_TYPE_INT32 = 13,
rosidl_typesupport_introspection_c__ROS_TYPE_UINT64 = 14,
rosidl_typesupport_introspection_c__ROS_TYPE_INT64 = 15,
rosidl_typesupport_introspection_c__ROS_TYPE_STRING = 16,
rosidl_typesupport_introspection_c__ROS_TYPE_WSTRING = 17,
rosidl_typesupport_introspection_c__ROS_TYPE_MESSAGE = 18,
}
extern "C" {
pub fn rcl_yaml_node_struct_init(allocator: rcutils_allocator_t) -> *mut rcl_params_t;
}
extern "C" {
pub fn rcl_yaml_node_struct_init_with_capacity(
capacity: usize,
allocator: rcutils_allocator_t,
) -> *mut rcl_params_t;
}
extern "C" {
pub fn rcl_yaml_node_struct_reallocate(
params_st: *mut rcl_params_t,
new_capacity: usize,
allocator: rcutils_allocator_t,
) -> rcutils_ret_t;
}
extern "C" {
pub fn rcl_yaml_node_struct_copy(params_st: *const rcl_params_t) -> *mut rcl_params_t;
}
extern "C" {
pub fn rcl_yaml_node_struct_fini(params_st: *mut rcl_params_t);
}
extern "C" {
pub fn rcl_parse_yaml_file(
file_path: *const ::std::os::raw::c_char,
params_st: *mut rcl_params_t,
) -> bool;
}
extern "C" {
pub fn rcl_parse_yaml_value(
node_name: *const ::std::os::raw::c_char,
param_name: *const ::std::os::raw::c_char,
yaml_value: *const ::std::os::raw::c_char,
params_st: *mut rcl_params_t,
) -> bool;
}
extern "C" {
pub fn rcl_yaml_node_struct_get(
node_name: *const ::std::os::raw::c_char,
param_name: *const ::std::os::raw::c_char,
params_st: *mut rcl_params_t,
) -> *mut rcl_variant_t;
}
extern "C" {
pub fn rcl_yaml_node_struct_print(params_st: *const rcl_params_t);
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
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)
)
);
}
Reference in New Issue View Git Blame Copy Permalink