pub fn iter(&self) -> Iter<T> {
        let mut slabs = self.slabs.iter();
        let slab_iter = slabs.next().unwrap().iter();
        Iter {
            slabs,
            slab_iter,
            primary_capacity: self.primary_capacity,
            secondary_capacity: self.secondary_capacity,
            key_offset: 0,
        }
    }
/// Return an iterator over the slabs.
///
/// 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);
///
/// for i in 0..3 {
///     slab.insert(i);
/// }
///
/// let mut iterator = slab.iter();
/// assert_eq!(iterator.next(), Some((0, &0)));
/// assert_eq!(iterator.next(), Some((1, &1)));
/// assert_eq!(iterator.next(), Some((2, &2)));
/// assert_eq!(iterator.next(), None);
/// ```
Return an iterator over the slabs.
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 over the slabs . 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(&self) -> Iter<T> {
        let mut slabs = self.slabs.iter();
        let slab_iter = slabs.next().unwrap().iter();
        Iter {
            slabs,
            slab_iter,
            primary_capacity: self.primary_capacity,
            secondary_capacity: self.secondary_capacity,
            key_offset: 0,
        }
    }
pub fn iter ( & self ) -> Iter < T > { let mut slabs = self . slabs . iter ( ) ; let slab_iter = slabs . next ( ) . unwrap ( ) . iter ( ) ; Iter { slabs , slab_iter , primary_capacity : self . primary_capacity , secondary_capacity : self . secondary_capacity , key_offset : 0 , } }
Return an iterator over the slabs.
Return an iterator over the slabs .
&self
&self
examples
None
use super_slab::*;
let mut slab = SuperSlab::with_capacity(2).




let mut slab = SuperSlab :: with_capacity ( 2 ) .