1//! An immutable map constructed at compile time.
2use core::fmt;
3use core::iter::FusedIterator;
4use core::iter::IntoIterator;
5use core::ops::Index;
6use core::slice;
7use phf_shared::{self, HashKey, PhfBorrow, PhfHash};
8#[cfg(feature = "serde")]
9use serde::ser::{Serialize, SerializeMap, Serializer};
10
11/// An immutable map constructed at compile time.
12///
13/// ## Note
14///
15/// The fields of this struct are public so that they may be initialized by the
16/// `phf_map!` macro and code generation. They are subject to change at any
17/// time and should never be accessed directly.
18pub struct Map<K: 'static, V: 'static> {
19 #[doc(hidden)]
20 pub key: HashKey,
21 #[doc(hidden)]
22 pub disps: &'static [(u32, u32)],
23 #[doc(hidden)]
24 pub entries: &'static [(K, V)],
25}
26
27impl<K, V> fmt::Debug for Map<K, V>
28where
29 K: fmt::Debug,
30 V: fmt::Debug,
31{
32 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
33 fmt.debug_map().entries(self.entries()).finish()
34 }
35}
36
37impl<'a, K, V, T: ?Sized> Index<&'a T> for Map<K, V>
38where
39 T: Eq + PhfHash,
40 K: PhfBorrow<T>,
41{
42 type Output = V;
43
44 fn index(&self, k: &'a T) -> &V {
45 self.get(k).expect(msg:"invalid key")
46 }
47}
48
49impl<K, V> Default for Map<K, V> {
50 fn default() -> Self {
51 Self::new()
52 }
53}
54
55impl<K, V> PartialEq for Map<K, V>
56where
57 K: PartialEq,
58 V: PartialEq,
59{
60 fn eq(&self, other: &Self) -> bool {
61 self.key == other.key && self.disps == other.disps && self.entries == other.entries
62 }
63}
64
65impl<K, V> Eq for Map<K, V>
66where
67 K: Eq,
68 V: Eq,
69{
70}
71
72impl<K, V> Map<K, V> {
73 /// Create a new, empty, immutable map.
74 #[inline]
75 pub const fn new() -> Self {
76 Self {
77 key: 0,
78 disps: &[],
79 entries: &[],
80 }
81 }
82
83 /// Returns the number of entries in the `Map`.
84 #[inline]
85 pub const fn len(&self) -> usize {
86 self.entries.len()
87 }
88
89 /// Returns true if the `Map` is empty.
90 #[inline]
91 pub const fn is_empty(&self) -> bool {
92 self.len() == 0
93 }
94
95 /// Determines if `key` is in the `Map`.
96 pub fn contains_key<T: ?Sized>(&self, key: &T) -> bool
97 where
98 T: Eq + PhfHash,
99 K: PhfBorrow<T>,
100 {
101 self.get(key).is_some()
102 }
103
104 /// Returns a reference to the value that `key` maps to.
105 pub fn get<T: ?Sized>(&self, key: &T) -> Option<&V>
106 where
107 T: Eq + PhfHash,
108 K: PhfBorrow<T>,
109 {
110 self.get_entry(key).map(|e| e.1)
111 }
112
113 /// Returns a reference to the map's internal static instance of the given
114 /// key.
115 ///
116 /// This can be useful for interning schemes.
117 pub fn get_key<T: ?Sized>(&self, key: &T) -> Option<&K>
118 where
119 T: Eq + PhfHash,
120 K: PhfBorrow<T>,
121 {
122 self.get_entry(key).map(|e| e.0)
123 }
124
125 /// Like `get`, but returns both the key and the value.
126 pub fn get_entry<T: ?Sized>(&self, key: &T) -> Option<(&K, &V)>
127 where
128 T: Eq + PhfHash,
129 K: PhfBorrow<T>,
130 {
131 if self.disps.is_empty() {
132 return None;
133 } //Prevent panic on empty map
134 let hashes = phf_shared::hash(key, &self.key);
135 let index = phf_shared::get_index(&hashes, self.disps, self.entries.len());
136 let entry = &self.entries[index as usize];
137 let b: &T = entry.0.borrow();
138 if b == key {
139 Some((&entry.0, &entry.1))
140 } else {
141 None
142 }
143 }
144
145 /// Returns an iterator over the key/value pairs in the map.
146 ///
147 /// Entries are returned in an arbitrary but fixed order.
148 pub fn entries(&self) -> Entries<'_, K, V> {
149 Entries {
150 iter: self.entries.iter(),
151 }
152 }
153
154 /// Returns an iterator over the keys in the map.
155 ///
156 /// Keys are returned in an arbitrary but fixed order.
157 pub fn keys(&self) -> Keys<'_, K, V> {
158 Keys {
159 iter: self.entries(),
160 }
161 }
162
163 /// Returns an iterator over the values in the map.
164 ///
165 /// Values are returned in an arbitrary but fixed order.
166 pub fn values(&self) -> Values<'_, K, V> {
167 Values {
168 iter: self.entries(),
169 }
170 }
171}
172
173impl<'a, K, V> IntoIterator for &'a Map<K, V> {
174 type Item = (&'a K, &'a V);
175 type IntoIter = Entries<'a, K, V>;
176
177 fn into_iter(self) -> Entries<'a, K, V> {
178 self.entries()
179 }
180}
181
182/// An iterator over the key/value pairs in a `Map`.
183pub struct Entries<'a, K, V> {
184 iter: slice::Iter<'a, (K, V)>,
185}
186
187impl<'a, K, V> Clone for Entries<'a, K, V> {
188 #[inline]
189 fn clone(&self) -> Self {
190 Self {
191 iter: self.iter.clone(),
192 }
193 }
194}
195
196impl<'a, K, V> fmt::Debug for Entries<'a, K, V>
197where
198 K: fmt::Debug,
199 V: fmt::Debug,
200{
201 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
202 f.debug_list().entries(self.clone()).finish()
203 }
204}
205
206impl<'a, K, V> Iterator for Entries<'a, K, V> {
207 type Item = (&'a K, &'a V);
208
209 fn next(&mut self) -> Option<(&'a K, &'a V)> {
210 self.iter.next().map(|&(ref k: &K, ref v: &V)| (k, v))
211 }
212
213 fn size_hint(&self) -> (usize, Option<usize>) {
214 self.iter.size_hint()
215 }
216}
217
218impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V> {
219 fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
220 self.iter.next_back().map(|e: &'a (K, V)| (&e.0, &e.1))
221 }
222}
223
224impl<'a, K, V> ExactSizeIterator for Entries<'a, K, V> {}
225
226impl<'a, K, V> FusedIterator for Entries<'a, K, V> {}
227
228/// An iterator over the keys in a `Map`.
229pub struct Keys<'a, K, V> {
230 iter: Entries<'a, K, V>,
231}
232
233impl<'a, K, V> Clone for Keys<'a, K, V> {
234 #[inline]
235 fn clone(&self) -> Self {
236 Self {
237 iter: self.iter.clone(),
238 }
239 }
240}
241
242impl<'a, K, V> fmt::Debug for Keys<'a, K, V>
243where
244 K: fmt::Debug,
245{
246 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
247 f.debug_list().entries(self.clone()).finish()
248 }
249}
250
251impl<'a, K, V> Iterator for Keys<'a, K, V> {
252 type Item = &'a K;
253
254 fn next(&mut self) -> Option<&'a K> {
255 self.iter.next().map(|e: (&'a K, &'a V)| e.0)
256 }
257
258 fn size_hint(&self) -> (usize, Option<usize>) {
259 self.iter.size_hint()
260 }
261}
262
263impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
264 fn next_back(&mut self) -> Option<&'a K> {
265 self.iter.next_back().map(|e: (&'a K, &'a V)| e.0)
266 }
267}
268
269impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
270
271impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
272
273/// An iterator over the values in a `Map`.
274pub struct Values<'a, K, V> {
275 iter: Entries<'a, K, V>,
276}
277
278impl<'a, K, V> Clone for Values<'a, K, V> {
279 #[inline]
280 fn clone(&self) -> Self {
281 Self {
282 iter: self.iter.clone(),
283 }
284 }
285}
286
287impl<'a, K, V> fmt::Debug for Values<'a, K, V>
288where
289 V: fmt::Debug,
290{
291 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
292 f.debug_list().entries(self.clone()).finish()
293 }
294}
295
296impl<'a, K, V> Iterator for Values<'a, K, V> {
297 type Item = &'a V;
298
299 fn next(&mut self) -> Option<&'a V> {
300 self.iter.next().map(|e: (&'a K, &'a V)| e.1)
301 }
302
303 fn size_hint(&self) -> (usize, Option<usize>) {
304 self.iter.size_hint()
305 }
306}
307
308impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
309 fn next_back(&mut self) -> Option<&'a V> {
310 self.iter.next_back().map(|e: (&'a K, &'a V)| e.1)
311 }
312}
313
314impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
315
316impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
317
318#[cfg(feature = "serde")]
319impl<K, V> Serialize for Map<K, V>
320where
321 K: Serialize,
322 V: Serialize,
323{
324 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
325 where
326 S: Serializer,
327 {
328 let mut map = serializer.serialize_map(Some(self.len()))?;
329 for (k, v) in self.entries() {
330 map.serialize_entry(k, v)?;
331 }
332 map.end()
333 }
334}
335