File size: 2,812 Bytes
1e92f2d |
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 |
use std::sync::{LockResult, Mutex, MutexGuard};
use concurrent_queue::ConcurrentQueue;
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize, de::Visitor};
use turbo_tasks::{Invalidator, ReadRef};
use crate::{FileContent, LinkContent};
#[derive(Serialize, Deserialize, PartialEq, Eq)]
pub enum WriteContent {
File(ReadRef<FileContent>),
Link(ReadRef<LinkContent>),
}
type InnerMap = FxHashMap<String, FxHashMap<Invalidator, Option<WriteContent>>>;
pub struct InvalidatorMap {
queue: ConcurrentQueue<(String, Invalidator, Option<WriteContent>)>,
map: Mutex<InnerMap>,
}
impl Default for InvalidatorMap {
fn default() -> Self {
Self {
queue: ConcurrentQueue::unbounded(),
map: Default::default(),
}
}
}
impl InvalidatorMap {
pub fn new() -> Self {
Self::default()
}
pub fn lock(&self) -> LockResult<MutexGuard<'_, InnerMap>> {
let mut guard = self.map.lock()?;
while let Ok((key, value, write_content)) = self.queue.pop() {
guard.entry(key).or_default().insert(value, write_content);
}
Ok(guard)
}
pub fn insert(
&self,
key: String,
invalidator: Invalidator,
write_content: Option<WriteContent>,
) {
self.queue
.push((key, invalidator, write_content))
.unwrap_or_else(|err| {
let (key, ..) = err.into_inner();
// PushError<T> is not Debug
panic!(
"failed to push {key:?} queue push should never fail, queue is unbounded and \
never closed"
)
});
}
}
impl Serialize for InvalidatorMap {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_newtype_struct("InvalidatorMap", &*self.lock().unwrap())
}
}
impl<'de> Deserialize<'de> for InvalidatorMap {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct V;
impl<'de> Visitor<'de> for V {
type Value = InvalidatorMap;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "an InvalidatorMap")
}
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
Ok(InvalidatorMap {
queue: ConcurrentQueue::unbounded(),
map: Mutex::new(Deserialize::deserialize(deserializer)?),
})
}
}
deserializer.deserialize_newtype_struct("InvalidatorMap", V)
}
}
|