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 { }
    }
}