hashlink/
lib.rs

1#![no_std]
2extern crate alloc;
3
4pub mod linked_hash_map;
5pub mod linked_hash_set;
6pub mod lru_cache;
7#[cfg(feature = "serde_impl")]
8pub mod serde;
9
10use core::hash::{BuildHasher, Hasher};
11
12pub use linked_hash_map::LinkedHashMap;
13pub use linked_hash_set::LinkedHashSet;
14pub use lru_cache::LruCache;
15
16/// Default hash builder, matches hashbrown's default hasher.
17///
18/// See [`DefaultHasher`] for more details.
19#[derive(Clone, Copy, Default, Debug)]
20pub struct DefaultHashBuilder(hashbrown::DefaultHashBuilder);
21
22impl BuildHasher for DefaultHashBuilder {
23    type Hasher = DefaultHasher;
24
25    #[inline]
26    fn build_hasher(&self) -> Self::Hasher {
27        DefaultHasher(self.0.build_hasher())
28    }
29}
30
31/// Default hasher, as selected by hashbrown.
32#[derive(Clone)]
33pub struct DefaultHasher(<hashbrown::DefaultHashBuilder as BuildHasher>::Hasher);
34
35impl Hasher for DefaultHasher {
36    #[inline]
37    fn write(&mut self, bytes: &[u8]) {
38        self.0.write(bytes)
39    }
40
41    #[inline]
42    fn write_u8(&mut self, i: u8) {
43        self.0.write_u8(i)
44    }
45
46    #[inline]
47    fn write_u16(&mut self, i: u16) {
48        self.0.write_u16(i)
49    }
50
51    #[inline]
52    fn write_u32(&mut self, i: u32) {
53        self.0.write_u32(i)
54    }
55
56    #[inline]
57    fn write_u64(&mut self, i: u64) {
58        self.0.write_u64(i)
59    }
60
61    #[inline]
62    fn write_u128(&mut self, i: u128) {
63        self.0.write_u128(i)
64    }
65
66    #[inline]
67    fn write_usize(&mut self, i: usize) {
68        self.0.write_usize(i)
69    }
70
71    #[inline]
72    fn finish(&self) -> u64 {
73        self.0.finish()
74    }
75
76    #[inline]
77    fn write_i8(&mut self, i: i8) {
78        self.0.write_i8(i)
79    }
80
81    #[inline]
82    fn write_i16(&mut self, i: i16) {
83        self.0.write_i16(i)
84    }
85
86    #[inline]
87    fn write_i32(&mut self, i: i32) {
88        self.0.write_i32(i)
89    }
90
91    #[inline]
92    fn write_i64(&mut self, i: i64) {
93        self.0.write_i64(i)
94    }
95
96    #[inline]
97    fn write_i128(&mut self, i: i128) {
98        self.0.write_i128(i)
99    }
100
101    #[inline]
102    fn write_isize(&mut self, i: isize) {
103        self.0.write_isize(i)
104    }
105}