#![allow(clippy::implicit_hasher)]
#[cfg(feature = "asynch")]
pub mod asynch;
#[cfg(feature = "arcache")]
use crate::internals::hashtrie::cursor::Datum;
use crate::internals::lincowcell::{LinCowCell, LinCowCellReadTxn, LinCowCellWriteTxn};
include!("impl.rs");
impl<K: Hash + Eq + Clone + Debug + Sync + Send + 'static, V: Clone + Sync + Send + 'static>
HashTrie<K, V>
{
pub fn new() -> Self {
HashTrie {
inner: LinCowCell::new(unsafe { SuperBlock::new() }),
}
}
pub fn read(&self) -> HashTrieReadTxn<K, V> {
let inner = self.inner.read();
HashTrieReadTxn { inner }
}
pub fn write(&self) -> HashTrieWriteTxn<K, V> {
let inner = self.inner.write();
HashTrieWriteTxn { inner }
}
pub fn try_write(&self) -> Option<HashTrieWriteTxn<K, V>> {
self.inner
.try_write()
.map(|inner| HashTrieWriteTxn { inner })
}
}
impl<
'a,
K: Hash + Eq + Clone + Debug + Sync + Send + 'static,
V: Clone + Sync + Send + 'static,
> HashTrieWriteTxn<'a, K, V>
{
#[cfg(feature = "arcache")]
pub(crate) fn get_txid(&self) -> u64 {
self.inner.as_ref().get_txid()
}
#[cfg(feature = "arcache")]
pub(crate) fn prehash<'b, Q: ?Sized>(&'a self, k: &'b Q) -> u64
where
K: Borrow<Q>,
Q: Hash + Eq,
{
self.inner.as_ref().hash_key(k)
}
#[cfg(feature = "arcache")]
pub(crate) unsafe fn get_slot_mut(&mut self, k_hash: u64) -> Option<&mut [Datum<K, V>]> {
self.inner.as_mut().get_slot_mut_ref(k_hash)
}
pub fn commit(self) {
self.inner.commit();
}
}
impl<
'a,
K: Hash + Eq + Clone + Debug + Sync + Send + 'static,
V: Clone + Sync + Send + 'static,
> HashTrieReadTxn<'a, K, V>
{
#[cfg(feature = "arcache")]
pub(crate) fn get_txid(&self) -> u64 {
self.inner.as_ref().get_txid()
}
#[cfg(feature = "arcache")]
pub(crate) fn prehash<'b, Q: ?Sized>(&'a self, k: &'b Q) -> u64
where
K: Borrow<Q>,
Q: Hash + Eq,
{
self.inner.as_ref().hash_key(k)
}
}
#[cfg(test)]
mod tests {
use super::HashTrie;
#[test]
fn test_hashtrie_basic_write() {
let hmap: HashTrie<usize, usize> = HashTrie::new();
let mut hmap_write = hmap.write();
hmap_write.insert(10, 10);
hmap_write.insert(15, 15);
assert!(hmap_write.contains_key(&10));
assert!(hmap_write.contains_key(&15));
assert!(!hmap_write.contains_key(&20));
assert!(hmap_write.get(&10) == Some(&10));
{
let v = hmap_write.get_mut(&10).unwrap();
*v = 11;
}
assert!(hmap_write.get(&10) == Some(&11));
assert!(hmap_write.remove(&10).is_some());
assert!(!hmap_write.contains_key(&10));
assert!(hmap_write.contains_key(&15));
assert!(hmap_write.remove(&30).is_none());
hmap_write.clear();
assert!(!hmap_write.contains_key(&10));
assert!(!hmap_write.contains_key(&15));
hmap_write.commit();
}
#[test]
fn test_hashtrie_basic_read_write() {
let hmap: HashTrie<usize, usize> = HashTrie::new();
let mut hmap_w1 = hmap.write();
hmap_w1.insert(10, 10);
hmap_w1.insert(15, 15);
hmap_w1.commit();
let hmap_r1 = hmap.read();
assert!(hmap_r1.contains_key(&10));
assert!(hmap_r1.contains_key(&15));
assert!(!hmap_r1.contains_key(&20));
let mut hmap_w2 = hmap.write();
hmap_w2.insert(20, 20);
hmap_w2.commit();
assert!(hmap_r1.contains_key(&10));
assert!(hmap_r1.contains_key(&15));
assert!(!hmap_r1.contains_key(&20));
let hmap_r2 = hmap.read();
assert!(hmap_r2.contains_key(&10));
assert!(hmap_r2.contains_key(&15));
assert!(hmap_r2.contains_key(&20));
}
#[test]
fn test_hashtrie_basic_read_snapshot() {
let hmap: HashTrie<usize, usize> = HashTrie::new();
let mut hmap_w1 = hmap.write();
hmap_w1.insert(10, 10);
hmap_w1.insert(15, 15);
let snap = hmap_w1.to_snapshot();
assert!(snap.contains_key(&10));
assert!(snap.contains_key(&15));
assert!(!snap.contains_key(&20));
}
#[test]
fn test_hashtrie_basic_iter() {
let hmap: HashTrie<usize, usize> = HashTrie::new();
let mut hmap_w1 = hmap.write();
assert!(hmap_w1.iter().count() == 0);
hmap_w1.insert(10, 10);
hmap_w1.insert(15, 15);
assert!(hmap_w1.iter().count() == 2);
}
#[test]
fn test_hashtrie_from_iter() {
let hmap: HashTrie<usize, usize> = vec![(10, 10), (15, 15), (20, 20)].into_iter().collect();
let hmap_r2 = hmap.read();
assert!(hmap_r2.contains_key(&10));
assert!(hmap_r2.contains_key(&15));
assert!(hmap_r2.contains_key(&20));
}
}