ohkami_lib/
map.rs

1/// Key-Value map to handle a few entires.
2///
3/// Usually, a web app handles 0 ~ 4 custom headers, and so
4/// simple `Vec<(K, V)>` is efficient than `HashMap<K, V>`
5/// to store/iterate/mutate.
6pub struct TupleMap<K: PartialEq, V>(Vec<(K, V)>);
7
8impl<K: PartialEq, V> TupleMap<K, V> {
9    pub fn new() -> Self {
10        Self(Vec::new())
11    }
12
13    #[inline]
14    pub fn get<Q>(&self, key: &Q) -> Option<&V>
15    where
16        K: std::borrow::Borrow<Q>,
17        Q: PartialEq + ?Sized,
18    {
19        for (k, v) in &self.0 {
20            if key == k.borrow() {
21                return Some(v);
22            }
23        }
24        None
25    }
26    #[inline]
27    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
28    where
29        K: std::borrow::Borrow<Q>,
30        Q: PartialEq + ?Sized,
31    {
32        for (k, v) in &mut self.0 {
33            if key == k.borrow() {
34                return Some(v);
35            }
36        }
37        None
38    }
39
40    #[inline]
41    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
42        for (k, v) in &mut self.0 {
43            if &key == k {
44                return Some(std::mem::replace(v, value));
45            }
46        }
47        {
48            self.0.push((key, value));
49            None
50        }
51    }
52
53    #[inline]
54    pub fn remove(&mut self, key: K) -> Option<V> {
55        for i in 0..self.0.len() {
56            if key == unsafe { self.0.get_unchecked(i) }.0 {
57                return Some(self.0.swap_remove(i).1);
58            }
59        }
60        None
61    }
62
63    pub fn append(&mut self, another: Self) {
64        for (k, v) in another.into_iter() {
65            self.insert(k, v);
66        }
67    }
68
69    pub fn clear(&mut self) {
70        self.0.clear();
71    }
72
73    pub fn iter(&self) -> impl Iterator<Item = &(K, V)> {
74        self.0.iter()
75    }
76
77    pub fn keys(&self) -> impl Iterator<Item = &K> {
78        self.iter().map(|(k, _)| k)
79    }
80    pub fn values(&self) -> impl Iterator<Item = &V> {
81        self.iter().map(|(_, v)| v)
82    }
83}
84
85impl<K: PartialEq, V> Default for TupleMap<K, V> {
86    fn default() -> Self {
87        Self::new()
88    }
89}
90
91impl<K: PartialEq, V> FromIterator<(K, V)> for TupleMap<K, V> {
92    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
93        Self(iter.into_iter().collect())
94    }
95}
96
97impl<K: PartialEq, V> std::iter::IntoIterator for TupleMap<K, V> {
98    type Item = (K, V);
99    type IntoIter = std::vec::IntoIter<(K, V)>;
100    fn into_iter(self) -> Self::IntoIter {
101        self.0.into_iter()
102    }
103}
104
105impl<K: PartialEq, V: PartialEq> PartialEq for TupleMap<K, V> {
106    fn eq(&self, other: &Self) -> bool {
107        self.0 == other.0
108    }
109}
110
111impl<K: Clone + PartialEq, V: Clone> Clone for TupleMap<K, V> {
112    fn clone(&self) -> Self {
113        Self(self.0.clone())
114    }
115}
116
117impl<K: PartialEq, V> std::fmt::Debug for TupleMap<K, V>
118where
119    K: std::fmt::Debug,
120    V: std::fmt::Debug,
121{
122    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
123        f.debug_map()
124            .entries(self.iter().map(|(k, v)| (k, v)))
125            .finish()
126    }
127}
128
129impl<'de, K: PartialEq, V> serde::Deserialize<'de> for TupleMap<K, V>
130where
131    K: serde::Deserialize<'de>,
132    V: serde::Deserialize<'de>,
133{
134    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
135        return deserializer.deserialize_map(TupleMapVisitor(std::marker::PhantomData));
136
137        /////////////////////////////////////////////////////////////////////////
138
139        struct TupleMapVisitor<K, V>(std::marker::PhantomData<fn() -> (K, V)>);
140
141        impl<'de, K: PartialEq, V> serde::de::Visitor<'de> for TupleMapVisitor<K, V>
142        where
143            K: serde::Deserialize<'de>,
144            V: serde::Deserialize<'de>,
145        {
146            type Value = TupleMap<K, V>;
147
148            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
149                f.write_str("a map")
150            }
151
152            #[inline]
153            fn visit_map<A: serde::de::MapAccess<'de>>(
154                self,
155                mut access: A,
156            ) -> Result<Self::Value, A::Error> {
157                let mut map = TupleMap::new();
158                while let Some((k, v)) = access.next_entry()? {
159                    map.insert(k, v);
160                }
161                Ok(map)
162            }
163        }
164    }
165}
ohkami_lib/map.rs

ohkami_lib/
map.rs
