Struct mutringbuf::iterators::impls::detached_work_iter::DetachedWorkIter

pub struct DetachedWorkIter<B: MutRB<T>, T, A> { /* private fields */ }

Same as WorkIter, but does not update the atomic index when advancing.

This makes it possible to explore available data back and forth, putting the consumer iterator on hold.

A typical use case of this structure is to search something amidst produced data, aligning the detached iterator to a suitable index, and then returning to a normal worker iterator.

This struct can only be created by detaching a worker iterator.

When done, a worker iterator can be re-obtained via Self::attach.

Note that, in order to avoid buffer saturation, atomic index can be synced with Self::sync_index; this synchronises indices making the consumer iterator able to move on.

As WorkIter, this iterator returns mutable references to data stored within the buffer. Thus, as stated in the docs written for the former, Self::advance has to be called when done with the mutation in order to move the iterator.

Implementations

impl<B: MutRB<T>, T, A> DetachedWorkIter<B, T, A>

pub fn available(&mut self) -> usize

See WorkIter::available.

pub fn index(&self) -> usize

See WorkIter::index.

pub fn buf_len(&self) -> usize

See WorkIter::buf_len.

pub unsafe fn set_index(&mut self, index: usize)

Sets local index.

Safety

Index must always be between consumer and producer.

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

Advances the iterator as in WorkIter::available(), but does not modify the atomic counter, making the change local.

Safety

See WorkIter::advance.

impl<B: MutRB<T>, T, A> DetachedWorkIter<B, T, A>

pub fn attach(self) -> WorkIter<B, T, A>

Attaches the iterator, yielding a WorkIter.

pub unsafe fn go_back(&mut self, count: usize)

Goes back, wrapping if necessary.

Safety

Index must always be between consumer and producer.

pub fn is_prod_alive(&self) -> bool

See WorkIter::is_prod_alive.

pub fn is_cons_alive(&self) -> bool

See WorkIter::is_cons_alive.

pub fn sync_index(&self)

Synchronises the underlying atomic index with the local index. I.e. let the consumer iterator advance.

pub fn get_workable(&mut self) -> Option<(&mut T, &mut A)>

See WorkIter::get_workable.

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

See WorkIter::get_workable_slice_exact.

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

See WorkIter::get_workable_slice_avail.

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

See WorkIter::get_workable_slice_multiple_of.

Trait Implementations

impl<B: ConcurrentRB + MutRB<T>, T, A> Send for DetachedWorkIter<B, T, A>