Struct mutringbuf::iterators::sync_iterators::work_iter::WorkIter

pub struct WorkIter<B: MutRB> { /* private fields */ }

Iterator used to mutate elements in-place.

This iterator returns mutable references to data stored within the buffer. Thuss stated in the docs below, Self::advance has to be called when done with the mutation in order to move the iterator.

Self::advance updates a global iterator, which is read by the consumer to decide if it can move on. To avoid this DetachedWorkIter can be obtained by calling Self::detach.

Implementations

impl<B: MutRB<Item = T>, T> WorkIter<B>

pub fn is_prod_alive(&self) -> bool

Returns true if the producer iterator is still alive, false if it has been dropped.

pub fn is_cons_alive(&self) -> bool

Returns true if the consumer iterator is still alive, false if it has been dropped.

pub fn detach(self) -> DetachedWorkIter<B>

Detaches the iterator yielding a DetachedWorkIter.

pub fn reset_index(&mut self)

Resets the index of the iterator. I.e., moves the iterator to the location occupied by its successor.

pub fn get_workable<'a>(&mut self) -> Option<&'a mut T>

Returns a mutable references to the current value.

Being these references, Self::advance() has to be called when done with the mutation in order to move the iterator.

pub fn get_workable_slice_exact<'a>( &mut self, count: usize ) -> Option<WorkableSlice<'a, T>>

Returns a tuple of mutable slice references, the sum of which with len equal to count.

Being these references, Self::advance() has to be called when done with the mutation in order to move the iterator.

pub fn get_workable_slice_avail<'a>(&mut self) -> Option<WorkableSlice<'a, T>>

Returns a tuple of mutable slice references, the sum of which with len equal to Self::available().

Being these references, Self::advance() has to be called when done with the mutation in order to move the iterator.

pub fn get_workable_slice_multiple_of<'a>( &mut self, rhs: usize ) -> Option<WorkableSlice<'a, T>>

Returns a tuple of mutable slice references, the sum of which with len equal to the maximum multiple of modulo.

Being these references, Self::advance() has to be called when done with the mutation in order to move the iterator.

Trait Implementations

impl<B: MutRB + IterManager> Drop for WorkIter<B>

fn drop(&mut self)

Executes the destructor for this type.

impl<B: MutRB<Item = T>, T> MRBIterator<T> for WorkIter<B>

fn available(&mut self) -> usize

Returns the number of items available for an iterator.

unsafe fn advance(&mut self, count: usize)

Advances the iterator by count.

fn index(&self) -> usize

Returns the index of the iterator.

fn buf_len(&self) -> usize

Returns the length of the buffer.

impl<B: ConcurrentRB + MutRB<Item = T>, T> Send for WorkIter<B>