feat: implement std::io::Write trait for the hashers

Instead of having a (non-working) wrapper struct for implementing
std::io::Write for a hasher, implement it directly on the hasher.

Closes #95.

Author: vmx

src/hasher.rs

@@ -134,19 +134,3 @@ impl<T: StatefulHasher> Hasher for T {
         hasher.finalize()
     }
 }
-
-/// New type wrapper for a hasher that implements the `std::io::Write` trait.
-#[cfg(feature = "std")]
-pub struct WriteHasher<H: Hasher>(H);
-
-#[cfg(feature = "std")]
-impl<H: StatefulHasher> std::io::Write for WriteHasher<H> {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        self.0.update(buf);
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}

src/hasher_impl.rs

@@ -50,6 +50,22 @@ macro_rules! derive_digest {
     };
 }
 
+macro_rules! derive_write {
+    ($name:ident) => {
+        #[cfg(feature = "std")]
+        impl<S: Size> std::io::Write for $name<S> {
+            fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+                self.update(buf);
+                Ok(buf.len())
+            }
+
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+    };
+}
+
 #[cfg(any(feature = "blake2b", feature = "blake2s"))]
 macro_rules! derive_hasher_blake {
     ($module:ident, $name:ident, $digest:ident) => {
@@ -91,6 +107,8 @@ macro_rules! derive_hasher_blake {
                 self.state = state;
             }
         }
+
+        derive_write!($name);
     };
 }
 
@@ -169,6 +187,8 @@ pub mod blake3 {
         }
     }
 
+    derive_write!(Blake3Hasher);
+
     /// blake3-256 hasher.
     pub type Blake3_256 = Blake3Hasher<U32>;
 }
@@ -201,6 +221,18 @@ macro_rules! derive_hasher_sha {
                 self.state.reset();
             }
         }
+
+        #[cfg(feature = "std")]
+        impl std::io::Write for $name {
+            fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+                self.update(buf);
+                Ok(buf.len())
+            }
+
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
     };
 }
 
@@ -342,6 +374,8 @@ pub mod identity {
         }
     }
 
+    derive_write!(IdentityHasher);
+
     /// 32 byte Identity hasher (constrained to 32 bytes).
     ///
     /// # Panics
@@ -403,6 +437,8 @@ pub mod strobe {
         }
     }
 
+    derive_write!(StrobeHasher);
+
     /// 256 bit strobe hasher.
     pub type Strobe256 = StrobeHasher<U32>;
 

src/lib.rs

@@ -62,8 +62,6 @@ mod multihash;
 mod multihash_impl;
 
 pub use crate::error::{Error, Result};
-#[cfg(feature = "std")]
-pub use crate::hasher::WriteHasher;
 pub use crate::hasher::{Digest, Hasher, Size, StatefulHasher};
 pub use crate::multihash::{Multihash as MultihashGeneric, MultihashDigest};
 pub use generic_array::typenum::{self, U128, U16, U20, U28, U32, U48, U64};

tests/lib.rs

@@ -1,4 +1,4 @@
-use std::io::Cursor;
+use std::io::{Cursor, Write};
 
 use multihash::{
     derive::Multihash, Blake2b256, Blake2b512, Blake2bDigest, Blake2s128, Blake2s256,
@@ -167,6 +167,16 @@ macro_rules! assert_roundtrip {
                     hash.code()
                 );
             }
+            // Hashing as `Write` implementation
+            {
+                let mut hasher = <$alg>::default();
+                hasher.write_all(b"helloworld").unwrap();
+                let hash = Code::multihash_from_digest(&hasher.finalize());
+                assert_eq!(
+                    Multihash::from_bytes(&hash.to_bytes()).unwrap().code(),
+                    hash.code()
+                );
+            }
         )*
     }
 }