Minor improvements to OwnedBytes

ownedbytes/src/lib.rs

@@ -1,7 +1,7 @@
 use std::convert::TryInto;
 use std::ops::{Deref, Range};
 use std::sync::Arc;
-use std::{fmt, io, mem};
+use std::{fmt, io};
 
 pub use stable_deref_trait::StableDeref;
 
@@ -26,8 +26,8 @@ impl OwnedBytes {
         data_holder: T,
     ) -> OwnedBytes {
         let box_stable_deref = Arc::new(data_holder);
-        let bytes: &[u8] = box_stable_deref.as_ref();
-        let data = unsafe { mem::transmute::<_, &'static [u8]>(bytes.deref()) };
+        let bytes: &[u8] = box_stable_deref.deref();
+        let data = unsafe { &*(bytes as *const [u8]) };
         OwnedBytes {
             data,
             box_stable_deref,
@@ -57,6 +57,12 @@ impl OwnedBytes {
         self.data.len()
     }
 
+    /// Returns true iff this `OwnedBytes` is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
     /// Splits the OwnedBytes into two OwnedBytes `(left, right)`.
     ///
     /// Left will hold `split_len` bytes.
@@ -68,13 +74,14 @@ impl OwnedBytes {
     #[inline]
     #[must_use]
     pub fn split(self, split_len: usize) -> (OwnedBytes, OwnedBytes) {
+        let (left_data, right_data) = self.data.split_at(split_len);
         let right_box_stable_deref = self.box_stable_deref.clone();
         let left = OwnedBytes {
-            data: &self.data[..split_len],
+            data: left_data,
             box_stable_deref: self.box_stable_deref,
         };
         let right = OwnedBytes {
-            data: &self.data[split_len..],
+            data: right_data,
             box_stable_deref: right_box_stable_deref,
         };
         (left, right)
@@ -99,55 +106,45 @@ impl OwnedBytes {
     ///
     /// `self` is truncated to `split_len`, left with the remaining bytes.
     pub fn split_off(&mut self, split_len: usize) -> OwnedBytes {
+        let (left, right) = self.data.split_at(split_len);
         let right_box_stable_deref = self.box_stable_deref.clone();
         let right_piece = OwnedBytes {
-            data: &self.data[split_len..],
+            data: right,
             box_stable_deref: right_box_stable_deref,
         };
-        self.data = &self.data[..split_len];
+        self.data = left;
         right_piece
     }
 
-    /// Returns true iff this `OwnedBytes` is empty.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.as_slice().is_empty()
-    }
-
     /// Drops the left most `advance_len` bytes.
     #[inline]
-    pub fn advance(&mut self, advance_len: usize) {
-        self.data = &self.data[advance_len..]
+    pub fn advance(&mut self, advance_len: usize) -> &[u8] {
+        let (data, rest) = self.data.split_at(advance_len);
+        self.data = rest;
+        data
     }
 
     /// Reads an `u8` from the `OwnedBytes` and advance by one byte.
     #[inline]
     pub fn read_u8(&mut self) -> u8 {
-        assert!(!self.is_empty());
-
-        let byte = self.as_slice()[0];
-        self.advance(1);
-        byte
+        self.advance(1)[0]
     }
 
-    /// Reads an `u64` encoded as little-endian from the `OwnedBytes` and advance by 8 bytes.
     #[inline]
-    pub fn read_u64(&mut self) -> u64 {
-        assert!(self.len() > 7);
-
-        let octlet: [u8; 8] = self.as_slice()[..8].try_into().unwrap();
-        self.advance(8);
-        u64::from_le_bytes(octlet)
+    fn read_n<const N: usize>(&mut self) -> [u8; N] {
+        self.advance(N).try_into().unwrap()
     }
 
     /// Reads an `u32` encoded as little-endian from the `OwnedBytes` and advance by 4 bytes.
     #[inline]
     pub fn read_u32(&mut self) -> u32 {
-        assert!(self.len() > 3);
+        u32::from_le_bytes(self.read_n())
+    }
 
-        let quad: [u8; 4] = self.as_slice()[..4].try_into().unwrap();
-        self.advance(4);
-        u32::from_le_bytes(quad)
+    /// Reads an `u64` encoded as little-endian from the `OwnedBytes` and advance by 8 bytes.
+    #[inline]
+    pub fn read_u64(&mut self) -> u64 {
+        u64::from_le_bytes(self.read_n())
     }
 }
 
@@ -201,32 +198,33 @@ impl Deref for OwnedBytes {
     }
 }
 
+impl AsRef<[u8]> for OwnedBytes {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
 impl io::Read for OwnedBytes {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let read_len = {
-            let data = self.as_slice();
-            if data.len() >= buf.len() {
-                let buf_len = buf.len();
-                buf.copy_from_slice(&data[..buf_len]);
-                buf.len()
-            } else {
-                let data_len = data.len();
-                buf[..data_len].copy_from_slice(data);
-                data_len
-            }
-        };
-        self.advance(read_len);
-        Ok(read_len)
+        let data_len = self.data.len();
+        let buf_len = buf.len();
+        if data_len >= buf_len {
+            let data = self.advance(buf_len);
+            buf.copy_from_slice(data);
+            Ok(buf_len)
+        } else {
+            buf[..data_len].copy_from_slice(self.data);
+            self.data = &[];
+            Ok(data_len)
+        }
     }
     #[inline]
     fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        let read_len = {
-            let data = self.as_slice();
-            buf.extend(data);
-            data.len()
-        };
-        self.advance(read_len);
+        buf.extend(self.data);
+        let read_len = self.data.len();
+        self.data = &[];
         Ok(read_len)
     }
     #[inline]
@@ -242,13 +240,6 @@ impl io::Read for OwnedBytes {
     }
 }
 
-impl AsRef<[u8]> for OwnedBytes {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::io::{self, Read};