truck-platform 0.6.0

graphic utility library based on wgpu
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
100
101
102
103
104
105

#![allow(dead_code)]

use rustc_hash::FxHashMap as HashMap;
use std::hash::Hash;

/// Hashmap for optimizing iteration.
#[derive(Clone, Debug)]
pub struct SliceHashMap<K, V> {
    vec: Vec<(K, V)>,
    map: HashMap<K, usize>,
}

impl<K, V> Default for SliceHashMap<K, V> {
    fn default() -> Self {
        SliceHashMap {
            vec: Vec::new(),
            map: HashMap::default(),
        }
    }
}

impl<K: Copy + Eq + Hash, V> SliceHashMap<K, V> {
    pub fn new() -> Self { Self::default() }
    pub fn get(&self, key: &K) -> Option<&V> { self.map.get(key).map(|idx| &self.vec[*idx].1) }
    pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
        let idx = *self.map.get(key)?;
        Some(&mut self.vec[idx].1)
    }
    pub fn len(&self) -> usize { self.vec.len() }
    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
        match self.map.get(&key) {
            Some(idx) => {
                self.vec.push((key, value));
                Some(self.vec.swap_remove(*idx).1)
            }
            None => {
                self.map.insert(key, self.vec.len());
                self.vec.push((key, value));
                None
            }
        }
    }
    pub fn remove(&mut self, key: &K) -> Option<V> {
        self.map.remove(key).map(|idx| {
            let output = self.vec.swap_remove(idx);
            if idx < self.vec.len() {
                let key = self.vec[idx].0;
                *self.map.get_mut(&key).unwrap() = idx;
            }
            output.1
        })
    }
    pub fn clear(&mut self) {
        self.vec.clear();
        self.map.clear();
    }
    pub fn as_slice(&self) -> &[(K, V)] { &self.vec }
}

impl<K, V> IntoIterator for SliceHashMap<K, V> {
    type Item = (K, V);
    type IntoIter = <Vec<(K, V)> as IntoIterator>::IntoIter;
    fn into_iter(self) -> Self::IntoIter { self.vec.into_iter() }
}

impl<'a, K, V> IntoIterator for &'a SliceHashMap<K, V> {
    type Item = &'a (K, V);
    type IntoIter = <&'a Vec<(K, V)> as IntoIterator>::IntoIter;
    fn into_iter(self) -> Self::IntoIter { self.vec.iter() }
}

impl<K: Copy + Eq + Hash, V> FromIterator<(K, V)> for SliceHashMap<K, V> {
    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
        let mut res = Self::default();
        iter.into_iter().enumerate().for_each(|(i, (key, val))| {
            res.vec.push((key, val));
            res.map.insert(key, i);
        });
        res
    }
}

#[test]
fn sliced_hashmap() {
    let mut map: SliceHashMap<_, _> = (0..100).map(|i| (i, 100 - i)).collect();
    assert_eq!(map.len(), 100);
    assert_eq!(map.vec.len(), map.map.len());
    for i in 0..100 {
        assert_eq!(map.insert(i, i + 200).unwrap(), 100 - i);
        assert_eq!(map.vec.len(), map.map.len());
    }
    for i in 0..100 {
        assert_eq!(*map.get(&i).unwrap(), i + 200);
        assert_eq!(map.vec.len(), map.map.len());
    }
    assert!(map.insert(100, 300).is_none());
    assert_eq!(map.len(), 101);
    for i in 0..100 {
        assert_eq!(map.remove(&i).unwrap(), i + 200);
        assert_eq!(map.vec.len(), map.map.len());
    }
    assert_eq!(map.len(), 1);
    map.clear();
    assert_eq!(map.len(), 0);
}