/rust/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.12.0/src/map/mutable.rs

Source
use core::hash::{BuildHasher, Hash};

use super::{
    Bucket, Entry, Equivalent, IndexMap, IndexedEntry, IterMut2, OccupiedEntry, VacantEntry,
};

/// Opt-in mutable access to [`IndexMap`] 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 map **if the modification
/// does not change the key's hash and equality**.
///
/// If keys are modified erroneously, 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`.
///
/// This trait is sealed and cannot be implemented for types outside this crate.
#[expect(private_bounds)]
pub trait MutableKeys: Sealed {
    type Key;
    type Value;

    /// Return item index, mutable reference to key and value
    ///
    /// Computes in **O(1)** time (average).
    fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut Self::Key, &mut Self::Value)>
    where
        Q: ?Sized + Hash + Equivalent<Self::Key>;

    /// Return mutable reference to key and value at an index.
    ///
    /// Valid indices are `0 <= index < self.len()`.
    ///
    /// Computes in **O(1)** time.
    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut Self::Key, &mut Self::Value)>;

    /// Return an iterator over the key-value pairs of the map, in their order
    fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value>;

    /// 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;
}

/// Opt-in mutable access to [`IndexMap`] keys.
///
/// See [`MutableKeys`] for more information.
impl<K, V, S> MutableKeys for IndexMap<K, V, S>
where
    S: BuildHasher,
{
    type Key = K;
    type Value = V;

    fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
    where
        Q: ?Sized + Hash + Equivalent<K>,
    {
        if let Some(i) = self.get_index_of(key) {
            let entry = &mut self.as_entries_mut()[i];
            Some((i, &mut entry.key, &mut entry.value))
        } else {
            None
        }
    }

    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
        self.as_entries_mut().get_mut(index).map(Bucket::muts)
    }

    fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value> {
        IterMut2::new(self.as_entries_mut())
    }

    fn retain2<F>(&mut self, keep: F)
    where
        F: FnMut(&mut K, &mut V) -> bool,
    {
        self.core.retain_in_order(keep);
    }
}

/// Opt-in mutable access to [`Entry`] 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 map **if the modification
/// does not change the key's hash and equality**.
///
/// If keys are modified erroneously, 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 `Entry`.
///
/// This trait is sealed and cannot be implemented for types outside this crate.
#[expect(private_bounds)]
pub trait MutableEntryKey: Sealed {
    type Key;

    /// Gets a mutable reference to the entry's key, either within the map if occupied,
    /// or else the new key that was used to find the entry.
    fn key_mut(&mut self) -> &mut Self::Key;
}

/// Opt-in mutable access to [`Entry`] keys.
///
/// See [`MutableEntryKey`] for more information.
impl<K, V> MutableEntryKey for Entry<'_, K, V> {
    type Key = K;
    fn key_mut(&mut self) -> &mut Self::Key {
        match self {
            Entry::Occupied(e) => e.key_mut(),
            Entry::Vacant(e) => e.key_mut(),
        }
    }
}

/// Opt-in mutable access to [`OccupiedEntry`] keys.
///
/// See [`MutableEntryKey`] for more information.
impl<K, V> MutableEntryKey for OccupiedEntry<'_, K, V> {
    type Key = K;
    fn key_mut(&mut self) -> &mut Self::Key {
        self.key_mut()
    }
}

/// Opt-in mutable access to [`VacantEntry`] keys.
///
/// See [`MutableEntryKey`] for more information.
impl<K, V> MutableEntryKey for VacantEntry<'_, K, V> {
    type Key = K;
    fn key_mut(&mut self) -> &mut Self::Key {
        self.key_mut()
    }
}

/// Opt-in mutable access to [`IndexedEntry`] keys.
///
/// See [`MutableEntryKey`] for more information.
impl<K, V> MutableEntryKey for IndexedEntry<'_, K, V> {
    type Key = K;
    fn key_mut(&mut self) -> &mut Self::Key {
        self.key_mut()
    }
}

trait Sealed {}

impl<K, V, S> Sealed for IndexMap<K, V, S> {}
impl<K, V> Sealed for Entry<'_, K, V> {}
impl<K, V> Sealed for OccupiedEntry<'_, K, V> {}
impl<K, V> Sealed for VacantEntry<'_, K, V> {}
impl<K, V> Sealed for IndexedEntry<'_, K, V> {}

