jay-compositor 1.14.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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use {
    crate::{
        client::{Client, ClientId},
        object::{Object, ObjectId, Version},
        utils::copyhashmap::{CopyHashMap, Locked},
    },
    ahash::AHashMap,
    derivative::Derivative,
    std::{
        cell::{Ref, RefCell},
        collections::hash_map::Entry,
        rc::Rc,
    },
};

#[derive(Derivative)]
#[derivative(Default(bound = ""))]
pub struct Bindings<P> {
    bindings: CopyHashMap<(ClientId, ObjectId), Rc<P>>,
}

impl<P: Object> Bindings<P> {
    pub fn add(&self, client: &Client, obj: &Rc<P>) {
        let prev = self.bindings.set((client.id, obj.id()), obj.clone());
        assert!(prev.is_none());
    }

    pub fn remove(&self, client: &Client, obj: &P) {
        self.bindings.remove(&(client.id, obj.id()));
    }

    pub fn clear(&self) {
        self.bindings.clear();
    }

    pub fn lock(&self) -> Locked<'_, (ClientId, ObjectId), Rc<P>> {
        self.bindings.lock()
    }
}

#[derive(Derivative)]
#[derivative(Default(bound = ""))]
pub struct PerClientBindings<P> {
    bindings: RefCell<AHashMap<ClientId, AHashMap<ObjectId, Rc<P>>>>,
}

impl<P: Object> PerClientBindings<P> {
    pub fn add(&self, client: &Client, obj: &Rc<P>) {
        let prev = self
            .bindings
            .borrow_mut()
            .entry(client.id)
            .or_default()
            .insert(obj.id(), obj.clone());
        assert!(prev.is_none());
    }

    pub fn remove(&self, client: &Client, obj: &P) {
        if let Entry::Occupied(mut oe) = self.bindings.borrow_mut().entry(client.id) {
            oe.get_mut().remove(&obj.id());
            if oe.get().is_empty() {
                oe.remove();
            }
        }
    }

    pub fn clear(&self) {
        self.bindings.borrow_mut().clear();
    }

    pub fn for_each(&self, client: ClientId, version: Version, mut f: impl FnMut(&P)) {
        if let Some(bindings) = self.bindings.borrow().get(&client) {
            for obj in bindings.values() {
                if obj.version() >= version {
                    f(obj);
                }
            }
        }
    }

    pub fn borrow(&self) -> Ref<'_, AHashMap<ClientId, AHashMap<ObjectId, Rc<P>>>> {
        self.bindings.borrow()
    }
}