fjadra 0.1.0

Library for simulating physical forces on particles
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

#[derive(Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct Handle<T>(usize, std::marker::PhantomData<T>);

impl<T> Clone for Handle<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Copy for Handle<T> {}

// For now we only support inserting data to the tree, so we can get away with a
// simple `Vec`-based store.
#[derive(Clone)]
pub struct Store<T>(Vec<T>);

impl<T> Default for Store<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T> Store<T> {
    pub fn new() -> Self {
        Self(Vec::new())
    }

    pub fn insert(&mut self, value: T) -> Handle<T> {
        let handle = Handle(self.0.len(), std::marker::PhantomData);
        self.0.push(value);
        handle
    }

    pub fn get(&self, handle: Handle<T>) -> &T {
        &self.0[handle.0]
    }

    pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
        &mut self.0[handle.0]
    }

    pub fn iter(&self) -> impl Iterator<Item = (Handle<T>, &T)> {
        self.0
            .iter()
            .enumerate()
            .map(|(i, v)| (Handle(i, std::marker::PhantomData), v))
    }
}

impl<T: std::fmt::Debug> std::fmt::Debug for Store<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let vs = self.iter().collect::<Vec<_>>();
        write!(f, "Store({vs:?})")
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn insert_and_get() {
        let mut store = Store::new();
        let handle = store.insert(42);
        assert_eq!(*store.get(handle), 42);
    }

    #[test]
    fn insert_and_get_mut() {
        let mut store = Store::new();
        let handle = store.insert(42);
        *store.get_mut(handle) = 43;
        assert_eq!(*store.get(handle), 43);
    }
}