Line	Count	Source
1		use core::hash::{BuildHasher, Hash};
2
3		use super::{
4		Bucket, Entry, Equivalent, IndexMap, IndexedEntry, IterMut2, OccupiedEntry, VacantEntry,
5		};
6
7		/// Opt-in mutable access to [`IndexMap`] keys.
8		///
9		/// These methods expose `&mut K`, mutable references to the key as it is stored
10		/// in the map.
11		/// You are allowed to modify the keys in the map **if the modification
12		/// does not change the key's hash and equality**.
13		///
14		/// If keys are modified erroneously, you can no longer look them up.
15		/// This is sound (memory safe) but a logical error hazard (just like
16		/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
17		///
18		/// `use` this trait to enable its methods for `IndexMap`.
19		///
20		/// This trait is sealed and cannot be implemented for types outside this crate.
21		#[expect(private_bounds)]
22		pub trait MutableKeys: Sealed {
23		type Key;
24		type Value;
25
26		/// Return item index, mutable reference to key and value
27		///
28		/// Computes in O(1) time (average).
29		fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut Self::Key, &mut Self::Value)>
30		where
31		Q: ?Sized + Hash + Equivalent<Self::Key>;
32
33		/// Return mutable reference to key and value at an index.
34		///
35		/// Valid indices are `0 <= index < self.len()`.
36		///
37		/// Computes in O(1) time.
38		fn get_index_mut2(&mut self, index: usize) -> Option<(&mut Self::Key, &mut Self::Value)>;
39
40		/// Return an iterator over the key-value pairs of the map, in their order
41		fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value>;
42
43		/// Scan through each key-value pair in the map and keep those where the
44		/// closure `keep` returns `true`.
45		///
46		/// The elements are visited in order, and remaining elements keep their
47		/// order.
48		///
49		/// Computes in O(n) time (average).
50		fn retain2<F>(&mut self, keep: F)
51		where
52		F: FnMut(&mut Self::Key, &mut Self::Value) -> bool;
53		}
54
55		/// Opt-in mutable access to [`IndexMap`] keys.
56		///
57		/// See [`MutableKeys`] for more information.
58		impl<K, V, S> MutableKeys for IndexMap<K, V, S>
59		where
60		S: BuildHasher,
61		{
62		type Key = K;
63		type Value = V;
64
65	0	fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
66	0	where
67	0	Q: ?Sized + Hash + Equivalent<K>,
68		{
69	0	if let Some(i) = self.get_index_of(key) {
70	0	let entry = &mut self.as_entries_mut()[i];
71	0	Some((i, &mut entry.key, &mut entry.value))
72		} else {
73	0	None
74		}
75	0	}
76
77	0	fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
78	0	self.as_entries_mut().get_mut(index).map(Bucket::muts)
79	0	}
80
81	0	fn iter_mut2(&mut self) -> IterMut2<'_, Self::Key, Self::Value> {
82	0	IterMut2::new(self.as_entries_mut())
83	0	}
84
85	0	fn retain2<F>(&mut self, keep: F)
86	0	where
87	0	F: FnMut(&mut K, &mut V) -> bool,
88		{
89	0	self.core.retain_in_order(keep);
90	0	}
91		}
92
93		/// Opt-in mutable access to [`Entry`] keys.
94		///
95		/// These methods expose `&mut K`, mutable references to the key as it is stored
96		/// in the map.
97		/// You are allowed to modify the keys in the map **if the modification
98		/// does not change the key's hash and equality**.
99		///
100		/// If keys are modified erroneously, you can no longer look them up.
101		/// This is sound (memory safe) but a logical error hazard (just like
102		/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
103		///
104		/// `use` this trait to enable its methods for `Entry`.
105		///
106		/// This trait is sealed and cannot be implemented for types outside this crate.
107		#[expect(private_bounds)]
108		pub trait MutableEntryKey: Sealed {
109		type Key;
110
111		/// Gets a mutable reference to the entry's key, either within the map if occupied,
112		/// or else the new key that was used to find the entry.
113		fn key_mut(&mut self) -> &mut Self::Key;
114		}
115
116		/// Opt-in mutable access to [`Entry`] keys.
117		///
118		/// See [`MutableEntryKey`] for more information.
119		impl<K, V> MutableEntryKey for Entry<'_, K, V> {
120		type Key = K;
121	0	fn key_mut(&mut self) -> &mut Self::Key {
122	0	match self {
123	0	Entry::Occupied(e) => e.key_mut(),
124	0	Entry::Vacant(e) => e.key_mut(),
125		}
126	0	}
127		}
128
129		/// Opt-in mutable access to [`OccupiedEntry`] keys.
130		///
131		/// See [`MutableEntryKey`] for more information.
132		impl<K, V> MutableEntryKey for OccupiedEntry<'_, K, V> {
133		type Key = K;
134	0	fn key_mut(&mut self) -> &mut Self::Key {
135	0	self.key_mut()
136	0	}
137		}
138
139		/// Opt-in mutable access to [`VacantEntry`] keys.
140		///
141		/// See [`MutableEntryKey`] for more information.
142		impl<K, V> MutableEntryKey for VacantEntry<'_, K, V> {
143		type Key = K;
144	0	fn key_mut(&mut self) -> &mut Self::Key {
145	0	self.key_mut()
146	0	}
147		}
148
149		/// Opt-in mutable access to [`IndexedEntry`] keys.
150		///
151		/// See [`MutableEntryKey`] for more information.
152		impl<K, V> MutableEntryKey for IndexedEntry<'_, K, V> {
153		type Key = K;
154	0	fn key_mut(&mut self) -> &mut Self::Key {
155	0	self.key_mut()
156	0	}
157		}
158
159		trait Sealed {}
160
161		impl<K, V, S> Sealed for IndexMap<K, V, S> {}
162		impl<K, V> Sealed for Entry<'_, K, V> {}
163		impl<K, V> Sealed for OccupiedEntry<'_, K, V> {}
164		impl<K, V> Sealed for VacantEntry<'_, K, V> {}
165		impl<K, V> Sealed for IndexedEntry<'_, K, V> {}

Coverage Report

Created: 2025-11-16 06:56