Explicity store the bytes size

We can afford it since the average hash is 34 bytes, and we want this thing
to be a multiple of 8 large.

Author: rklaehn

src/lib.rs

@@ -212,9 +212,7 @@ impl Multihash {
 
     /// Returns the bytes representation of this multihash.
     pub fn as_bytes(&self) -> &[u8] {
-        let bytes = self.storage.bytes();
-        let size = multihash_size(bytes).expect("storage contains a valid multihash");
-        &bytes[..size]
+        self.storage.bytes()
     }
 
     /// Builds a `MultihashRef` corresponding to this `Multihash`.
@@ -261,30 +259,6 @@ pub struct MultihashRef<'a> {
     bytes: &'a [u8],
 }
 
-/// Given a buffer starting with a valid multihash, returns the size of the multihash
-fn multihash_size(input: &[u8]) -> Result<usize, DecodeError> {
-    if input.is_empty() {
-        return Err(DecodeError::BadInputLength);
-    }
-    let mut res = 0usize;
-
-    // Ensure `Hash::code` returns a `u16` so that our `decode::u16` here is correct.
-    std::convert::identity::<fn(Hash) -> u16>(Hash::code);
-    let (code, bytes) = decode::u16(&input).map_err(|_| DecodeError::BadInputLength)?;
-
-    // Very convoluted way to get the size of the code
-    let mut tmp = [0u8; 3];
-    res += unsigned_varint::encode::u16(code, &mut tmp).len();
-
-    let (hash_len, _) = decode::u32(&bytes).map_err(|_| DecodeError::BadInputLength)?;
-
-    // Very convoluted way to get the size of the hash_len
-    let mut tmp = [0u8; 5];
-    res += unsigned_varint::encode::u32(hash_len, &mut tmp).len();
-    res += hash_len as usize;
-    Ok(res)
-}
-
 impl<'a> MultihashRef<'a> {
     /// Creates a `MultihashRef` from the given `input`.
     pub fn from_slice(input: &'a [u8]) -> Result<Self, DecodeError> {

src/storage.rs

@@ -1,31 +1,32 @@
 use std::sync::Arc;
 
-const MAX_INLINE: usize = 39;
+const MAX_INLINE: usize = 38;
 
 #[derive(Clone)]
 pub enum Storage {
-    /// hash is stored inline. if it is smaller than 39 bytes it should be padded with 0u8
-    Inline([u8; MAX_INLINE]),
+    /// hash is stored inline if it is smaller than MAX_INLINE
+    Inline(u8, [u8; MAX_INLINE]),
     /// hash is stored on the heap. this must be only used if the hash is actually larger than
-    /// 39 bytes to ensure an unique representation.
+    /// MAX_INLINE bytes to ensure an unique representation.
     Heap(Arc<[u8]>),
 }
 
 impl Storage {
-    /// The raw bytes. Note that this can be longer than the data this storage has been created from.
+    /// The raw bytes.
     pub fn bytes(&self) -> &[u8] {
         match self {
-            Storage::Inline(bytes) => bytes,
+            Storage::Inline(len, bytes) => &bytes[..(*len as usize)],
             Storage::Heap(data) => &data,
         }
     }
 
-    /// creates storage from a vec. Note that this will not preserve the size.
+    /// creates storage from a vec. For a size up to MAX_INLINE, this will not allocate.
     pub fn from_slice(slice: &[u8]) -> Self {
-        if slice.len() <= MAX_INLINE {
+        let len = slice.len();
+        if len <= MAX_INLINE {
             let mut data: [u8; MAX_INLINE] = [0; MAX_INLINE];
-            data[..slice.len()].copy_from_slice(slice);
-            Storage::Inline(data)
+            data[..len].copy_from_slice(slice);
+            Storage::Inline(len as u8, data)
         } else {
             Storage::Heap(slice.into())
         }
@@ -34,10 +35,21 @@ impl Storage {
 
 #[cfg(test)]
 mod tests {
-    use super::Storage;
+    use super::{Storage, MAX_INLINE};
 
     #[test]
-    fn test_size() {
+    fn struct_size() {
+        // this should be true for both 32 and 64 bit archs
         assert_eq!(std::mem::size_of::<Storage>(), 40);
     }
+
+    #[test]
+    fn roundtrip() {
+        // check that .bytes() returns whatever the storage was created with
+        for i in 0..((MAX_INLINE + 10) as u8) {
+            let data = (0..i).collect::<Vec<u8>>();
+            let storage = Storage::from_slice(&data);
+            assert_eq!(data, storage.bytes());
+        }
+    }
 }

tests/lib.rs

@@ -276,8 +276,3 @@ fn multihash_ref_errors() {
         "Should error on wrong hash length"
     );
 }
-
-#[test]
-fn multihash_size() {
-    assert_eq!(std::mem::size_of::<Multihash>(), 40);
-}