Add wrapper for char arrays to access str conveniently

This adds a wrapper around char arrays that allows
to access them either as slices or as strings. When
accessing the string representation, it will automatically
convert the char array to a string slice up to the first null byte.

Author: azerupi

mavlink-bindgen/src/parser.rs

@@ -188,7 +188,7 @@ impl MavProfile {
             #[allow(unused_imports)]
             use bitflags::bitflags;
 
-            use mavlink_core::{MavlinkVersion, Message, MessageData, bytes::Bytes, bytes_mut::BytesMut};
+            use mavlink_core::{MavlinkVersion, Message, MessageData, bytes::Bytes, bytes_mut::BytesMut, types::CharArray};
 
             #[cfg(feature = "serde")]
             use serde::{Serialize, Deserialize};
@@ -948,6 +948,7 @@ pub enum MavType {
     Char,
     Float,
     Double,
+    CharArray(usize),
     Array(Box<MavType>, usize),
 }
 
@@ -968,16 +969,18 @@ impl MavType {
             "float" => Some(Float),
             "Double" => Some(Double),
             "double" => Some(Double),
-            _ => {
-                if s.ends_with(']') {
-                    let start = s.find('[')?;
-                    let size = s[start + 1..(s.len() - 1)].parse::<usize>().ok()?;
-                    let mtype = Self::parse_type(&s[0..start])?;
-                    Some(Array(Box::new(mtype), size))
-                } else {
-                    None
-                }
+            _ if s.starts_with("char[") => {
+                let start = s.find('[')?;
+                let size = s[start + 1..(s.len() - 1)].parse::<usize>().ok()?;
+                Some(CharArray(size))
             }
+            _ if s.ends_with(']') => {
+                let start = s.find('[')?;
+                let size = s[start + 1..(s.len() - 1)].parse::<usize>().ok()?;
+                let mtype = Self::parse_type(&s[0..start])?;
+                Some(Array(Box::new(mtype), size))
+            }
+            _ => None,
         }
     }
 
@@ -997,6 +1000,15 @@ impl MavType {
             Int64 => quote! {#val = #buf.get_i64_le();},
             Float => quote! {#val = #buf.get_f32_le();},
             Double => quote! {#val = #buf.get_f64_le();},
+            CharArray(size) => {
+                quote! {
+                    let mut tmp = [0_u8; #size];
+                    for v in &mut tmp {
+                        *v = #buf.get_u8();
+                    }
+                    #val = CharArray::new(tmp);
+                }
+            }
             Array(t, _) => {
                 let r = t.rust_reader(&quote!(let val), buf);
                 quote! {
@@ -1025,6 +1037,14 @@ impl MavType {
             UInt64 => quote! {#buf.put_u64_le(#val);},
             Int64 => quote! {#buf.put_i64_le(#val);},
             Double => quote! {#buf.put_f64_le(#val);},
+            CharArray(_) => {
+                let w = Char.rust_writer(&quote!(*val), buf);
+                quote! {
+                    for val in &#val {
+                        #w
+                    }
+                }
+            }
             Array(t, _size) => {
                 let w = t.rust_writer(&quote!(*val), buf);
                 quote! {
@@ -1044,6 +1064,7 @@ impl MavType {
             UInt16 | Int16 => 2,
             UInt32 | Int32 | Float => 4,
             UInt64 | Int64 | Double => 8,
+            CharArray(size) => *size,
             Array(t, size) => t.len() * size,
         }
     }
@@ -1052,7 +1073,7 @@ impl MavType {
     fn order_len(&self) -> usize {
         use self::MavType::*;
         match self {
-            UInt8MavlinkVersion | UInt8 | Int8 | Char => 1,
+            UInt8MavlinkVersion | UInt8 | Int8 | Char | CharArray(_) => 1,
             UInt16 | Int16 => 2,
             UInt32 | Int32 | Float => 4,
             UInt64 | Int64 | Double => 8,
@@ -1076,6 +1097,7 @@ impl MavType {
             UInt64 => "uint64_t".into(),
             Int64 => "int64_t".into(),
             Double => "double".into(),
+            CharArray(_) => "char".into(),
             Array(t, _) => t.primitive_type(),
         }
     }
@@ -1096,6 +1118,7 @@ impl MavType {
             UInt64 => "u64".into(),
             Int64 => "i64".into(),
             Double => "f64".into(),
+            CharArray(size) => format!("CharArray<{}>", size),
             Array(t, size) => format!("[{};{}]", t.rust_type(), size),
         }
     }
@@ -1114,6 +1137,7 @@ impl MavType {
             UInt64 => quote!(0_u64),
             Int64 => quote!(0_i64),
             Double => quote!(0.0_f64),
+            CharArray(size) => quote!(CharArray::new([0_u8; #size])),
             Array(ty, size) => {
                 let default_value = ty.emit_default_value();
                 quote!([#default_value; #size])
@@ -1564,7 +1588,7 @@ pub fn extra_crc(msg: &MavMessage) -> u8 {
             crc.digest(field.name.as_bytes());
         }
         crc.digest(b" ");
-        if let MavType::Array(_, size) = field.mavtype {
+        if let MavType::Array(_, size) | MavType::CharArray(size) = field.mavtype {
             crc.digest(&[size as u8]);
         }
     }

mavlink-bindgen/tests/snapshots/[email protected]

@@ -9,7 +9,9 @@ expression: contents
 use arbitrary::Arbitrary;
 #[allow(unused_imports)]
 use bitflags::bitflags;
-use mavlink_core::{bytes::Bytes, bytes_mut::BytesMut, MavlinkVersion, Message, MessageData};
+use mavlink_core::{
+    bytes::Bytes, bytes_mut::BytesMut, types::CharArray, MavlinkVersion, Message, MessageData,
+};
 #[allow(unused_imports)]
 use num_derive::FromPrimitive;
 #[allow(unused_imports)]

mavlink-bindgen/tests/snapshots/[email protected]

@@ -9,7 +9,9 @@ expression: contents
 use arbitrary::Arbitrary;
 #[allow(unused_imports)]
 use bitflags::bitflags;
-use mavlink_core::{bytes::Bytes, bytes_mut::BytesMut, MavlinkVersion, Message, MessageData};
+use mavlink_core::{
+    bytes::Bytes, bytes_mut::BytesMut, types::CharArray, MavlinkVersion, Message, MessageData,
+};
 #[allow(unused_imports)]
 use num_derive::FromPrimitive;
 #[allow(unused_imports)]
@@ -123,16 +125,15 @@ pub struct PARAM_REQUEST_READ_DATA {
     pub param_index: i16,
     pub target_system: u8,
     pub target_component: u8,
-    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
-    pub param_id: [u8; 16],
+    pub param_id: CharArray<16>,
 }
 impl PARAM_REQUEST_READ_DATA {
     pub const ENCODED_LEN: usize = 20usize;
     pub const DEFAULT: Self = Self {
         param_index: 0_i16,
         target_system: 0_u8,
         target_component: 0_u8,
-        param_id: [0_u8; 16usize],
+        param_id: CharArray::new([0_u8; 16usize]),
     };
     #[cfg(feature = "arbitrary")]
     pub fn random<R: rand::RngCore>(rng: &mut R) -> Self {
@@ -170,10 +171,11 @@ impl MessageData for PARAM_REQUEST_READ_DATA {
         __struct.param_index = buf.get_i16_le();
         __struct.target_system = buf.get_u8();
         __struct.target_component = buf.get_u8();
-        for v in &mut __struct.param_id {
-            let val = buf.get_u8();
-            *v = val;
+        let mut tmp = [0_u8; 16usize];
+        for v in &mut tmp {
+            *v = buf.get_u8();
         }
+        __struct.param_id = CharArray::new(tmp);
         Ok(__struct)
     }
     fn ser(&self, version: MavlinkVersion, bytes: &mut [u8]) -> usize {
@@ -208,8 +210,7 @@ pub struct PARAM_SET_DATA {
     pub param_value: f32,
     pub target_system: u8,
     pub target_component: u8,
-    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
-    pub param_id: [u8; 16],
+    pub param_id: CharArray<16>,
     pub param_type: MavParamType,
 }
 impl PARAM_SET_DATA {
@@ -218,7 +219,7 @@ impl PARAM_SET_DATA {
         param_value: 0.0_f32,
         target_system: 0_u8,
         target_component: 0_u8,
-        param_id: [0_u8; 16usize],
+        param_id: CharArray::new([0_u8; 16usize]),
         param_type: MavParamType::DEFAULT,
     };
     #[cfg(feature = "arbitrary")]
@@ -257,10 +258,11 @@ impl MessageData for PARAM_SET_DATA {
         __struct.param_value = buf.get_f32_le();
         __struct.target_system = buf.get_u8();
         __struct.target_component = buf.get_u8();
-        for v in &mut __struct.param_id {
-            let val = buf.get_u8();
-            *v = val;
+        let mut tmp = [0_u8; 16usize];
+        for v in &mut tmp {
+            *v = buf.get_u8();
         }
+        __struct.param_id = CharArray::new(tmp);
         let tmp = buf.get_u8();
         __struct.param_type =
             FromPrimitive::from_u8(tmp).ok_or(::mavlink_core::error::ParserError::InvalidEnum {
@@ -302,8 +304,7 @@ pub struct PARAM_VALUE_DATA {
     pub param_value: f32,
     pub param_count: u16,
     pub param_index: u16,
-    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
-    pub param_id: [u8; 16],
+    pub param_id: CharArray<16>,
     pub param_type: MavParamType,
 }
 impl PARAM_VALUE_DATA {
@@ -312,7 +313,7 @@ impl PARAM_VALUE_DATA {
         param_value: 0.0_f32,
         param_count: 0_u16,
         param_index: 0_u16,
-        param_id: [0_u8; 16usize],
+        param_id: CharArray::new([0_u8; 16usize]),
         param_type: MavParamType::DEFAULT,
     };
     #[cfg(feature = "arbitrary")]
@@ -351,10 +352,11 @@ impl MessageData for PARAM_VALUE_DATA {
         __struct.param_value = buf.get_f32_le();
         __struct.param_count = buf.get_u16_le();
         __struct.param_index = buf.get_u16_le();
-        for v in &mut __struct.param_id {
-            let val = buf.get_u8();
-            *v = val;
+        let mut tmp = [0_u8; 16usize];
+        for v in &mut tmp {
+            *v = buf.get_u8();
         }
+        __struct.param_id = CharArray::new(tmp);
         let tmp = buf.get_u8();
         __struct.param_type =
             FromPrimitive::from_u8(tmp).ok_or(::mavlink_core::error::ParserError::InvalidEnum {

mavlink-core/src/lib.rs

@@ -48,6 +48,7 @@ pub mod bytes_mut;
 #[cfg(feature = "std")]
 mod connection;
 pub mod error;
+pub mod types;
 #[cfg(feature = "std")]
 pub use self::connection::{connect, Connectable, MavConnection};
 

mavlink-core/src/types.rs

@@ -0,0 +1,140 @@
+use core::ops::{Deref, DerefMut};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+
+/// Abstraction around a byte array that represents a string.
+///
+/// MAVLink encodes strings as C char arrays and the handling is field dependent.
+/// This abstration allows to choose if one wants to handle the field as
+/// a raw byte array or if one wants the convenience of a str that stops at the first null byte.
+///
+/// # Example
+/// ```
+/// use mavlink_core::types::CharArray;
+///
+/// let data = [0x48, 0x45, 0x4c, 0x4c, 0x4f, 0x00, 0x57, 0x4f, 0x52, 0x4c, 0x44, 0x00, 0x00, 0x00];
+/// let ca = CharArray::new(data);
+/// assert_eq!(ca.to_str(), "HELLO");
+/// ```
+#[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct CharArray<const N: usize> {
+    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
+    data: [u8; N],
+
+    #[cfg_attr(feature = "serde", serde(skip))]
+    str_len: usize,
+}
+
+impl<const N: usize> CharArray<N> {
+    pub const fn new(data: [u8; N]) -> Self {
+        // Note: The generated code uses this in const contexts, so this is a const fn
+        // and so we can't use iterators or other fancy stuff unfortunately.
+        let mut first_null = N;
+        let mut i = 0;
+        loop {
+            if i >= N {
+                break;
+            }
+            if data[i] == 0 {
+                first_null = i;
+                break;
+            }
+            i += 1;
+        }
+        Self {
+            data,
+            str_len: first_null,
+        }
+    }
+
+    /// Get the string representation of the char array.
+    /// Returns the string stopping at the first null byte and if the string is not valid utf8
+    /// the returned string will be empty.
+    pub fn to_str(&self) -> &str {
+        std::str::from_utf8(&self.data[..self.str_len]).unwrap_or("")
+    }
+}
+
+impl<const N: usize> Deref for CharArray<N> {
+    type Target = [u8; N];
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<const N: usize> DerefMut for CharArray<N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl<'a, const N: usize> IntoIterator for &'a CharArray<N> {
+    type Item = &'a u8;
+    type IntoIter = core::slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.data.iter()
+    }
+}
+
+impl<const N: usize> From<[u8; N]> for CharArray<N> {
+    fn from(data: [u8; N]) -> Self {
+        Self::new(data)
+    }
+}
+
+impl<const N: usize> From<CharArray<N>> for [u8; N] {
+    fn from(value: CharArray<N>) -> Self {
+        value.data
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, const N: usize> Deserialize<'de> for CharArray<N> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data: [u8; N] = serde_arrays::deserialize(deserializer)?;
+        Ok(Self::new(data))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a, const N: usize> Arbitrary<'a> for CharArray<N> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let mut data = [0u8; N];
+        u.fill_buffer(&mut data)?;
+        Ok(CharArray::new(data))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CharArray;
+
+    #[test]
+    fn char_array_to_str_handles_no_nulls() {
+        let data = *b"HELLOWORLD";
+        let ca = CharArray::new(data);
+        assert_eq!(ca.len(), 10);
+        assert_eq!(ca.to_str(), "HELLOWORLD");
+    }
+
+    #[test]
+    fn char_array_to_str_trims_after_first_null() {
+        let mut data = [0u8; 10];
+        data[..3].copy_from_slice(b"abc");
+        // data[3..] are zeros
+        let ca = CharArray::new(data);
+        assert_eq!(ca.len(), 10);
+        assert_eq!(ca.to_str(), "abc");
+    }
+}