perf: render Cids to bytes without allocating a Vec

not sure how much sense does this make, given that the byte writing fns
might be less inlined. would be nice to have some benchmarks.

this also adds a test to verify directory cid when using cidv1 even
though it's quite unclear to me if those are allowed in unixfs dirs.

Author: Joonas Koivunen

unixfs/src/dir/builder/buffered.rs

@@ -417,6 +417,44 @@ mod tests {
         );
     }
 
+    #[test]
+    fn dir_with_cidv1_link() {
+        // this is `echo '{ "name": "hello" }` | ./ipfs dag put`
+        let target =
+            Cid::try_from("bafyreihakpd7te5nbmlhdk5ntvcvhf2hmfgrvcwna2sddq5zz5342mcbli").unwrap();
+
+        let mut builder = BufferingTreeBuilder::default();
+        builder.put_file("a/b", target, 12).unwrap();
+
+        let mut full_path = String::new();
+        let mut buffer = Vec::new();
+
+        let iter = builder.build(&mut full_path, &mut buffer);
+        let mut actual = iter
+            .map(|res| res.map(|n| (n.path, n.cid, n.block)))
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+
+        let mut expected = vec![("a", "QmPMDMPG8dbHDC9GuvqWr9pfruLnp4GZCAWrskwCmenVQa")];
+
+        // hopefully this way the errors will be easier to hunt down
+
+        actual.reverse();
+        expected.reverse();
+
+        while let Some(actual) = actual.pop() {
+            let expected = expected.pop().expect("size mismatch");
+            assert_eq!(actual.0, expected.0);
+            assert_eq!(
+                actual.1.to_string(),
+                expected.1,
+                "{:?}: {:?}",
+                actual.0,
+                Hex(&actual.2)
+            );
+        }
+    }
+
     /// Returns a quick and dirty sha2-256 of the given number as a Cidv0
     fn some_cid(number: usize) -> Cid {
         use multihash::Sha2_256;

unixfs/src/dir/builder/iter.rs

@@ -82,7 +82,8 @@ impl<'a> PostOrderIterator<'a> {
                 // ones are the tags
                 1 + sizeof_len(self.0.len())
                     + 1
-                    + sizeof_len(self.1.link.hash().as_bytes().len())
+                    //+ sizeof_len(WriteableCid(&self.1.link).get_size())
+                    + sizeof_len(self.1.link.to_bytes().len())
                     + 1
                     + sizeof_varint(self.1.total_size)
             }
@@ -91,26 +92,68 @@ impl<'a> PostOrderIterator<'a> {
                 &self,
                 w: &mut Writer<W>,
             ) -> quick_protobuf::Result<()> {
-                w.write_with_tag(10, |w| w.write_bytes(self.1.link.hash().as_bytes()))?;
+                // w.write_with_tag(10, |w| w.write_message(&WriteableCid(&self.1.link)))?;
+                w.write_with_tag(10, |w| w.write_bytes(&self.1.link.to_bytes()))?;
                 w.write_with_tag(18, |w| w.write_string(self.0.as_str()))?;
                 w.write_with_tag(24, |w| w.write_uint64(self.1.total_size))?;
                 Ok(())
             }
         }
 
+        struct WriteableCid<'a>(&'a Cid);
+
+        // Cid by default does not have a way to count it's length or just write it out without
+        // allocating a vector.
+        impl<'a> MessageWrite for WriteableCid<'a> {
+            fn get_size(&self) -> usize {
+                use cid::Version::*;
+                use quick_protobuf::sizeofs::*;
+
+                match self.0.version() {
+                    V0 => self.0.hash().as_bytes().len(),
+                    V1 => {
+                        let version_len = 1;
+                        let codec_len = sizeof_varint(u64::from(self.0.codec()));
+                        let hash_len = self.0.hash().as_bytes().len();
+                        version_len + codec_len + hash_len
+                    }
+                }
+            }
+
+            fn write_message<W: WriterBackend>(
+                &self,
+                w: &mut Writer<W>,
+            ) -> quick_protobuf::Result<()> {
+                use cid::Version::*;
+
+                match self.0.version() {
+                    V0 => {
+                        for b in self.0.hash().as_bytes() {
+                            w.write_u8(*b)?;
+                        }
+                        Ok(())
+                    }
+                    V1 => {
+                        // it is possible that Cidv1 should not be linked to from a unixfs
+                        // directory; at least go-ipfs 0.5 `ipfs files` denies making a cbor link
+                        w.write_u8(1)?;
+                        w.write_varint(u64::from(self.0.codec()))?;
+                        for b in self.0.hash().as_bytes() {
+                            w.write_u8(*b)?;
+                        }
+                        Ok(())
+                    }
+                }
+            }
+        }
+
         impl<'a> MessageWrite for BTreeMappedDir<'a> {
             fn get_size(&self) -> usize {
                 use quick_protobuf::sizeofs::*;
 
                 let links = self
                     .links
                     .iter()
-                    .inspect(|(_, Leaf { link, .. })| {
-                        assert!(
-                            link.version() == cid::Version::V0,
-                            "size calc is only impl for v0 cids"
-                        )
-                    })
                     .map(|(k, v)| EntryAsPBLink(k, v))
                     .map(|link| 1 + sizeof_len(link.get_size()))
                     .sum::<usize>();