Struct Consumer 

pub struct Consumer<'a, const N: usize> { /* private fields */ }

A Consumer is a smart pointer to a Buffer, which is endowed with the right to remove data from the buffer. Only one Consumer may exist at one time for any given buffer. The methods of a Consumer are the only way to read data out of a Buffer.

Implementations

impl<'a, const N: usize> Consumer<'a, N>

pub fn read<'b>(&'b mut self, target_len: usize) -> Region<'b, Self>

Return a Region for up to target_len bytes to be read from the buffer. The returned region may be shorter than target_len. The returned region has length zero if and only if the buffer is empty. The returned region is guaranteed to be not longer than target_len. To read the largest possible length, set target_len = usize::MAX.

Even though we are reading from the buffer, the Region which is returned is mutable. Its memory is available for arbitrary use by the caller for as long as the Region remains in scope.

Examples found in repository

examples/two_threads.rs (line 19)

fn consumer(mut c: fring::Consumer<N>) {
    loop {
        std::thread::sleep(std::time::Duration::from_millis(60));
        let r = c.read(usize::MAX);
        if r.len() == 0 {  // buffer is empty
            break;
        }
        println!("            read \"{}\"", std::str::from_utf8(&*r).unwrap());
    }
}

pub unsafe fn read_ref<T: Copy + ?Sized>( &mut self, item: &mut T, ) -> Result<(), ()>

If the buffer contains enough bytes to make an instance of T, then write them into *item and return Ok. Otherwise, return Err. UNSAFE: caller must guarantee that the bytes contained in the buffer constitute a valid instance of T. In consequence, if T is an integer type or an integer array or slice type, then it is safe to call this function.

pub fn data_size(&self) -> usize

Return the amount of data currently stored in the buffer. If the producer is writing concurrently with this call, then the amount of data may increase, but it will not decrease below the value which is returned.

pub fn flush(&mut self)

Discard all data which is currently stored in the buffer. If the producer is writing concurrently with this call, then the producer’s newest data may not be discarded.