wasmtime_environ/collections/
index_map.rs

1use crate::{
2    collections::{TryClone, TryFromIterator},
3    error::OutOfMemory,
4};
5use core::{
6    borrow::Borrow,
7    cmp::Ordering,
8    fmt,
9    hash::{BuildHasher, Hash},
10    marker::PhantomData,
11    mem,
12    ops::{Index, IndexMut, RangeBounds},
13};
14use indexmap::map as inner;
15
16#[cfg(feature = "std")]
17use std::hash::RandomState as DefaultHashBuilder;
18
19#[cfg(not(feature = "std"))]
20use hashbrown::DefaultHashBuilder;
21
22/// A wrapper around [`indexmap::IndexMap`] that only provides fallible
23/// allocation.
24pub struct TryIndexMap<K, V, S = DefaultHashBuilder> {
25    inner: indexmap::IndexMap<K, V, S>,
26}
27
28impl<K, V, S> TryClone for TryIndexMap<K, V, S>
29where
30    K: Eq + Hash + TryClone,
31    V: TryClone,
32    S: BuildHasher + TryClone,
33{
34    fn try_clone(&self) -> Result<Self, OutOfMemory> {
35        let mut map = Self::with_capacity_and_hasher(self.capacity(), self.hasher().try_clone()?)?;
36        for (k, v) in self.iter() {
37            map.insert(k.try_clone()?, v.try_clone()?)?;
38        }
39        Ok(map)
40    }
41}
42
43impl<K, V, S> fmt::Debug for TryIndexMap<K, V, S>
44where
45    K: fmt::Debug,
46    V: fmt::Debug,
47    S: fmt::Debug,
48{
49    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
50        fmt::Debug::fmt(&self.inner, f)
51    }
52}
53
54impl<K, V, S> From<TryIndexMap<K, V, S>> for indexmap::IndexMap<K, V, S> {
55    fn from(map: TryIndexMap<K, V, S>) -> Self {
56        map.inner
57    }
58}
59
60impl<K, V, S> From<indexmap::IndexMap<K, V, S>> for TryIndexMap<K, V, S> {
61    fn from(inner: indexmap::IndexMap<K, V, S>) -> Self {
62        Self { inner }
63    }
64}
65
66impl<K, V, H> serde::ser::Serialize for TryIndexMap<K, V, H>
67where
68    K: serde::ser::Serialize,
69    V: serde::ser::Serialize,
70{
71    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
72    where
73        S: serde::Serializer,
74    {
75        use serde::ser::SerializeMap as _;
76        let mut map = serializer.serialize_map(Some(self.len()))?;
77        for (k, v) in self {
78            map.serialize_entry(k, v)?;
79        }
80        map.end()
81    }
82}
83
84impl<'de, K, V> serde::de::Deserialize<'de> for TryIndexMap<K, V>
85where
86    K: serde::de::Deserialize<'de> + Hash + Eq,
87    V: serde::de::Deserialize<'de>,
88{
89    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
90    where
91        D: serde::Deserializer<'de>,
92    {
93        struct Visitor<K, V>(PhantomData<fn() -> TryIndexMap<K, V>>);
94
95        impl<'de, K, V> serde::de::Visitor<'de> for Visitor<K, V>
96        where
97            K: serde::de::Deserialize<'de> + Hash + Eq,
98            V: serde::de::Deserialize<'de>,
99        {
100            type Value = TryIndexMap<K, V>;
101
102            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
103                f.write_str("an `IndexMap`")
104            }
105
106            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
107            where
108                A: serde::de::MapAccess<'de>,
109            {
110                use serde::de::Error as _;
111
112                let mut result = TryIndexMap::<K, V>::new();
113
114                if let Some(len) = map.size_hint() {
115                    result.reserve(len).map_err(|oom| A::Error::custom(oom))?;
116                }
117
118                while let Some((k, v)) = map.next_entry::<K, V>()? {
119                    result.insert(k, v).map_err(|oom| A::Error::custom(oom))?;
120                }
121
122                Ok(result)
123            }
124        }
125
126        deserializer.deserialize_map(Visitor(PhantomData))
127    }
128}
129
130impl<K, V> TryFromIterator<(K, V), OutOfMemory> for TryIndexMap<K, V>
131where
132    K: Hash + Eq,
133{
134    fn try_from_iter<I>(iter: I) -> Result<Self, OutOfMemory>
135    where
136        I: Iterator<Item = (K, V)>,
137    {
138        let mut map = Self::with_capacity(iter.size_hint().0)?;
139        for (k, v) in iter {
140            map.insert(k, v)?;
141        }
142        Ok(map)
143    }
144}
145
146impl<K, V, E> TryFromIterator<Result<(K, V), E>, E> for TryIndexMap<K, V>
147where
148    K: Hash + Eq,
149    E: From<OutOfMemory>,
150{
151    fn try_from_iter<I>(iter: I) -> Result<Self, E>
152    where
153        I: Iterator<Item = Result<(K, V), E>>,
154    {
155        let mut map = Self::with_capacity(iter.size_hint().0)?;
156        for item in iter {
157            let (k, v) = item?;
158            map.insert(k, v)?;
159        }
160        Ok(map)
161    }
162}
163
164impl<K, V> TryIndexMap<K, V> {
165    /// Same as [`indexmap::IndexMap::new`].
166    pub fn new() -> Self {
167        Self {
168            inner: indexmap::IndexMap::with_hasher(<_>::default()),
169        }
170    }
171
172    /// Same as [`indexmap::IndexMap::with_capacity`] but returns an error on
173    /// allocation failure.
174    pub fn with_capacity(n: usize) -> Result<Self, OutOfMemory> {
175        Self::with_capacity_and_hasher(n, <_>::default())
176    }
177}
178
179impl<K, V, S> TryIndexMap<K, V, S> {
180    /// Same as [`indexmap::IndexMap::with_capacity_and_hasher`] but returns an
181    /// error on allocation failure.
182    pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> Result<Self, OutOfMemory> {
183        let mut map = Self::with_hasher(hash_builder);
184        map.reserve(n)?;
185        Ok(map)
186    }
187
188    /// Same as [`indexmap::IndexMap::with_hasher`].
189    pub const fn with_hasher(hash_builder: S) -> Self {
190        TryIndexMap {
191            inner: indexmap::IndexMap::with_hasher(hash_builder),
192        }
193    }
194
195    /// Same as [`indexmap::IndexMap::capacity`].
196    pub fn capacity(&self) -> usize {
197        self.inner.capacity()
198    }
199
200    /// Same as [`indexmap::IndexMap::hasher`].
201    pub fn hasher(&self) -> &S {
202        self.inner.hasher()
203    }
204
205    /// Same as [`indexmap::IndexMap::len`].
206    pub fn len(&self) -> usize {
207        self.inner.len()
208    }
209
210    /// Same as [`indexmap::IndexMap::is_empty`].
211    pub fn is_empty(&self) -> bool {
212        self.inner.is_empty()
213    }
214
215    /// Same as [`indexmap::IndexMap::iter`].
216    pub fn iter(&self) -> inner::Iter<'_, K, V> {
217        self.inner.iter()
218    }
219
220    /// Same as [`indexmap::IndexMap::iter_mut`].
221    pub fn iter_mut(&mut self) -> inner::IterMut<'_, K, V> {
222        self.inner.iter_mut()
223    }
224
225    /// Same as [`indexmap::IndexMap::keys`].
226    pub fn keys(&self) -> inner::Keys<'_, K, V> {
227        self.inner.keys()
228    }
229
230    /// Same as [`indexmap::IndexMap::into_keys`].
231    pub fn into_keys(self) -> inner::IntoKeys<K, V> {
232        self.inner.into_keys()
233    }
234
235    /// Same as [`indexmap::IndexMap::values`].
236    pub fn values(&self) -> inner::Values<'_, K, V> {
237        self.inner.values()
238    }
239
240    /// Same as [`indexmap::IndexMap::values_mut`].
241    pub fn values_mut(&mut self) -> inner::ValuesMut<'_, K, V> {
242        self.inner.values_mut()
243    }
244
245    /// Same as [`indexmap::IndexMap::into_values`].
246    pub fn into_values(self) -> inner::IntoValues<K, V> {
247        self.inner.into_values()
248    }
249
250    /// Same as [`indexmap::IndexMap::clear`].
251    pub fn clear(&mut self) {
252        self.inner.clear()
253    }
254
255    /// Same as [`indexmap::IndexMap::truncate`].
256    pub fn truncate(&mut self, len: usize) {
257        self.inner.truncate(len);
258    }
259
260    /// Same as [`indexmap::IndexMap::drain`].
261    pub fn drain<R>(&mut self, range: R) -> inner::Drain<'_, K, V>
262    where
263        R: RangeBounds<usize>,
264    {
265        self.inner.drain(range)
266    }
267
268    /// Same as [`indexmap::IndexMap::extract_if`].
269    pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> inner::ExtractIf<'_, K, V, F>
270    where
271        F: FnMut(&K, &mut V) -> bool,
272        R: RangeBounds<usize>,
273    {
274        self.inner.extract_if(range, pred)
275    }
276
277    /// Same as [`indexmap::IndexMap::split_off`] but returns an error on
278    /// allocation failure.
279    pub fn split_off(&mut self, at: usize) -> Result<Self, OutOfMemory>
280    where
281        K: Eq + Hash,
282        S: BuildHasher + TryClone,
283    {
284        assert!(at <= self.len());
285        let mut map = Self::with_capacity_and_hasher(self.len() - at, self.hasher().try_clone()?)?;
286        for (k, v) in self.drain(at..) {
287            map.insert(k, v)?;
288        }
289        Ok(map)
290    }
291
292    /// Same as [`indexmap::IndexMap::reserve`] but returns an error on
293    /// allocation failure.
294    pub fn reserve(&mut self, additional: usize) -> Result<(), OutOfMemory> {
295        self.inner.try_reserve(additional).map_err(|_| {
296            let new_len = self.len().saturating_add(additional);
297            OutOfMemory::new(
298                new_len
299                    .saturating_mul(mem::size_of::<K>())
300                    .saturating_add(new_len.saturating_mul(mem::size_of::<V>())),
301            )
302        })
303    }
304
305    /// Same as [`indexmap::IndexMap::reserve_exact`] but returns an error on
306    /// allocation failure.
307    pub fn reserve_exact(&mut self, additional: usize) -> Result<(), OutOfMemory> {
308        self.inner.try_reserve_exact(additional).map_err(|_| {
309            let new_len = self.len().saturating_add(additional);
310            OutOfMemory::new(
311                new_len
312                    .saturating_mul(mem::size_of::<K>())
313                    .saturating_add(new_len.saturating_mul(mem::size_of::<V>())),
314            )
315        })
316    }
317}
318
319impl<K, V, S> TryIndexMap<K, V, S>
320where
321    K: Hash + Eq,
322    S: BuildHasher,
323{
324    /// Same as [`indexmap::IndexMap::insert`] but returns an error on
325    /// allocation failure.
326    pub fn insert(&mut self, key: K, value: V) -> Result<Option<V>, OutOfMemory> {
327        self.reserve(1)?;
328        Ok(self.inner.insert(key, value))
329    }
330
331    /// Same as [`indexmap::IndexMap::insert_full`] but returns an error on
332    /// allocation failure.
333    pub fn insert_full(&mut self, key: K, value: V) -> Result<(usize, Option<V>), OutOfMemory> {
334        self.reserve(1)?;
335        Ok(self.inner.insert_full(key, value))
336    }
337
338    /// Same as [`indexmap::IndexMap::insert_sorted`] but returns an error on
339    /// allocation failure.
340    pub fn insert_sorted(&mut self, key: K, value: V) -> Result<(usize, Option<V>), OutOfMemory>
341    where
342        K: Ord,
343    {
344        self.reserve(1)?;
345        Ok(self.inner.insert_sorted(key, value))
346    }
347
348    /// Same as [`indexmap::IndexMap::insert_sorted_by`] but returns an error on
349    /// allocation failure.
350    pub fn insert_sorted_by<F>(
351        &mut self,
352        key: K,
353        value: V,
354        cmp: F,
355    ) -> Result<(usize, Option<V>), OutOfMemory>
356    where
357        F: FnMut(&K, &V, &K, &V) -> Ordering,
358    {
359        self.reserve(1)?;
360        Ok(self.inner.insert_sorted_by(key, value, cmp))
361    }
362
363    /// Same as [`indexmap::IndexMap::insert_sorted_by_key`] but returns an
364    /// error on allocation failure.
365    pub fn insert_sorted_by_key<B, F>(
366        &mut self,
367        key: K,
368        value: V,
369        sort_key: F,
370    ) -> Result<(usize, Option<V>), OutOfMemory>
371    where
372        B: Ord,
373        F: FnMut(&K, &V) -> B,
374    {
375        self.reserve(1)?;
376        Ok(self.inner.insert_sorted_by_key(key, value, sort_key))
377    }
378
379    /// Same as [`indexmap::IndexMap::insert_before`] but returns an error on
380    /// allocation failure.
381    pub fn insert_before(
382        &mut self,
383        index: usize,
384        key: K,
385        value: V,
386    ) -> Result<(usize, Option<V>), OutOfMemory> {
387        self.reserve(1)?;
388        Ok(self.inner.insert_before(index, key, value))
389    }
390
391    /// Same as [`indexmap::IndexMap::shift_insert`] but returns an error on
392    /// allocation failure.
393    pub fn shift_insert(
394        &mut self,
395        index: usize,
396        key: K,
397        value: V,
398    ) -> Result<Option<V>, OutOfMemory> {
399        self.reserve(1)?;
400        Ok(self.inner.shift_insert(index, key, value))
401    }
402
403    /// Same as [`indexmap::IndexMap::shift_insert`].
404    pub fn replace_index(&mut self, index: usize, key: K) -> Result<K, (usize, K)> {
405        self.inner.replace_index(index, key)
406    }
407}
408
409impl<K, V, S> TryIndexMap<K, V, S>
410where
411    S: BuildHasher,
412{
413    /// Same as [`indexmap::IndexMap::contains_key`].
414    pub fn contains_key<Q>(&self, key: &Q) -> bool
415    where
416        Q: ?Sized + Hash + Eq,
417        K: Borrow<Q>,
418    {
419        self.inner.contains_key(key)
420    }
421
422    /// Same as [`indexmap::IndexMap::get`].
423    pub fn get<Q>(&self, key: &Q) -> Option<&V>
424    where
425        Q: ?Sized + Hash + Eq,
426        K: Borrow<Q>,
427    {
428        self.inner.get(key)
429    }
430
431    /// Same as [`indexmap::IndexMap::get_key_value`].
432    pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>
433    where
434        Q: ?Sized + Hash + Eq,
435        K: Borrow<Q>,
436    {
437        self.inner.get_key_value(key)
438    }
439
440    /// Same as [`indexmap::IndexMap::get_full`].
441    pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>
442    where
443        Q: ?Sized + Hash + Eq,
444        K: Borrow<Q>,
445    {
446        self.inner.get_full(key)
447    }
448
449    /// Same as [`indexmap::IndexMap::get_index_of`].
450    pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>
451    where
452        Q: ?Sized + Hash + Eq,
453        K: Borrow<Q>,
454    {
455        self.inner.get_index_of(key)
456    }
457
458    /// Same as [`indexmap::IndexMap::get_mut`].
459    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
460    where
461        Q: ?Sized + Hash + Eq,
462        K: Borrow<Q>,
463    {
464        self.inner.get_mut(key)
465    }
466
467    /// Same as [`indexmap::IndexMap::get_key_value_mut`].
468    pub fn get_key_value_mut<Q>(&mut self, key: &Q) -> Option<(&K, &mut V)>
469    where
470        Q: ?Sized + Hash + Eq,
471        K: Borrow<Q>,
472    {
473        self.inner.get_key_value_mut(key)
474    }
475
476    /// Same as [`indexmap::IndexMap::get_full_mut`].
477    pub fn get_full_mut<Q>(&mut self, key: &Q) -> Option<(usize, &K, &mut V)>
478    where
479        Q: ?Sized + Hash + Eq,
480        K: Borrow<Q>,
481    {
482        self.inner.get_full_mut(key)
483    }
484
485    /// Same as [`indexmap::IndexMap::get_disjoint_mut`].
486    pub fn get_disjoint_mut<Q, const N: usize>(&mut self, keys: [&Q; N]) -> [Option<&mut V>; N]
487    where
488        Q: ?Sized + Hash + Eq,
489        K: Borrow<Q>,
490    {
491        self.inner.get_disjoint_mut(keys)
492    }
493
494    /// Same as [`indexmap::IndexMap::swap_remove`].
495    pub fn swap_remove<Q>(&mut self, key: &Q) -> Option<V>
496    where
497        Q: ?Sized + Hash + Eq,
498        K: Borrow<Q>,
499    {
500        self.inner.swap_remove(key)
501    }
502
503    /// Same as [`indexmap::IndexMap::swap_remove_entry`].
504    pub fn swap_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
505    where
506        Q: ?Sized + Hash + Eq,
507        K: Borrow<Q>,
508    {
509        self.inner.swap_remove_entry(key)
510    }
511
512    /// Same as [`indexmap::IndexMap::swap_remove_full`].
513    pub fn swap_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
514    where
515        Q: ?Sized + Hash + Eq,
516        K: Borrow<Q>,
517    {
518        self.inner.swap_remove_full(key)
519    }
520
521    /// Same as [`indexmap::IndexMap::shift_remove`].
522    pub fn shift_remove<Q>(&mut self, key: &Q) -> Option<V>
523    where
524        Q: ?Sized + Hash + Eq,
525        K: Borrow<Q>,
526    {
527        self.inner.shift_remove(key)
528    }
529
530    /// Same as [`indexmap::IndexMap::shift_remove_entry`].
531    pub fn shift_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
532    where
533        Q: ?Sized + Hash + Eq,
534        K: Borrow<Q>,
535    {
536        self.inner.shift_remove_entry(key)
537    }
538
539    /// Same as [`indexmap::IndexMap::shift_remove_full`].
540    pub fn shift_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
541    where
542        Q: ?Sized + Hash + Eq,
543        K: Borrow<Q>,
544    {
545        self.inner.shift_remove_full(key)
546    }
547}
548
549impl<K, V, S> TryIndexMap<K, V, S> {
550    /// Same as [`indexmap::IndexMap::pop`].
551    pub fn pop(&mut self) -> Option<(K, V)> {
552        self.inner.pop()
553    }
554
555    /// Same as [`indexmap::IndexMap::retain`].
556    pub fn retain<F>(&mut self, keep: F)
557    where
558        F: FnMut(&K, &mut V) -> bool,
559    {
560        self.inner.retain(keep);
561    }
562
563    /// Same as [`indexmap::IndexMap::sort_keys`].
564    pub fn sort_keys(&mut self)
565    where
566        K: Ord,
567    {
568        self.inner.sort_keys();
569    }
570
571    /// Same as [`indexmap::IndexMap::sort_by`].
572    pub fn sort_by<F>(&mut self, cmp: F)
573    where
574        F: FnMut(&K, &V, &K, &V) -> Ordering,
575    {
576        self.inner.sort_by(cmp);
577    }
578
579    /// Same as [`indexmap::IndexMap::sorted_by`].
580    pub fn sorted_by<F>(self, cmp: F) -> inner::IntoIter<K, V>
581    where
582        F: FnMut(&K, &V, &K, &V) -> Ordering,
583    {
584        self.inner.sorted_by(cmp)
585    }
586
587    /// Same as [`indexmap::IndexMap::sort_by_key`].
588    pub fn sort_by_key<T, F>(&mut self, sort_key: F)
589    where
590        T: Ord,
591        F: FnMut(&K, &V) -> T,
592    {
593        self.inner.sort_by_key(sort_key);
594    }
595
596    /// Same as [`indexmap::IndexMap::sort_unstable_keys`].
597    pub fn sort_unstable_keys(&mut self)
598    where
599        K: Ord,
600    {
601        self.inner.sort_unstable_keys();
602    }
603
604    /// Same as [`indexmap::IndexMap::sort_unstable_by`].
605    pub fn sort_unstable_by<F>(&mut self, cmp: F)
606    where
607        F: FnMut(&K, &V, &K, &V) -> Ordering,
608    {
609        self.inner.sort_unstable_by(cmp);
610    }
611
612    /// Same as [`indexmap::IndexMap::sorted_unstable_by`].
613    pub fn sorted_unstable_by<F>(self, cmp: F) -> inner::IntoIter<K, V>
614    where
615        F: FnMut(&K, &V, &K, &V) -> Ordering,
616    {
617        self.inner.sorted_unstable_by(cmp)
618    }
619
620    /// Same as [`indexmap::IndexMap::sort_unstable_by_key`].
621    pub fn sort_unstable_by_key<T, F>(&mut self, sort_key: F)
622    where
623        T: Ord,
624        F: FnMut(&K, &V) -> T,
625    {
626        self.inner.sort_unstable_by_key(sort_key);
627    }
628
629    /// Same as [`indexmap::IndexMap::binary_search_keys`].
630    pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
631    where
632        K: Ord,
633    {
634        self.inner.binary_search_keys(x)
635    }
636
637    /// Same as [`indexmap::IndexMap::binary_search_by`].
638    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
639    where
640        F: FnMut(&'a K, &'a V) -> Ordering,
641    {
642        self.inner.binary_search_by(f)
643    }
644
645    /// Same as [`indexmap::IndexMap::binary_search_by_key`].
646    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
647    where
648        F: FnMut(&'a K, &'a V) -> B,
649        B: Ord,
650    {
651        self.inner.binary_search_by_key(b, f)
652    }
653
654    /// Same as [`indexmap::IndexMap::is_sorted`].
655    pub fn is_sorted(&self) -> bool
656    where
657        K: PartialOrd,
658    {
659        self.inner.is_sorted()
660    }
661
662    /// Same as [`indexmap::IndexMap::is_sorted_by`].
663    pub fn is_sorted_by<'a, F>(&'a self, cmp: F) -> bool
664    where
665        F: FnMut(&'a K, &'a V, &'a K, &'a V) -> bool,
666    {
667        self.inner.is_sorted_by(cmp)
668    }
669
670    /// Same as [`indexmap::IndexMap::is_sorted_by_key`].
671    pub fn is_sorted_by_key<'a, F, T>(&'a self, sort_key: F) -> bool
672    where
673        F: FnMut(&'a K, &'a V) -> T,
674        T: PartialOrd,
675    {
676        self.inner.is_sorted_by_key(sort_key)
677    }
678
679    /// Same as [`indexmap::IndexMap::partition_point`].
680    #[must_use]
681    pub fn partition_point<P>(&self, pred: P) -> usize
682    where
683        P: FnMut(&K, &V) -> bool,
684    {
685        self.inner.partition_point(pred)
686    }
687
688    /// Same as [`indexmap::IndexMap::reverse`].
689    pub fn reverse(&mut self) {
690        self.inner.reverse()
691    }
692
693    /// Same as [`indexmap::IndexMap::get_index`].
694    pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
695        self.inner.get_index(index)
696    }
697
698    /// Same as [`indexmap::IndexMap::get_index_mut`].
699    pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
700        self.inner.get_index_mut(index)
701    }
702
703    /// Same as [`indexmap::IndexMap::get_disjoint_indices_mut`].
704    pub fn get_disjoint_indices_mut<const N: usize>(
705        &mut self,
706        indices: [usize; N],
707    ) -> Result<[(&K, &mut V); N], indexmap::GetDisjointMutError> {
708        self.inner.get_disjoint_indices_mut(indices)
709    }
710
711    /// Same as [`indexmap::IndexMap::first`].
712    pub fn first(&self) -> Option<(&K, &V)> {
713        self.inner.first()
714    }
715
716    /// Same as [`indexmap::IndexMap::first_mut`].
717    pub fn first_mut(&mut self) -> Option<(&K, &mut V)> {
718        self.inner.first_mut()
719    }
720
721    /// Same as [`indexmap::IndexMap::last`].
722    pub fn last(&self) -> Option<(&K, &V)> {
723        self.inner.last()
724    }
725
726    /// Same as [`indexmap::IndexMap::last_mut`].
727    pub fn last_mut(&mut self) -> Option<(&K, &mut V)> {
728        self.inner.last_mut()
729    }
730
731    /// Same as [`indexmap::IndexMap::swap_remove_index`].
732    pub fn swap_remove_index(&mut self, index: usize) -> Option<(K, V)> {
733        self.inner.swap_remove_index(index)
734    }
735
736    /// Same as [`indexmap::IndexMap::shift_remove_index`].
737    pub fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)> {
738        self.inner.shift_remove_index(index)
739    }
740
741    /// Same as [`indexmap::IndexMap::move_index`].
742    pub fn move_index(&mut self, from: usize, to: usize) {
743        self.inner.move_index(from, to)
744    }
745
746    /// Same as [`indexmap::IndexMap::swap_indices`].
747    pub fn swap_indices(&mut self, a: usize, b: usize) {
748        self.inner.swap_indices(a, b)
749    }
750}
751
752impl<K, V, Q, S> Index<&Q> for TryIndexMap<K, V, S>
753where
754    Q: ?Sized + Hash + Eq,
755    K: Borrow<Q>,
756    S: BuildHasher,
757{
758    type Output = V;
759
760    fn index(&self, key: &Q) -> &V {
761        &self.inner[key]
762    }
763}
764
765impl<K, V, Q, S> IndexMut<&Q> for TryIndexMap<K, V, S>
766where
767    Q: ?Sized + Hash + Eq,
768    K: Borrow<Q>,
769    S: BuildHasher,
770{
771    fn index_mut(&mut self, key: &Q) -> &mut V {
772        &mut self.inner[key]
773    }
774}
775
776impl<K, V, S> Index<usize> for TryIndexMap<K, V, S> {
777    type Output = V;
778
779    fn index(&self, index: usize) -> &V {
780        &self.inner[index]
781    }
782}
783
784impl<K, V, S> IndexMut<usize> for TryIndexMap<K, V, S> {
785    fn index_mut(&mut self, index: usize) -> &mut V {
786        &mut self.inner[index]
787    }
788}
789
790impl<K, V, S> Default for TryIndexMap<K, V, S>
791where
792    S: Default,
793{
794    fn default() -> Self {
795        Self::with_hasher(S::default())
796    }
797}
798
799impl<K, V1, S1, V2, S2> PartialEq<TryIndexMap<K, V2, S2>> for TryIndexMap<K, V1, S1>
800where
801    K: Hash + Eq,
802    V1: PartialEq<V2>,
803    S1: BuildHasher,
804    S2: BuildHasher,
805{
806    fn eq(&self, other: &TryIndexMap<K, V2, S2>) -> bool {
807        &self.inner == &other.inner
808    }
809}
810
811impl<K, V, S> Eq for TryIndexMap<K, V, S>
812where
813    K: Eq + Hash,
814    V: Eq,
815    S: BuildHasher,
816{
817}
818
819impl<'a, K, V, S> IntoIterator for &'a TryIndexMap<K, V, S> {
820    type Item = (&'a K, &'a V);
821    type IntoIter = inner::Iter<'a, K, V>;
822
823    fn into_iter(self) -> Self::IntoIter {
824        self.iter()
825    }
826}
827
828impl<'a, K, V, S> IntoIterator for &'a mut TryIndexMap<K, V, S> {
829    type Item = (&'a K, &'a mut V);
830    type IntoIter = inner::IterMut<'a, K, V>;
831
832    fn into_iter(self) -> Self::IntoIter {
833        self.iter_mut()
834    }
835}
836
837impl<K, V, S> IntoIterator for TryIndexMap<K, V, S> {
838    type Item = (K, V);
839    type IntoIter = inner::IntoIter<K, V>;
840
841    fn into_iter(self) -> Self::IntoIter {
842        self.inner.into_iter()
843    }
844}
845
846#[cfg(test)]
847mod tests {
848    use super::*;
849    use crate::error::Result;
850
851    #[test]
852    fn smoke() -> Result<()> {
853        let mut map = TryIndexMap::new();
854
855        map.insert("a", 10)?;
856        map.insert("b", 20)?;
857        map.insert("c", 30)?;
858
859        assert_eq!(map[&"a"], 10);
860        assert_eq!(map[&"b"], 20);
861        assert_eq!(map[&"c"], 30);
862
863        assert_eq!(map[0], 10);
864        assert_eq!(map[1], 20);
865        assert_eq!(map[2], 30);
866
867        Ok(())
868    }
869}
wasmtime_environ/collections/index_map.rs

wasmtime_environ/collections/
index_map.rs
