Introduce HexWriter

this structs create an hex string from a writer, in cases where you have
an encodable object it allows skipping the creation of the intermediate Vec<u8>

Author: RCasatta

src/hex.rs

@@ -219,6 +219,45 @@ impl ToHex for [u8] {
     }
 }
 
+/// A struct implementing [`io::Write`] that converts what's written into it
+/// in an hex String
+///
+/// If you already have the data to be converted in a `Vec<u8>` use [`ToHex`]
+/// but if you have an encodable object, by using this you avoid the
+/// serialization to `Vec<u8>` by going directly to `String`.
+///
+/// Note that to achieve better perfomance than [`ToHex`] the struct must be
+/// created with the right `capacity` of the end hex string result so that the
+/// inner `String` doesn't re-allocate
+pub struct HexWriter(String);
+
+impl HexWriter {
+    /// Creates a new [`HexWriter`] specify the `capacity` of the inner `String` that will contain
+    /// the hex value
+    pub fn new(capacity: usize) -> Self {
+        HexWriter(String::with_capacity(capacity))
+    }
+
+    /// Get the hex string result
+    pub fn result(self) -> String {
+        self.0
+    }
+}
+
+impl io::Write for HexWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        use core::fmt::Write;
+        for ch in buf {
+            write!(self.0, "{:02x}", ch).expect("writing to string");
+        }
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 #[cfg(any(test, feature = "std", feature = "alloc"))]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl FromHex for Vec<u8> {
@@ -276,6 +315,7 @@ mod tests {
     use super::*;
 
     use core::fmt;
+    use std::io::Write;
 
     #[test]
     #[cfg(any(feature = "std", feature = "alloc"))]
@@ -398,5 +438,41 @@ mod tests {
             Err(Error::InvalidChar(194))
         );
     }
+
+
+    #[test]
+    fn hex_writer() {
+        let vec: Vec<_>  = (0u8..32).collect();
+        let mut writer = HexWriter::new(64);
+        writer.write_all(&vec[..]).unwrap();
+        assert_eq!(vec.to_hex(), writer.result());
+    }
 }
 
+
+#[cfg(all(test, feature="unstable"))]
+mod benches {
+    use test::{Bencher, black_box};
+    use super::{ToHex, HexWriter};
+    use std::io::Write;
+    use crate::{sha256, Hash};
+
+    #[bench]
+    fn bench_to_hex(bh: &mut Bencher) {
+        let hash = sha256::Hash::hash(&[0; 1]);
+        bh.iter(|| {
+            black_box(hash.to_hex());
+        })
+    }
+
+
+    #[bench]
+    fn bench_to_hex_writer(bh: &mut Bencher) {
+        let hash = sha256::Hash::hash(&[0; 1]);
+        bh.iter(|| {
+            let mut writer = HexWriter::new(64);
+            writer.write_all(hash.as_inner()).unwrap();
+            black_box(writer.result());
+        })
+    }
+}