bittern 1.0.1

A reference-counted arena for interning and deduplicating data
Documentation 
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

use crate::internal::hash::DefaultState;
use crate::identity::Identity;
use crate::internal::ptr::{non_null, non_null_deref};
use core::hash::BuildHasher;
use core::ptr::NonNull;
use hashbrown::HashTable;
use crate::internal::iter::IndexIter;

/// Hash table that doesn't store values (only their pointer)
pub(crate) struct HashIndex<T: ?Sized, S: BuildHasher = DefaultState> {
    state: S,
    table: HashTable<NonNull<T>>,
}
impl<T: ?Sized> HashIndex<T, DefaultState> {
    pub(crate) fn new() -> Self {
        Self {
            state: DefaultState::new(),
            table: HashTable::new(),
        }
    }
}
impl<T: ?Sized, S: BuildHasher> HashIndex<T, S> {
    pub fn len(&self) -> usize {
        self.table.len()
    }

    pub fn allocation_size(&self) -> usize {
        self.table.allocation_size()
    }

    pub(crate) fn iter(&'_ self) -> IndexIter<'_, T> {
        IndexIter::new(self.table.iter())
    }
}
impl<T: ?Sized, S: BuildHasher> HashIndex<T, S> {
    pub(crate) fn get_ptr<K>(&self, key: &K) -> Option<NonNull<T>>
    where K: ?Sized, T: Identity<K>
    {
        let hash = T::hash(key, &self.state);
        let eq = |other: &NonNull<T>| non_null_deref(other).equivalent(key);
        self.table.find(hash, eq).copied()
    }

    pub(crate) fn contains<K>(&self, key: &K) -> bool
    where K: ?Sized, T: Identity<K>
    {
        self.get_ptr(key).is_some()
    }
}
impl<T: ?Sized + Identity, S: BuildHasher> HashIndex<T, S> {
    pub(crate) fn insert_unique(&mut self, val: &mut T) {
        let hash = T::hash(val, &self.state);
        let rehash = |v: &NonNull<T>| T::hash(non_null_deref(v), &self.state);
        self.table.insert_unique(hash, non_null(val), rehash);
    }
}