move IdentityHasher into its own file

Author: arvidn

src/serde/identity_hash.rs

@@ -0,0 +1,43 @@
+use rand::Rng;
+use std::hash::{BuildHasher, Hasher};
+
+#[derive(Default, Clone, Copy)]
+pub struct IdentityHash(u64, u64);
+
+impl IdentityHash {
+    fn new(salt: u64) -> Self {
+        Self(0, salt)
+    }
+}
+
+impl Hasher for IdentityHash {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0 =
+            u64::from_le_bytes(bytes[0..8].try_into().expect("expected 32 byte hashes")) ^ self.1;
+    }
+
+    fn write_u64(&mut self, _i: u64) {
+        panic!("This hasher only takes bytes");
+    }
+}
+
+pub struct RandomState(u64);
+
+impl Default for RandomState {
+    fn default() -> Self {
+        let mut rng = rand::thread_rng();
+        Self(rng.gen())
+    }
+}
+
+impl BuildHasher for RandomState {
+    type Hasher = IdentityHash;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        IdentityHash::new(self.0)
+    }
+}

src/serde/mod.rs

@@ -3,6 +3,7 @@ mod de;
 mod de_br;
 mod de_tree;
 mod errors;
+mod identity_hash;
 mod incremental;
 mod object_cache;
 mod parse_atom;
@@ -19,6 +20,7 @@ mod test;
 pub use de::node_from_bytes;
 pub use de_br::{node_from_bytes_backrefs, node_from_bytes_backrefs_record};
 pub use de_tree::{parse_triples, ParsedTriple};
+pub use identity_hash::RandomState;
 pub use incremental::{Serializer, UndoState};
 pub use object_cache::{serialized_length, treehash, ObjectCache};
 pub use ser::{node_to_bytes, node_to_bytes_limit};

src/serde/read_cache_lookup.rs

@@ -1,6 +1,6 @@
+use crate::serde::RandomState;
 use bitvec::prelude::*;
 use bitvec::vec::BitVec;
-use rand::Rng;
 /// When deserializing a clvm object, a stack of deserialized child objects
 /// is created, which can be used with back-references. A `ReadCacheLookup` keeps
 /// track of the state of this stack and all child objects under each root
@@ -19,51 +19,9 @@ use rand::Rng;
 ///
 /// All hashes correspond to sha256 tree hashes.
 use std::collections::{HashMap, HashSet};
-use std::hash::{BuildHasher, Hasher};
 
 use super::bytes32::{hash_blob, hash_blobs, Bytes32};
 
-#[derive(Default, Clone, Copy)]
-pub struct IdentityHash(u64, u64);
-
-impl IdentityHash {
-    fn new(salt: u64) -> Self {
-        Self(0, salt)
-    }
-}
-
-impl Hasher for IdentityHash {
-    fn finish(&self) -> u64 {
-        self.0
-    }
-
-    fn write(&mut self, bytes: &[u8]) {
-        self.0 =
-            u64::from_le_bytes(bytes[0..8].try_into().expect("expected 32 byte hashes")) ^ self.1;
-    }
-
-    fn write_u64(&mut self, _i: u64) {
-        panic!("This hasher only takes bytes");
-    }
-}
-
-pub struct RandomState(u64);
-
-impl RandomState {
-    fn new() -> Self {
-        let mut rng = rand::thread_rng();
-        Self(rng.gen())
-    }
-}
-
-impl BuildHasher for RandomState {
-    type Hasher = IdentityHash;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        IdentityHash::new(self.0)
-    }
-}
-
 #[derive(Debug)]
 pub struct ReadCacheLookup {
     root_hash: Bytes32,
@@ -91,9 +49,9 @@ impl ReadCacheLookup {
         let read_stack = Vec::with_capacity(1000);
         // all keys in count and parent_lookup are tree-hashes. There's no need
         // to hash them again for the hash map
-        let mut count = HashMap::with_hasher(RandomState::new());
+        let mut count = HashMap::with_hasher(RandomState::default());
         count.insert(root_hash, 1);
-        let parent_lookup = HashMap::with_hasher(RandomState::new());
+        let parent_lookup = HashMap::with_hasher(RandomState::default());
         Self {
             root_hash,
             read_stack,
@@ -178,8 +136,10 @@ impl ReadCacheLookup {
 
         // all the values we put in this hash set are themselves sha256 hashes.
         // There's no point in hashing the hashes
-        let mut seen_ids =
-            HashSet::<&Bytes32, RandomState>::with_capacity_and_hasher(1000, RandomState::new());
+        let mut seen_ids = HashSet::<&Bytes32, RandomState>::with_capacity_and_hasher(
+            1000,
+            RandomState::default(),
+        );
 
         let max_bytes_for_path_encoding = serialized_length - 2; // 1 byte for 0xfe, 1 min byte for savings
         let max_path_length: usize = (max_bytes_for_path_encoding.saturating_mul(8) - 1)