lib/
sha1_hash_map.rs

1#[allow(dead_code)]
2use core::panic;
3use hex::encode;
4use sha1::{Digest, Sha1};
5use std::{
6    collections::{hash_map::DefaultHasher, HashMap},
7    hash::{Hash, Hasher},
8    sync::Arc,
9};
10
11#[derive(Debug, Clone, Default, PartialEq, Eq)]
12pub struct HashSetMap<T> {
13    pub register: HashMap<Arc<[u8]>, Arc<T>>,
14}
15
16pub struct HashSetMapBuilder<T> {
17    pub hash_register: HashSetMap<T>,
18    pub hasher: Option<Arc<dyn Hasher>>,
19}
20
21pub struct Sha1Hasher {
22    pub state: [u8; 20],
23}
24pub struct HsmWithSha1Hasher {
25    pub hsm: HashSetMapBuilder<String>,
26    pub hasher: Sha1Hasher,
27}
28
29#[allow(dead_code)]
30impl<'a, T> HashSetMapBuilder<T>
31where
32    T: Hash + Eq + Clone + Default + ToString,
33    HashSetMapBuilder<T>: Default,
34{
35    pub fn insert(
36        mut self,
37        hasher: &mut Sha1Hasher,
38        input: T,
39    ) -> (Arc<[u8]>, Option<Arc<T>>, Self) {
40        if self.hasher.is_none() {
41            panic!("HashSetMapBuilder::insert() -> hasher is None")
42        };
43        hasher.write(input.to_string().as_bytes());
44        let key = hasher.finish();
45        // print!("{}|", key);
46        (
47            key.clone(),
48            self.hash_register.register.insert(key, Arc::new(input)),
49            self,
50        )
51    }
52    pub fn new() -> Self {
53        Default::default()
54    }
55    pub fn new_with_capacity(capacity: usize) -> Self {
56        let mut hash_register = HashSetMap::default();
57        hash_register.register = HashMap::with_capacity(capacity);
58        Self {
59            hash_register,
60            hasher: None,
61        }
62    }
63    pub fn new_with_hasher(hasher: Arc<dyn Hasher>) -> Self {
64        Self {
65            hash_register: Default::default(),
66            hasher: Some(hasher),
67        }
68    }
69    pub fn new_with_capacity_and_hasher(capacity: usize, hasher: Arc<dyn Hasher>) -> Self {
70        let mut hash_register = HashSetMap::default();
71        hash_register.register = HashMap::with_capacity_and_hasher(capacity, Default::default());
72        Self {
73            hash_register,
74            hasher: Some(hasher),
75        }
76    }
77    pub fn build(self) -> HashMap<Arc<String>, Arc<T>> {
78        let mut hash_register = HashMap::with_capacity(self.hash_register.register.len());
79        for (key, value) in self.hash_register.register.into_iter() {
80            hash_register.insert(Arc::new(encode(key.as_ref())), value);
81        }
82        hash_register
83    }
84
85    pub fn with_hasher(mut self, hasher: Arc<dyn Hasher>) -> Self {
86        self.hasher = Some(hasher);
87        self
88    }
89    pub fn hasher(&mut self, hasher: Arc<dyn Hasher>) -> &mut Self {
90        self.hasher = Some(hasher);
91        self
92    }
93
94    pub fn len(&self) -> usize {
95        self.hash_register.register.len()
96    }
97    pub fn is_empty(&self) -> bool {
98        self.hash_register.register.is_empty()
99    }
100    pub fn clear(&mut self) {
101        self.hash_register.register.clear();
102    }
103}
104
105impl<T> Default for HashSetMapBuilder<T>
106where
107    T: Hash + Eq + Clone + Default + ToString,
108{
109    fn default() -> Self {
110        Self {
111            hash_register: HashSetMap {
112                register: HashMap::new(),
113            },
114            hasher: Some(Arc::new(DefaultHasher::new())),
115        }
116    }
117}
118
119#[allow(dead_code)]
120impl Sha1Hasher {
121    pub fn new() -> Self {
122        Self { state: [0; 20] }
123    }
124    pub fn digest(&self, data: &[u8]) -> String {
125        let mut hasher = Sha1Hasher::new();
126        hasher.write(data);
127        encode(hasher.state.as_ref())
128    }
129    pub fn write(&mut self, bytes: &[u8]) {
130        // println!("{:?}", bytes);
131        let mut hasher = Sha1::new();
132        hasher.update(bytes);
133        let encode = hasher.finalize();
134        // println!("{:#?}", encode);
135        self.state = encode[0..20].try_into().unwrap();
136    }
137
138    pub fn finish(&self) -> Arc<[u8]> {
139        Arc::new(self.state)
140    }
141}
142
143#[allow(dead_code)]
144impl HsmWithSha1Hasher {
145    pub fn new() -> Self {
146        Self {
147            hsm: HashSetMapBuilder::new(),
148            hasher: Sha1Hasher::new(),
149        }
150    }
151    pub fn insert(mut self, input: String) -> (Arc<[u8]>, Option<Arc<String>>, Self) {
152        let key;
153        let previous;
154        (key, previous, self.hsm) = self.hsm.insert(&mut self.hasher, input);
155        (key, previous, self)
156    }
157    pub fn insert_blind(mut self, input: String) -> Self {
158        let _key;
159        let _previous;
160        (_key, _previous, self) = self.insert(input);
161        self
162    }
163    pub fn build(self) -> HashMap<Arc<String>, Arc<String>> {
164        self.hsm.build()
165    }
166}
lib/sha1_hash_map.rs

lib/
sha1_hash_map.rs
