1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
# weak-table: weak hash maps and sets for Rust
[](https://github.com/tov/weak-table-rs/actions)
[](https://crates.io/crates/weak-table)
[](LICENSE-MIT)
This crate defines several kinds of weak hash maps and sets. See
the [full API documentation](http://docs.rs/weak-table/) for details.
### Rust version support
This crate supports Rust version 1.46 and later.
### Crate features
`weak-table` is built with the `std` feature, which enables
functionality dependent on the `std` library, enabled by default.
Optionally, the following dependency may be enabled:
- `ahash`: use `ahash`’s hasher rather than the `std` hasher
If the `std` feature is disabled (for no_std) then the `ahash` dependency **must** be enabled.
### Examples
Here we create a weak hash map and demonstrate that it forgets mappings
whose keys expire:
```rust
use weak_table::WeakKeyHashMap;
use std::sync::{Arc, Weak};
let mut table = <WeakKeyHashMap<Weak<str>, u32>>::new();
let one = Arc::<str>::from("one");
let two = Arc::<str>::from("two");
table.insert(one.clone(), 1);
assert_eq!( table.get("one"), Some(&1) );
assert_eq!( table.get("two"), None );
table.insert(two.clone(), 2);
*table.get_mut(&one).unwrap() += 10;
assert_eq!( table.get("one"), Some(&11) );
assert_eq!( table.get("two"), Some(&2) );
drop(one);
assert_eq!( table.get("one"), None );
assert_eq!( table.get("two"), Some(&2) );
```
Here we use a weak hash set to implement a simple string interning facility:
```rust
use weak_table::WeakHashSet;
use std::ops::Deref;
use std::rc::{Rc, Weak};
#[derive(Clone, Debug)]
pub struct Symbol(Rc<str>);
impl PartialEq for Symbol {
fn eq(&self, other: &Symbol) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
}
impl Eq for Symbol {}
impl Deref for Symbol {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
#[derive(Debug, Default)]
pub struct SymbolTable(WeakHashSet<Weak<str>>);
impl SymbolTable {
pub fn new() -> Self {
Self::default()
}
pub fn intern(&mut self, name: &str) -> Symbol {
if let Some(rc) = self.0.get(name) {
Symbol(rc)
} else {
let rc = Rc::<str>::from(name);
self.0.insert(Rc::clone(&rc));
Symbol(rc)
}
}
}
#[test]
fn interning() {
let mut tab = SymbolTable::new();
let a0 = tab.intern("a");
let a1 = tab.intern("a");
let b = tab.intern("b");
assert_eq!(a0, a1);
assert_ne!(a0, b);
}
```
|
