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