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 76
use std::hash::Hash;
use std::hash::BuildHasher;
use super::{OrderMap, Equivalent};
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 `OrderMap`.
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 OrderMap<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>,
{
if let Some((_, found)) = self.find(key) {
let entry = &mut self.entries[found];
Some((found, &mut entry.key, &mut entry.value))
} else {
None
}
}
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 { }
}
}