Struct ringbuf::Consumer

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

Consumer part of ring buffer.

Methods

impl<T: Sized> Consumer<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 pop(&mut self) -> Result<T, PopError>

Removes first element from the ring buffer and returns it.

pub fn for_each_mut<F>(&mut self, f: F) where
    F: FnMut(&mut T), 

Iterate mutably over the elements contained by this buffer.

pub fn for_each<F>(&mut self, f: F) where
    F: FnMut(&T), 

Iterate immutably over the elements contained by this buffer.

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

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

Removes first elements from the ring buffer and writes them into a slice. Elements should be Copy.

On success returns count of elements been removed from the ring buffer.

pub fn move_slice(
    &mut self,
    other: &mut Producer<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 Consumer<u8>

pub fn write_into(
    &mut self,
    writer: &mut dyn Write,
    count: Option<usize>
) -> Result<usize, WriteIntoError>

Removes at most first count bytes from the ring buffer and writes them into a Write instance. If count is None then as much as possible bytes will be written.

impl<T: Sized> Consumer<T>

pub fn access<F: FnOnce(&[T], &[T])>(&self, f: F) -> Result<(), AccessError>

Gives immutable access to the elements contained by the ring buffer without removing them.

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

The slices may not include elements pushed to the buffer by concurring producer after the method call.

pub fn access_mut<F: FnOnce(&mut [T], &mut [T])>(
    &mut self,
    f: F
) -> Result<(), AccessError>

Gives mutable access to the elements contained by the ring buffer without removing them.

The method 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.

The iteration may not include elements pushed to the buffer by concurring producer after the method call.

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

Allows to read from 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 read, and some arbitrary data. + On failure: some another arbitrary data.

On success returns data returned from f.

Trait Implementations

impl Read for Consumer<u8>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Like read, except that it reads into a slice of buffers.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.