jay-compositor 1.13.0

The Jay compositor
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

use {
    crate::utils::{stack::Stack, thread_id::ThreadId},
    isnt::std_1::primitive::IsntConstPtrExt,
    std::{any::Any, cell::Cell, convert::Infallible, rc::Rc},
};

#[cfg(test)]
mod tests;

pub struct ThreadLocalData<T>
where
    T: 'static,
{
    thread_id: ThreadId,
    ptr: Cell<*const T>,
}

thread_local! {
    static HOLDER: Stack<Rc<dyn Any>> = const { Stack::new() };
}

unsafe impl<T> Send for ThreadLocalData<T> {}
unsafe impl<T> Sync for ThreadLocalData<T> {}

impl<T> ThreadLocalData<T>
where
    T: 'static,
{
    pub fn new(thread_id: ThreadId) -> Self {
        Self {
            thread_id,
            ptr: Default::default(),
        }
    }

    #[cfg_attr(not(test), expect(dead_code))]
    pub fn get_or_create(&self, init: impl FnOnce() -> Rc<T>) -> Rc<T> {
        self.get_or_try_create::<Infallible>(|| Ok(init())).unwrap()
    }

    pub fn get_or_try_create<E>(
        &self,
        init: impl FnOnce() -> Result<Rc<T>, E>,
    ) -> Result<Rc<T>, E> {
        assert!(self.thread_id.is_current());
        HOLDER.with(|h| {
            let ptr = self.ptr.get();
            if ptr.is_not_null() {
                unsafe {
                    Rc::increment_strong_count(ptr);
                    return Ok(Rc::from_raw(ptr));
                }
            }
            let rc = init()?;
            h.push(rc.clone());
            self.ptr.set(Rc::as_ptr(&rc));
            Ok(rc)
        })
    }
}