feat: add a way to return hashing implementations

It's now possible to get a hasher implementation based on a `Code`

This commits allso adds some tests for the `Code` enum.

Author: vmx

src/hashes.rs

@@ -5,7 +5,7 @@ use sha1::Sha1 as Sha1Hasher;
 use sha2::{Sha256, Sha512};
 use tiny_keccak::{Hasher, Keccak, Sha3};
 
-use crate::digests::{wrap, Multihash, MultihashDigest};
+use crate::digests::{wrap, DynMultihashDigest, Multihash, MultihashDigest};
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Code {
@@ -84,6 +84,40 @@ impl Code {
             _ => Code::Custom(code),
         }
     }
+
+    /// Return the hasher that is used to create a hash with this code.
+    ///
+    /// If a custom code is used, `None` is returned.
+    pub fn hasher(&self) -> Option<Box<dyn DynMultihashDigest>> {
+        match *self {
+            Self::Custom(_) => None,
+            Self::Implemented(code) => Some(code.hasher()),
+        }
+    }
+}
+
+impl ImplementedCode {
+    /// Return the Multihash implementation that does the actual hashing
+    fn hasher(self) -> Box<dyn DynMultihashDigest> {
+        match self {
+            ImplementedCode::Identity => Box::new(Identity),
+            ImplementedCode::Sha1 => Box::new(Sha1),
+            ImplementedCode::Sha2_256 => Box::new(Sha2_256),
+            ImplementedCode::Sha2_512 => Box::new(Sha2_512),
+            ImplementedCode::Sha3_224 => Box::new(Sha3_224),
+            ImplementedCode::Sha3_256 => Box::new(Sha3_256),
+            ImplementedCode::Sha3_384 => Box::new(Sha3_384),
+            ImplementedCode::Sha3_512 => Box::new(Sha3_512),
+            ImplementedCode::Keccak224 => Box::new(Keccak224),
+            ImplementedCode::Keccak256 => Box::new(Keccak256),
+            ImplementedCode::Keccak384 => Box::new(Keccak384),
+            ImplementedCode::Keccak512 => Box::new(Keccak512),
+            ImplementedCode::Blake2b256 => Box::new(Blake2b256),
+            ImplementedCode::Blake2b512 => Box::new(Blake2b512),
+            ImplementedCode::Blake2s128 => Box::new(Blake2s128),
+            ImplementedCode::Blake2s256 => Box::new(Blake2s256),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]

tests/hashes.rs

@@ -0,0 +1,43 @@
+use multihash::{wrap, Code, ImplementedCode, Multihash, MultihashDigest, Sha3_512};
+
+#[test]
+fn to_u64() {
+    assert_eq!(Code::Implemented(ImplementedCode::Keccak256).to_u64(), 0x1b);
+    assert_eq!(Code::Custom(0x1234).to_u64(), 0x1234);
+}
+
+#[test]
+fn from_u64() {
+    assert_eq!(
+        Code::from_u64(0xb220),
+        Code::Implemented(ImplementedCode::Blake2b256)
+    );
+    assert_eq!(Code::from_u64(0x0011_2233), Code::Custom(0x0011_2233));
+}
+
+#[test]
+fn hasher() {
+    let expected = Sha3_512::digest(b"abcdefg");
+    let hasher = Code::Implemented(ImplementedCode::Sha3_512)
+        .hasher()
+        .unwrap();
+    assert_eq!(hasher.digest(b"abcdefg"), expected);
+    assert!(Code::Custom(0x2222).hasher().is_none());
+}
+
+#[test]
+fn custom_multihash_digest() {
+    #[derive(Clone, Debug)]
+    struct SameHash;
+    impl MultihashDigest for SameHash {
+        const CODE: Code = Code::Custom(0x9999);
+
+        fn digest(_data: &[u8]) -> Multihash {
+            let data = b"alwaysthesame";
+            wrap(&Self::CODE, data)
+        }
+    }
+
+    let my_hash = SameHash::digest(b"abc");
+    assert_eq!(my_hash.digest(), b"alwaysthesame");
+}