1 #![allow(dead_code)]
2 
3 #[derive(Clone)]
4 pub struct VecMap<K, V> {
5     vec: Vec<(K, V)>,
6 }
7 
8 impl<K: PartialEq, V> VecMap<K, V> {
9     #[inline]
with_capacity(cap: usize) -> VecMap<K, V>10     pub fn with_capacity(cap: usize) -> VecMap<K, V> {
11         VecMap {
12             vec: Vec::with_capacity(cap),
13         }
14     }
15 
16     #[inline]
insert(&mut self, key: K, value: V)17     pub fn insert(&mut self, key: K, value: V) {
18         match self.find(&key) {
19             Some(pos) => self.vec[pos] = (key, value),
20             None => self.vec.push((key, value)),
21         }
22     }
23 
24     #[inline]
entry(&mut self, key: K) -> Entry<'_, K, V>25     pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
26         match self.find(&key) {
27             Some(pos) => Entry::Occupied(OccupiedEntry {
28                 vec: self,
29                 pos: pos,
30             }),
31             None => Entry::Vacant(VacantEntry {
32                 vec: self,
33                 key: key,
34             }),
35         }
36     }
37 
38     #[inline]
get<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> Option<&V>39     pub fn get<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> Option<&V> {
40         self.find(key).map(move |pos| &self.vec[pos].1)
41     }
42 
43     #[inline]
get_mut<K2: PartialEq<K> + ?Sized>(&mut self, key: &K2) -> Option<&mut V>44     pub fn get_mut<K2: PartialEq<K> + ?Sized>(&mut self, key: &K2) -> Option<&mut V> {
45         self.find(key).map(move |pos| &mut self.vec[pos].1)
46     }
47 
48     #[inline]
contains_key<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> bool49     pub fn contains_key<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> bool {
50         self.find(key).is_some()
51     }
52 
53     #[inline]
len(&self) -> usize54     pub fn len(&self) -> usize {
55         self.vec.len()
56     }
57 
58     #[inline]
iter(&self) -> ::std::slice::Iter<'_, (K, V)>59     pub fn iter(&self) -> ::std::slice::Iter<'_, (K, V)> {
60         self.vec.iter()
61     }
62     #[inline]
remove<K2: PartialEq<K> + ?Sized>(&mut self, key: &K2) -> Option<V>63     pub fn remove<K2: PartialEq<K> + ?Sized>(&mut self, key: &K2) -> Option<V> {
64         self.find(key)
65             .map(|pos| self.vec.remove(pos))
66             .map(|(_, v)| v)
67     }
68     #[inline]
clear(&mut self)69     pub fn clear(&mut self) {
70         self.vec.clear();
71     }
72 
73     #[inline]
find<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> Option<usize>74     fn find<K2: PartialEq<K> + ?Sized>(&self, key: &K2) -> Option<usize> {
75         self.vec.iter().position(|entry| key == &entry.0)
76     }
77 }
78 
79 pub enum Entry<'a, K: 'a, V: 'a> {
80     Vacant(VacantEntry<'a, K, V>),
81     Occupied(OccupiedEntry<'a, K, V>),
82 }
83 
84 pub struct VacantEntry<'a, K, V> {
85     vec: &'a mut VecMap<K, V>,
86     key: K,
87 }
88 
89 impl<'a, K, V> VacantEntry<'a, K, V> {
insert(self, val: V) -> &'a mut V90     pub fn insert(self, val: V) -> &'a mut V {
91         let vec = self.vec;
92         vec.vec.push((self.key, val));
93         let pos = vec.vec.len() - 1;
94         &mut vec.vec[pos].1
95     }
96 }
97 
98 pub struct OccupiedEntry<'a, K, V> {
99     vec: &'a mut VecMap<K, V>,
100     pos: usize,
101 }
102 
103 impl<'a, K, V> OccupiedEntry<'a, K, V> {
into_mut(self) -> &'a mut V104     pub fn into_mut(self) -> &'a mut V {
105         &mut self.vec.vec[self.pos].1
106     }
107 }
108