Add support for str and &[mut] str

Author: HadrienG2

src/lib.rs

@@ -345,6 +345,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 { }
 
@@ -489,26 +490,63 @@ array_abomonate!(30);
 array_abomonate!(31);
 array_abomonate!(32);
 
-unsafe impl<'bytes> Abomonation<'bytes> for String {
+unsafe impl<'target, 'bytes: 'target> Abomonation<'bytes> for &'target str {
     unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
         write.write_all(self.as_bytes())
     }
 
+    #[inline]
+    unsafe fn exhume(self_: NonNull<Self>, bytes: &'bytes mut [u8]) -> Option<&'bytes 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<'target, 'bytes: 'target> Abomonation<'bytes> for &'target mut str {
+    unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
+        <&str>::entomb(&self.as_ref(), write)
+    }
+
+    #[inline]
+    unsafe fn exhume(self_: NonNull<Self>, bytes: &'bytes mut [u8]) -> Option<&'bytes 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<'bytes> Abomonation<'bytes> for String {
+    unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()> {
+        <&str>::entomb(&self.as_ref(), write)
+    }
+
     #[inline]
     unsafe fn exhume(self_: NonNull<Self>, bytes: &'bytes mut [u8]) -> Option<&'bytes 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())
     }
 }
 
@@ -631,6 +669,15 @@ unsafe fn exhume_ref<'target, 'bytes: 'target, T: Abomonation<'bytes>>(bytes: &'
     }
 }
 
+// Common subset of "exhume" for all &str-like types
+unsafe fn exhume_str_ref<'target, 'bytes: 'target>(length: usize, bytes: &'bytes mut [u8]) -> Option<(&'target mut str, &'bytes 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

@@ -5,12 +5,13 @@ use std::fmt::Debug;
 
 // Test struct for the unsafe_abomonate macro
 #[derive(Clone, Debug, Eq, PartialEq)]
-struct MyStruct {
+struct MyStruct<'d> {
     a: String,
     b: u64,
     c: Vec<u8>,
+    d: &'d str,
 }
-unsafe_abomonate!(MyStruct : a, b, c);
+unsafe_abomonate!(MyStruct<'_> : a, b, c, d);
 
 // Test for PhantomData abomonation, which has no Abomonation bound
 struct NotAbomonatable;
@@ -75,7 +76,8 @@ gen_tests!{
 
     MyStruct{ a: "test".to_owned(),
               b: 0,
-              c: vec![0, 1, 2] } => (test_macro_pass,
+              c: vec![0, 1, 2],
+              d: &"grawwwwrr!" } => (test_macro_pass,
                                      test_macro_fail,
                                      test_macro_size),
 
@@ -86,6 +88,10 @@ gen_tests!{
     Some(&42u64) => (test_ref_u64_pass,
                      test_ref_u64_fail,
                      test_ref_u64_size),
+
+    &"grawwwwrr!" => (test_str_pass,
+                      test_str_fail,
+                      test_str_size),
 }
 
 fn _test_pass<'bytes, T: Abomonation<'bytes> + Debug + Eq>(