Add support for str and &[mut] str

Author: HadrienG2

src/lib.rs

@@ -336,6 +336,7 @@ unsafe impl Abomonation for bool { }
 unsafe impl Abomonation for () { }
 
 unsafe impl Abomonation for char { }
+unsafe impl Abomonation for str { }
 
 unsafe impl Abomonation for ::std::time::Duration { }
 
@@ -480,26 +481,63 @@ array_abomonate!(30);
 array_abomonate!(31);
 array_abomonate!(32);
 
-unsafe impl Abomonation for String {
+unsafe impl Abomonation for &'_ str {
     unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
         write.write_all(self.as_bytes())
     }
 
+    #[inline]
+    unsafe fn exhume<'a>(self_: NonNull<Self>, bytes: &'a mut [u8]) -> Option<&'a mut [u8]> {
+        // FIXME: This (briefly) constructs an &str to invalid data, which is UB.
+        //        I'm not sure if this can be fully resolved without relying on &str implementation details.
+        let self_len = self_.as_ref().len();
+        let (s, rest) = exhume_str_ref(self_len, bytes)?;
+        self_.as_ptr().write(s);
+        Some(rest)
+    }
+
+    fn extent(&self) -> usize {
+        self.len()
+    }
+}
+
+unsafe impl Abomonation for &'_ mut str {
+    unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
+        <&str>::entomb(&self.as_ref(), write)
+    }
+
+    #[inline]
+    unsafe fn exhume<'a>(self_: NonNull<Self>, bytes: &'a mut [u8]) -> Option<&'a mut [u8]> {
+        // FIXME: This (briefly) constructs an &mut str to invalid data, which is UB.
+        //        I'm not sure if this can be fully resolved without relying on &str implementation details.
+        let self_len = self_.as_ref().len();
+        let (s, rest) = exhume_str_ref(self_len, bytes)?;
+        self_.as_ptr().write(s);
+        Some(rest)
+    }
+
+    fn extent(&self) -> usize {
+        <&str>::extent(&self.as_ref())
+    }
+}
+
+unsafe impl Abomonation for String {
+    unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
+        <&str>::entomb(&self.as_ref(), write)
+    }
+
     #[inline]
     unsafe fn exhume<'a>(self_: NonNull<Self>, bytes: &'a mut [u8]) -> Option<&'a mut [u8]> {
         // FIXME: This (briefly) constructs an &String to invalid data, which is UB.
         //        I'm not sure if this can be fully resolved without relying on String implementation details.
         let self_len = self_.as_ref().len();
-        if self_len > bytes.len() { None }
-        else {
-            let (mine, rest) = bytes.split_at_mut(self_len);
-            self_.as_ptr().write(String::from_raw_parts(mine.as_mut_ptr(), self_len, self_len));
-            Some(rest)
-        }
+        let (s, rest) = exhume_str_ref(self_len, bytes)?;
+        self_.as_ptr().write(String::from_raw_parts(s.as_mut_ptr(), s.len(), s.len()));
+        Some(rest)
     }
 
     fn extent(&self) -> usize {
-        self.len()
+        <&str>::extent(&self.as_ref())
     }
 }
 
@@ -618,6 +656,15 @@ unsafe fn exhume_ptr<'a, T: Abomonation>(bytes: &'a mut [u8]) -> Option<(NonNull
     }
 }
 
+// Common subset of "exhume" for all &str-like types
+unsafe fn exhume_str_ref<'a>(length: usize, bytes: &'a mut [u8]) -> Option<(&'a mut str, &'a mut [u8])> {
+    if length > bytes.len() { None }
+    else {
+        let (mine, rest) = bytes.split_at_mut(length);
+        Some((std::str::from_utf8_unchecked_mut(mine), rest))
+    }
+}
+
 mod network {
     use Abomonation;
     use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6, IpAddr, Ipv4Addr, Ipv6Addr};

tests/tests.rs

@@ -16,12 +16,14 @@ use std::fmt::Debug;
 #[test] fn test_string_pass() { _test_pass(vec![format!("grawwwwrr!"); 1024]); }
 #[test] fn test_vec_u_s_pass() { _test_pass(vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
 #[test] fn test_ref_u64_pass() { _test_pass(vec![Some(&42u64); 1024]); }
+#[test] fn test_str_pass() { _test_pass(vec![&"grawwwwrr!"; 1024]); }
 
 #[test] fn test_u64_fail() { _test_fail(vec![0u64; 1024]); }
 #[test] fn test_u128_fail() { _test_fail(vec![0u128; 1024]); }
 #[test] fn test_string_fail() { _test_fail(vec![format!("grawwwwrr!"); 1024]); }
 #[test] fn test_vec_u_s_fail() { _test_fail(vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
 #[test] fn test_ref_u64_fail() { _test_fail(vec![Some(&42u64); 1024]); }
+#[test] fn test_str_fail() { _test_fail(vec![&"grawwwwrr!"; 1024]); }
 
 #[test] fn test_array_size() { _test_size(vec![[0, 1, 2]; 1024]); }
 #[test] fn test_opt_vec_size() { _test_size(vec![Some(vec![0,1,2]), None]); }
@@ -34,6 +36,7 @@ use std::fmt::Debug;
 #[test] fn test_string_size() { _test_size(vec![format!("grawwwwrr!"); 1024]); }
 #[test] fn test_vec_u_s_size() { _test_size(vec![vec![(0u64, format!("grawwwwrr!")); 32]; 32]); }
 #[test] fn test_ref_u64_size() { _test_size(vec![Some(&42u64); 1024]); }
+#[test] fn test_str_size() { _test_size(vec![&"grawwwwrr!"; 1024]); }
 
 #[test]
 fn test_phantom_data_for_non_abomonatable_type() {
@@ -67,18 +70,19 @@ fn _test_size<T: Abomonation>(record: T) {
 
 
 #[derive(Debug, Eq, PartialEq)]
-struct MyStruct {
+struct MyStruct<'a> {
     a: String,
     b: u64,
     c: Vec<u8>,
+    d: &'a str,
 }
 
-unsafe_abomonate!(MyStruct : a, b, c);
+unsafe_abomonate!(MyStruct<'_> : a, b, c, d);
 
 #[test]
 fn test_macro() {
     // create some test data out of abomonation-approved types
-    let record = MyStruct{ a: "test".to_owned(), b: 0, c: vec![0, 1, 2] };
+    let record = MyStruct{ a: "test".to_owned(), b: 0, c: vec![0, 1, 2], d: &"grawwwwrr!" };
 
     // encode vector into a Vec<u8>
     let mut bytes = Vec::new();
@@ -94,7 +98,7 @@ fn test_macro() {
 #[test]
 fn test_macro_size() {
     // create some test data out of abomonation-approved types
-    let record = MyStruct{ a: "test".to_owned(), b: 0, c: vec![0, 1, 2] };
+    let record = MyStruct{ a: "test".to_owned(), b: 0, c: vec![0, 1, 2], d: &"grawwwwrr!" };
 
     // encode vector into a Vec<u8>
     let mut bytes = Vec::new();