pub fn iter_mut(&mut self) -> IterMut<T> {
        let mut slabs = self.slabs.iter_mut();
        let slab_iter = slabs.next().unwrap().iter_mut();
        IterMut {
            slabs,
            slab_iter,
            primary_capacity: self.primary_capacity,
            secondary_capacity: self.secondary_capacity,
            key_offset: 0,
        }
    }
/// Return an iterator that allows modifying each value.
///
/// This function should generally be **avoided** as it is not efficient.
/// Iterators must iterate over every slot in the slab even if it is
/// vacant. As such, a slab with a capacity of 1 million but only one
/// stored value must still iterate the million slots.
///
/// # Examples
///
/// ```
/// # use super_slab::*;
/// let mut slab = SuperSlab::with_capacity(2);
///
/// let key1 = slab.insert(0);
/// let key2 = slab.insert(1);
///
/// for (key, val) in slab.iter_mut() {
///     if key == key1 {
///         *val += 2;
///     }
/// }
///
/// assert_eq!(slab[key1], 2);
/// assert_eq!(slab[key2], 1);
/// ```
Return an iterator that allows modifying each value.
This function should generally be **avoided** as it is not efficient.
Iterators must iterate over every slot in the slab even if it is
vacant. As such, a slab with a capacity of 1 million but only one
stored value must still iterate the million slots.
Return an iterator that allows modifying each value . This function should generally be ** avoided ** as it is not efficient . Iterators must iterate over every slot in the slab even if it is vacant . As such a slab with a capacity of 1 million but only one stored value must still iterate the million slots .
pub fn iter_mut(&mut self) -> IterMut<T> {
        let mut slabs = self.slabs.iter_mut();
        let slab_iter = slabs.next().unwrap().iter_mut();
        IterMut {
            slabs,
            slab_iter,
            primary_capacity: self.primary_capacity,
            secondary_capacity: self.secondary_capacity,
            key_offset: 0,
        }
    }
pub fn iter_mut ( & mut self ) -> IterMut < T > { let mut slabs = self . slabs . iter_mut ( ) ; let slab_iter = slabs . next ( ) . unwrap ( ) . iter_mut ( ) ; IterMut { slabs , slab_iter , primary_capacity : self . primary_capacity , secondary_capacity : self . secondary_capacity , key_offset : 0 , } }
Return an iterator that allows modifying each value.
Return an iterator that allows modifying each value .
&mut self
&mut self
examples
None
use super_slab::*;
let mut slab = SuperSlab::with_capacity(2).

let key1 = slab.insert(0);
let key2 = slab.insert(1).




let mut slab = SuperSlab :: with_capacity ( 2 ) . let key1 = slab . insert ( 0 ) ; let key2 = slab . insert ( 1 ) .