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
use core::hash::{BuildHasher, Hash}; use super::{Equivalent, IndexMap}; pub struct PrivateMarker {} /// Opt-in mutable access to keys. /// /// These methods expose `&mut K`, mutable references to the key as it is stored /// in the map. /// You are allowed to modify the keys in the hashmap **if the modifcation /// does not change the key’s hash and equality**. /// /// If keys are modified erronously, you can no longer look them up. /// This is sound (memory safe) but a logical error hazard (just like /// implementing PartialEq, Eq, or Hash incorrectly would be). /// /// `use` this trait to enable its methods for `IndexMap`. pub trait MutableKeys { type Key; type Value; /// Return item index, mutable reference to key and value fn get_full_mut2<Q: ?Sized>( &mut self, key: &Q, ) -> Option<(usize, &mut Self::Key, &mut Self::Value)> where Q: Hash + Equivalent<Self::Key>; /// Scan through each key-value pair in the map and keep those where the /// closure `keep` returns `true`. /// /// The elements are visited in order, and remaining elements keep their /// order. /// /// Computes in **O(n)** time (average). fn retain2<F>(&mut self, keep: F) where F: FnMut(&mut Self::Key, &mut Self::Value) -> bool; /// This method is not useful in itself – it is there to “seal” the trait /// for external implementation, so that we can add methods without /// causing breaking changes. fn __private_marker(&self) -> PrivateMarker; } /// Opt-in mutable access to keys. /// /// See [`MutableKeys`](trait.MutableKeys.html) for more information. impl<K, V, S> MutableKeys for IndexMap<K, V, S> where K: Eq + Hash, S: BuildHasher, { type Key = K; type Value = V; fn get_full_mut2<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)> where Q: Hash + Equivalent<K>, { self.get_full_mut2_impl(key) } fn retain2<F>(&mut self, keep: F) where F: FnMut(&mut K, &mut V) -> bool, { self.retain_mut(keep) } fn __private_marker(&self) -> PrivateMarker { PrivateMarker {} } }