Expand description
Producer part of ring buffer.
Mode
It can operate in immediate (by default) or postponed mode.
Mode could be switched using Self::postponed
/Self::into_postponed
and Self::into_immediate
methods.
- In immediate mode removed and inserted items are automatically synchronized with the other end.
- In postponed mode synchronization occurs only when
Self::sync
orSelf::into_immediate
is called or whenSelf
is dropped. The reason to use postponed mode is that multiple subsequent operations are performed faster due to less frequent cache synchronization.
Implementations
sourceimpl<T, R: RbRef> Producer<T, R>where
R::Rb: RbWrite<T>,
impl<T, R: RbRef> Producer<T, R>where
R::Rb: RbWrite<T>,
sourcepub unsafe fn new(target: R) -> Self
pub unsafe fn new(target: R) -> Self
Creates producer from the ring buffer reference.
Safety
There must be only one producer containing the same ring buffer reference.
sourcepub fn into_rb_ref(self) -> R
pub fn into_rb_ref(self) -> R
Consumes self
and returns underlying ring buffer reference.
sourcepub fn postponed(&mut self) -> PostponedProducer<T, &R::Rb>
pub fn postponed(&mut self) -> PostponedProducer<T, &R::Rb>
Returns postponed producer that borrows Self
.
sourcepub fn into_postponed(self) -> PostponedProducer<T, R>
pub fn into_postponed(self) -> PostponedProducer<T, R>
Transforms Self
into postponed producer.
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns capacity of the ring buffer.
The capacity of the buffer is constant.
sourcepub fn is_full(&self) -> bool
pub fn is_full(&self) -> bool
Checks if the ring buffer is full.
The result may become irrelevant at any time because of concurring consumer activity.
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
The number of items stored in the buffer.
Actual number may be less than the returned value because of concurring consumer activity.
sourcepub fn free_len(&self) -> usize
pub fn free_len(&self) -> usize
The number of remaining free places in the buffer.
Actual number may be greater than the returning value because of concurring consumer activity.
sourcepub unsafe fn free_space_as_slices(
&mut self
) -> (&mut [MaybeUninit<T>], &mut [MaybeUninit<T>])
pub unsafe fn free_space_as_slices(
&mut self
) -> (&mut [MaybeUninit<T>], &mut [MaybeUninit<T>])
Provides a direct access to the ring buffer vacant memory. Returns a pair of slices of uninitialized memory, the second one may be empty.
Safety
Vacant memory is uninitialized. Initialized items must be put starting from the beginning of first slice. When first slice is fully filled then items must be put to the beginning of the second slice.
This method must be followed by Self::advance
call with the number of items being put previously as argument.
No other mutating calls allowed before that.
sourcepub fn push(&mut self, elem: T) -> Result<(), T>
pub fn push(&mut self, elem: T) -> Result<(), T>
Appends an item to the ring buffer.
On failure returns an Err
containing the item that hasn’t been appended.
sourcepub fn push_iter<I: Iterator<Item = T>>(&mut self, iter: &mut I) -> usize
pub fn push_iter<I: Iterator<Item = T>>(&mut self, iter: &mut I) -> usize
Appends items from an iterator to the ring buffer. Elements that haven’t been added to the ring buffer remain in the iterator.
Returns count of items been appended to the ring buffer.
Inserted items are committed to the ring buffer all at once in the end, e.g. when buffer is full or iterator has ended.
sourceimpl<T: Copy, R: RbRef> Producer<T, R>where
R::Rb: RbWrite<T>,
impl<T: Copy, R: RbRef> Producer<T, R>where
R::Rb: RbWrite<T>,
sourcepub fn push_slice(&mut self, elems: &[T]) -> usize
pub fn push_slice(&mut self, elems: &[T]) -> usize
Appends items from slice to the ring buffer.
Elements should be Copy
.
Returns count of items been appended to the ring buffer.
sourceimpl<T, R: RbRef> Producer<T, RbWrap<RbWriteCache<T, R>>>where
R::Rb: RbWrite<T>,
impl<T, R: RbRef> Producer<T, RbWrap<RbWriteCache<T, R>>>where
R::Rb: RbWrite<T>,
sourcepub unsafe fn new_postponed(target: R) -> Self
pub unsafe fn new_postponed(target: R) -> Self
Create new postponed producer.
Safety
There must be only one producer containing the same ring buffer reference.
sourceimpl<R: RbRef> Producer<u8, R>where
R::Rb: RbWrite<u8>,
impl<R: RbRef> Producer<u8, R>where
R::Rb: RbWrite<u8>,
sourcepub fn read_from<P: Read>(
&mut self,
reader: &mut P,
count: Option<usize>
) -> Result<usize>
pub fn read_from<P: Read>(
&mut self,
reader: &mut P,
count: Option<usize>
) -> Result<usize>
Reads at most count
bytes from Read
instance and appends them to the ring buffer.
If count
is None
then as much as possible bytes will be read.
Returns Ok(n)
if read
succeeded. n
is number of bytes been read.
n == 0
means that either read
returned zero or ring buffer is full.
If read
is failed then original error is returned. In this case it is guaranteed that no items was read from the reader.
To achieve this we read only one contiguous slice at once. So this call may read less than remaining
items in the buffer even if the reader is ready to provide more.
Trait Implementations
sourceimpl<R: RbRef> Write for Producer<u8, R>where
R::Rb: RbWrite<u8>,
impl<R: RbRef> Write for Producer<u8, R>where
R::Rb: RbWrite<u8>,
sourcefn write(&mut self, buffer: &[u8]) -> Result<usize>
fn write(&mut self, buffer: &[u8]) -> Result<usize>
sourcefn flush(&mut self) -> Result<()>
fn flush(&mut self) -> Result<()>
sourcefn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)1.0.0 · sourcefn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
sourcefn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
write_all_vectored
)