/rust/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.13.0/src/set/mutable.rs

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

use super::{Equivalent, IndexSet};
use crate::map::MutableKeys;

/// Opt-in mutable access to [`IndexSet`] values.
///
/// These methods expose `&mut T`, mutable references to the value as it is stored
/// in the set.
/// You are allowed to modify the values in the set **if the modification
/// does not change the value's hash and equality**.
///
/// If values 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 `IndexSet`.
///
/// This trait is sealed and cannot be implemented for types outside this crate.
#[expect(private_bounds)]
pub trait MutableValues: Sealed {
    type Value;

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

    /// Return mutable reference to the 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::Value>;

    /// Scan through each value in the set and keep those where the
    /// closure `keep` returns `true`.
    ///
    /// The values are visited in order, and remaining values keep their order.
    ///
    /// Computes in **O(n)** time (average).
    fn retain2<F>(&mut self, keep: F)
    where
        F: FnMut(&mut Self::Value) -> bool;
}

/// Opt-in mutable access to [`IndexSet`] values.
///
/// See [`MutableValues`] for more information.
impl<T, S> MutableValues for IndexSet<T, S>
where
    S: BuildHasher,
{
    type Value = T;

    fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut T)>
    where
        Q: ?Sized + Hash + Equivalent<T>,
    {
        match self.map.get_full_mut2(value) {
            Some((index, value, ())) => Some((index, value)),
            None => None,
        }
    }

    fn get_index_mut2(&mut self, index: usize) -> Option<&mut T> {
        match self.map.get_index_mut2(index) {
            Some((value, ())) => Some(value),
            None => None,
        }
    }

    fn retain2<F>(&mut self, mut keep: F)
    where
        F: FnMut(&mut T) -> bool,
    {
        self.map.retain2(move |value, ()| keep(value));
    }
}

trait Sealed {}

impl<T, S> Sealed for IndexSet<T, S> {}

Line	Count	Source
1		use core::hash::{BuildHasher, Hash};
2
3		use super::{Equivalent, IndexSet};
4		use crate::map::MutableKeys;
5
6		/// Opt-in mutable access to [`IndexSet`] values.
7		///
8		/// These methods expose `&mut T`, mutable references to the value as it is stored
9		/// in the set.
10		/// You are allowed to modify the values in the set **if the modification
11		/// does not change the value's hash and equality**.
12		///
13		/// If values are modified erroneously, you can no longer look them up.
14		/// This is sound (memory safe) but a logical error hazard (just like
15		/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
16		///
17		/// `use` this trait to enable its methods for `IndexSet`.
18		///
19		/// This trait is sealed and cannot be implemented for types outside this crate.
20		#[expect(private_bounds)]
21		pub trait MutableValues: Sealed {
22		type Value;
23
24		/// Return item index and mutable reference to the value
25		///
26		/// Computes in O(1) time (average).
27		fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut Self::Value)>
28		where
29		Q: ?Sized + Hash + Equivalent<Self::Value>;
30
31		/// Return mutable reference to the value at an index.
32		///
33		/// Valid indices are `0 <= index < self.len()`.
34		///
35		/// Computes in O(1) time.
36		fn get_index_mut2(&mut self, index: usize) -> Option<&mut Self::Value>;
37
38		/// Scan through each value in the set and keep those where the
39		/// closure `keep` returns `true`.
40		///
41		/// The values are visited in order, and remaining values keep their order.
42		///
43		/// Computes in O(n) time (average).
44		fn retain2<F>(&mut self, keep: F)
45		where
46		F: FnMut(&mut Self::Value) -> bool;
47		}
48
49		/// Opt-in mutable access to [`IndexSet`] values.
50		///
51		/// See [`MutableValues`] for more information.
52		impl<T, S> MutableValues for IndexSet<T, S>
53		where
54		S: BuildHasher,
55		{
56		type Value = T;
57
58	0	fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut T)>
59	0	where
60	0	Q: ?Sized + Hash + Equivalent<T>,
61		{
62	0	match self.map.get_full_mut2(value) {
63	0	Some((index, value, ())) => Some((index, value)),
64	0	None => None,
65		}
66	0	}
67
68	0	fn get_index_mut2(&mut self, index: usize) -> Option<&mut T> {
69	0	match self.map.get_index_mut2(index) {
70	0	Some((value, ())) => Some(value),
71	0	None => None,
72		}
73	0	}
74
75	0	fn retain2<F>(&mut self, mut keep: F)
76	0	where
77	0	F: FnMut(&mut T) -> bool,
78		{
79	0	self.map.retain2(move \|value, ()\| keep(value));
80	0	}
81		}
82
83		trait Sealed {}
84
85		impl<T, S> Sealed for IndexSet<T, S> {}

Coverage Report

Created: 2026-01-10 06:06