verde 0.2.2

A refreshingly simple incremental computation library
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
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

use std::{borrow::Borrow, hash::Hash};

use parking_lot::{MappedRwLockReadGuard, Mutex, RwLock, RwLockReadGuard};
use rustc_hash::FxHashMap;

use crate::{event, internal::Interned};

pub trait ErasedInternedStorage {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct InternedStorage<T: Interned> {
	/// Mutex is required for TOCTOU safety.
	map: Mutex<FxHashMap<T, u32>>,
	values: RwLock<Vec<T>>,
}

pub type Get<'a, T> = MappedRwLockReadGuard<'a, T>;

impl<T: Interned> ErasedInternedStorage for InternedStorage<T> {}

impl<T: Interned> InternedStorage<T> {
	/// Insert a new value into the storage.
	pub fn insert(&self, value: T) -> u32 {
		let mut map = self.map.lock();
		match map.get(&value) {
			Some(index) => *index,
			None => {
				event!(trace, "inserting new value");
				let mut values = self.values.write();
				let index = values.len() as u32;
				values.push(value.clone());
				map.insert(value, index);
				index
			},
		}
	}

	pub fn insert_ref<U>(&self, value: &U) -> u32
	where
		U: ToOwned<Owned = T> + Hash + Eq + ?Sized,
		T: Borrow<U>,
	{
		let mut map = self.map.lock();
		match map.get(value) {
			Some(index) => *index,
			None => {
				event!(trace, "inserting new value");
				let mut values = self.values.write();
				let index = values.len() as u32;
				values.push(value.to_owned());
				map.insert(value.to_owned(), index);
				index
			},
		}
	}

	pub fn get(&self, index: u32) -> Get<'_, T> {
		RwLockReadGuard::map(self.values.read_recursive(), |x| &x[index as usize])
	}
}

impl<T: Interned> Default for InternedStorage<T> {
	fn default() -> Self {
		Self {
			map: Mutex::default(),
			values: RwLock::new(Vec::new()),
		}
	}
}

impl<'a> dyn ErasedInternedStorage + 'a {
	/// **Safety**: The type of `self` must be `InternedStorage<T>`.
	pub unsafe fn insert<T: Interned>(&self, value: T) -> u32 {
		unsafe {
			let storage = self as *const dyn ErasedInternedStorage as *const InternedStorage<T>;
			(*storage).insert(value)
		}
	}

	/// **Safety**: The type of `self` must be `InternedStorage<T>`.
	pub unsafe fn get<T: Interned>(&self, index: u32) -> Get<'_, T> {
		unsafe {
			let storage = self as *const dyn ErasedInternedStorage as *const InternedStorage<T>;
			(*storage).get(index)
		}
	}

	/// **Safety**: The type of `self` must be `InternedStorage<T>`.
	pub unsafe fn insert_ref<T, U>(&self, value: &U) -> u32
	where
		U: ToOwned<Owned = T> + Hash + Eq + ?Sized,
		T: Borrow<U> + Interned,
	{
		unsafe {
			let storage = self as *const dyn ErasedInternedStorage as *const InternedStorage<T>;
			(*storage).insert_ref(value)
		}
	}
}