pub mod msg {
use super::super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Bool {
pub data: bool,
}
impl WrappedTypesupport for Bool {
type CStruct = std_msgs__msg__Bool;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Bool()
}
}
fn create_msg() -> *mut std_msgs__msg__Bool {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Bool__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Bool__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Bool) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Bool__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Bool__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Bool {
Bool { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Bool {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Bool>::new();
Bool::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Byte {
pub data: u8,
}
impl WrappedTypesupport for Byte {
type CStruct = std_msgs__msg__Byte;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Byte()
}
}
fn create_msg() -> *mut std_msgs__msg__Byte {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Byte__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Byte__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Byte) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Byte__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Byte__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Byte {
Byte { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Byte {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Byte>::new();
Byte::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct ByteMultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<u8>,
}
impl WrappedTypesupport for ByteMultiArray {
type CStruct = std_msgs__msg__ByteMultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__ByteMultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__ByteMultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__ByteMultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__ByteMultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__ByteMultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__ByteMultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__ByteMultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> ByteMultiArray {
ByteMultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for ByteMultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<ByteMultiArray>::new();
ByteMultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Char {
pub data: u8,
}
impl WrappedTypesupport for Char {
type CStruct = std_msgs__msg__Char;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Char()
}
}
fn create_msg() -> *mut std_msgs__msg__Char {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Char__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Char__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Char) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Char__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Char__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Char {
Char { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Char {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Char>::new();
Char::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct ColorRGBA {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
impl WrappedTypesupport for ColorRGBA {
type CStruct = std_msgs__msg__ColorRGBA;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__ColorRGBA()
}
}
fn create_msg() -> *mut std_msgs__msg__ColorRGBA {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__ColorRGBA__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__ColorRGBA__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__ColorRGBA) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__ColorRGBA__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__ColorRGBA__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> ColorRGBA {
ColorRGBA {
r: msg.r,
g: msg.g,
b: msg.b,
a: msg.a,
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.r = self.r;
msg.g = self.g;
msg.b = self.b;
msg.a = self.a;
}
}
impl Default for ColorRGBA {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<ColorRGBA>::new();
ColorRGBA::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Empty {}
impl WrappedTypesupport for Empty {
type CStruct = std_msgs__msg__Empty;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Empty()
}
}
fn create_msg() -> *mut std_msgs__msg__Empty {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Empty__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Empty__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Empty) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Empty__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Empty__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Empty {
Empty {}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {}
}
impl Default for Empty {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Empty>::new();
Empty::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Float32 {
pub data: f32,
}
impl WrappedTypesupport for Float32 {
type CStruct = std_msgs__msg__Float32;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float32()
}
}
fn create_msg() -> *mut std_msgs__msg__Float32 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Float32__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Float32__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Float32) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float32__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Float32__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Float32 {
Float32 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Float32 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Float32>::new();
Float32::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Float32MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<f32>,
}
impl WrappedTypesupport for Float32MultiArray {
type CStruct = std_msgs__msg__Float32MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float32MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Float32MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float32MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Float32MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Float32MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float32MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Float32MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Float32MultiArray {
Float32MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Float32MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Float32MultiArray>::new();
Float32MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Float64 {
pub data: f64,
}
impl WrappedTypesupport for Float64 {
type CStruct = std_msgs__msg__Float64;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float64()
}
}
fn create_msg() -> *mut std_msgs__msg__Float64 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Float64__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Float64__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Float64) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float64__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Float64__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Float64 {
Float64 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Float64 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Float64>::new();
Float64::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Float64MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<f64>,
}
impl WrappedTypesupport for Float64MultiArray {
type CStruct = std_msgs__msg__Float64MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float64MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Float64MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float64MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Float64MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Float64MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Float64MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Float64MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Float64MultiArray {
Float64MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Float64MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Float64MultiArray>::new();
Float64MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Header {
pub stamp: builtin_interfaces::msg::Time,
pub frame_id: std::string::String,
}
impl WrappedTypesupport for Header {
type CStruct = std_msgs__msg__Header;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Header()
}
}
fn create_msg() -> *mut std_msgs__msg__Header {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Header__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Header__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Header) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Header__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Header__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Header {
Header {
stamp: builtin_interfaces::msg::Time::from_native(&msg.stamp),
frame_id: msg.frame_id.to_str().to_owned(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.stamp.copy_to_native(&mut msg.stamp);
msg.frame_id.assign(&self.frame_id);
}
}
impl Default for Header {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Header>::new();
Header::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int16 {
pub data: i16,
}
impl WrappedTypesupport for Int16 {
type CStruct = std_msgs__msg__Int16;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int16()
}
}
fn create_msg() -> *mut std_msgs__msg__Int16 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Int16__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int16__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int16) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int16__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int16__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int16 {
Int16 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Int16 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int16>::new();
Int16::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int16MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<i16>,
}
impl WrappedTypesupport for Int16MultiArray {
type CStruct = std_msgs__msg__Int16MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int16MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Int16MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int16MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int16MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int16MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int16MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int16MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int16MultiArray {
Int16MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Int16MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int16MultiArray>::new();
Int16MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int32 {
pub data: i32,
}
impl WrappedTypesupport for Int32 {
type CStruct = std_msgs__msg__Int32;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int32()
}
}
fn create_msg() -> *mut std_msgs__msg__Int32 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Int32__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int32__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int32) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int32__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int32__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int32 {
Int32 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Int32 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int32>::new();
Int32::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int32MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<i32>,
}
impl WrappedTypesupport for Int32MultiArray {
type CStruct = std_msgs__msg__Int32MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int32MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Int32MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int32MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int32MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int32MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int32MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int32MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int32MultiArray {
Int32MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Int32MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int32MultiArray>::new();
Int32MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int64 {
pub data: i64,
}
impl WrappedTypesupport for Int64 {
type CStruct = std_msgs__msg__Int64;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int64()
}
}
fn create_msg() -> *mut std_msgs__msg__Int64 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Int64__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int64__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int64) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int64__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int64__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int64 {
Int64 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Int64 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int64>::new();
Int64::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int64MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<i64>,
}
impl WrappedTypesupport for Int64MultiArray {
type CStruct = std_msgs__msg__Int64MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int64MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Int64MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int64MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int64MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int64MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int64MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int64MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int64MultiArray {
Int64MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Int64MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int64MultiArray>::new();
Int64MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int8 {
pub data: i8,
}
impl WrappedTypesupport for Int8 {
type CStruct = std_msgs__msg__Int8;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int8()
}
}
fn create_msg() -> *mut std_msgs__msg__Int8 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__Int8__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int8__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int8) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int8__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int8__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int8 {
Int8 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for Int8 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int8>::new();
Int8::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct Int8MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<i8>,
}
impl WrappedTypesupport for Int8MultiArray {
type CStruct = std_msgs__msg__Int8MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int8MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__Int8MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int8MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__Int8MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__Int8MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__Int8MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__Int8MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> Int8MultiArray {
Int8MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for Int8MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<Int8MultiArray>::new();
Int8MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct MultiArrayDimension {
pub label: std::string::String,
pub size: u32,
pub stride: u32,
}
impl WrappedTypesupport for MultiArrayDimension {
type CStruct = std_msgs__msg__MultiArrayDimension;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__MultiArrayDimension()
}
}
fn create_msg() -> *mut std_msgs__msg__MultiArrayDimension {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__MultiArrayDimension__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__MultiArrayDimension__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__MultiArrayDimension) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__MultiArrayDimension__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__MultiArrayDimension__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> MultiArrayDimension {
MultiArrayDimension {
label: msg.label.to_str().to_owned(),
size: msg.size,
stride: msg.stride,
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.label.assign(&self.label);
msg.size = self.size;
msg.stride = self.stride;
}
}
impl Default for MultiArrayDimension {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<MultiArrayDimension>::new();
MultiArrayDimension::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct MultiArrayLayout {
pub dim: Vec<std_msgs::msg::MultiArrayDimension>,
pub data_offset: u32,
}
impl WrappedTypesupport for MultiArrayLayout {
type CStruct = std_msgs__msg__MultiArrayLayout;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__MultiArrayLayout()
}
}
fn create_msg() -> *mut std_msgs__msg__MultiArrayLayout {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__MultiArrayLayout__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__MultiArrayLayout__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__MultiArrayLayout) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__MultiArrayLayout__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__MultiArrayLayout__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> MultiArrayLayout {
MultiArrayLayout {
dim: {
let mut temp = Vec::with_capacity(msg.dim.size);
let slice = unsafe {
std::slice::from_raw_parts(msg.dim.data, msg.dim.size)
};
for s in slice {
temp.push(std_msgs::msg::MultiArrayDimension::from_native(s));
}
temp
},
data_offset: msg.data_offset,
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
unsafe {
std_msgs__msg__MultiArrayDimension__Sequence__fini(&mut msg.dim);
std_msgs__msg__MultiArrayDimension__Sequence__init(
&mut msg.dim,
self.dim.len(),
);
let slice = std::slice::from_raw_parts_mut(msg.dim.data, msg.dim.size);
for (t, s) in slice.iter_mut().zip(&self.dim) {
s.copy_to_native(t);
}
}
msg.data_offset = self.data_offset;
}
}
impl Default for MultiArrayLayout {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<MultiArrayLayout>::new();
MultiArrayLayout::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct String {
pub data: std::string::String,
}
impl WrappedTypesupport for String {
type CStruct = std_msgs__msg__String;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__String()
}
}
fn create_msg() -> *mut std_msgs__msg__String {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__String__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__String__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__String) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__String__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__String__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> String {
String {
data: msg.data.to_str().to_owned(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data.assign(&self.data);
}
}
impl Default for String {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<String>::new();
String::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt16 {
pub data: u16,
}
impl WrappedTypesupport for UInt16 {
type CStruct = std_msgs__msg__UInt16;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt16()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt16 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__UInt16__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt16__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt16) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt16__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt16__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt16 {
UInt16 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for UInt16 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt16>::new();
UInt16::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt16MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<u16>,
}
impl WrappedTypesupport for UInt16MultiArray {
type CStruct = std_msgs__msg__UInt16MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt16MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt16MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt16MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt16MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt16MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt16MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt16MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt16MultiArray {
UInt16MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for UInt16MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt16MultiArray>::new();
UInt16MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt32 {
pub data: u32,
}
impl WrappedTypesupport for UInt32 {
type CStruct = std_msgs__msg__UInt32;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt32()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt32 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__UInt32__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt32__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt32) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt32__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt32__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt32 {
UInt32 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for UInt32 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt32>::new();
UInt32::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt32MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<u32>,
}
impl WrappedTypesupport for UInt32MultiArray {
type CStruct = std_msgs__msg__UInt32MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt32MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt32MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt32MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt32MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt32MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt32MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt32MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt32MultiArray {
UInt32MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for UInt32MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt32MultiArray>::new();
UInt32MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt64 {
pub data: u64,
}
impl WrappedTypesupport for UInt64 {
type CStruct = std_msgs__msg__UInt64;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt64()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt64 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__UInt64__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt64__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt64) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt64__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt64__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt64 {
UInt64 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for UInt64 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt64>::new();
UInt64::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt64MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<u64>,
}
impl WrappedTypesupport for UInt64MultiArray {
type CStruct = std_msgs__msg__UInt64MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt64MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt64MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt64MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt64MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt64MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt64MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt64MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt64MultiArray {
UInt64MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for UInt64MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt64MultiArray>::new();
UInt64MultiArray::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt8 {
pub data: u8,
}
impl WrappedTypesupport for UInt8 {
type CStruct = std_msgs__msg__UInt8;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt8()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt8 {
#[cfg(not(feature = "doc-only"))] unsafe { std_msgs__msg__UInt8__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt8__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt8) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt8__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt8__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt8 {
UInt8 { data: msg.data }
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
msg.data = self.data;
}
}
impl Default for UInt8 {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt8>::new();
UInt8::from_native(&msg_native)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct UInt8MultiArray {
pub layout: std_msgs::msg::MultiArrayLayout,
pub data: Vec<u8>,
}
impl WrappedTypesupport for UInt8MultiArray {
type CStruct = std_msgs__msg__UInt8MultiArray;
fn get_ts() -> &'static rosidl_message_type_support_t {
unsafe {
&*rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt8MultiArray()
}
}
fn create_msg() -> *mut std_msgs__msg__UInt8MultiArray {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt8MultiArray__create() }
#[cfg(feature = "doc-only")] std_msgs__msg__UInt8MultiArray__create()
}
fn destroy_msg(msg: *mut std_msgs__msg__UInt8MultiArray) -> () {
#[cfg(not(feature = "doc-only"))]
unsafe { std_msgs__msg__UInt8MultiArray__destroy(msg) };
#[cfg(feature = "doc-only")] std_msgs__msg__UInt8MultiArray__destroy(msg)
}
fn from_native(#[allow(unused)] msg: &Self::CStruct) -> UInt8MultiArray {
UInt8MultiArray {
layout: std_msgs::msg::MultiArrayLayout::from_native(&msg.layout),
data: msg.data.to_vec(),
}
}
fn copy_to_native(&self, #[allow(unused)] msg: &mut Self::CStruct) {
self.layout.copy_to_native(&mut msg.layout);
msg.data.update(&self.data);
}
}
impl Default for UInt8MultiArray {
fn default() -> Self {
let msg_native = WrappedNativeMsg::<UInt8MultiArray>::new();
UInt8MultiArray::from_native(&msg_native)
}
}
}