Struct ringbuf::Producer

pub struct Producer<T> { /* fields omitted */ }

Producer part of ring buffer.

Methods

impl<T: Sized> Producer<T>

pub fn capacity(&self) -> usize

Returns capacity of the ring buffer.

pub fn is_empty(&self) -> bool

Checks if the ring buffer is empty.

pub fn is_full(&self) -> bool

Checks if the ring buffer is full.

pub fn len(&self) -> usize

The length of the data in the buffer.

pub fn remaining(&self) -> usize

The remaining space in the buffer.

pub fn push(&mut self, elem: T) -> Result<(), PushError<T>>

Appends an element to the ring buffer. On failure returns an error containing the element that hasn't beed appended.

impl<T: Sized + Copy> Producer<T>

pub fn push_slice(&mut self, elems: &[T]) -> Result<usize, PushSliceError>

Appends elements from slice to the ring buffer. Elements should be Copy.

On success returns count of elements been appended to the ring buffer.

pub fn move_slice(
    &mut self,
    other: &mut Consumer<T>,
    count: Option<usize>
) -> Result<usize, MoveSliceError>

Removes at most count elements from the Consumer of the ring buffer and appends them to the Producer of the another one. If count is None then as much as possible elements will be moved.

Elements should be Copy.

On success returns count of elements been moved.

impl Producer<u8>

pub fn read_from(
    &mut self,
    reader: &mut dyn Read,
    count: Option<usize>
) -> Result<usize, ReadFromError>

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.

impl<T: Sized> Producer<T>

pub unsafe fn push_access<R, E, F>(
    &mut self,
    f: F
) -> Result<Result<(usize, R), E>, PushAccessError> where
    R: Sized,
    E: Sized,
    F: FnOnce(&mut [T], &mut [T]) -> Result<(usize, R), E>, 

Allows to write into ring buffer memory directry.

This function is unsafe beacuse it gives access to possibly uninitialized memory and transfers to the user the responsibility of manually calling destructors

Takes a function f as argument. f takes two slices of ring buffer content (the second one may be empty). First slice contains older elements.

f should return: + On success: pair of number of elements been written, and some arbitrary data. + On failure: some another arbitrary data.

On success returns data returned from f.

Trait Implementations

impl Write for Producer<u8>

fn write(&mut self, buffer: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.