Struct futures_ringbuf::RingBuffer

pub struct RingBuffer<T: Sized + Copy> { /* fields omitted */ }

A RingBuffer that implements AsyncRead and AsyncWrite from the futures library.

This object is rather special in that it’s read and writes are connected to a single ringbuffer. It’s good for low level unit tests for (eg. framing a connection with a codec) and verifying that a codec writes the correct data, but it does not mock a full network connection. Subtle things can go wrong, like when using AsyncRead::split and dropping the WriteHalf, the ReadHalf cannot detect that and the task won’t be woken up.

If you want to mock a network connection, use Endpoint.

Implementations

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

pub fn new(size: usize) -> Self

Create a new RingBuffer with a defined capacity. Note that capacity != length, similar to Vec.

pub fn capacity(&self) -> usize

The total capacity of the buffer

pub fn is_empty(&self) -> bool

Whether there is no data at all in the buffer.

pub fn is_full(&self) -> bool

Whether the buffer is completely full.

pub fn len(&self) -> usize

The length of the data in the buffer.

pub fn remaining(&self) -> usize

How much free space there is left in the container. On empty, remaining == capacity

Trait Implementations

impl AsyncRead for RingBuffer<u8>

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    dst: &mut [u8]
) -> Poll<Result<usize, Error>>

Will return Poll::Pending when the buffer is empty. Will be woken up by the AsyncWrite impl when new data is written or the writer is closed.

When the buffer (for network simulation) is closed and empty, or if you pass in a 0 byte buffer, this will return Poll::Ready( Ok(0) ).

This method is infallible.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl AsyncWrite for RingBuffer<u8>

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    src: &[u8]
) -> Poll<Result<usize, Error>>

Will return Poll::Pending when the buffer is full. AsyncRead impl will wake up this task when new place is made. This method returns a io::ErrorKind::NotConnected error if called after poll_close.

fn poll_flush(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

We are always flushed, this is a noop. This method is infallible.

fn poll_close(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

Closes the stream. After this no more data can be send into it. This method is infallible.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<T: Sized + Copy> Debug for RingBuffer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Sized + Copy> From<(Producer<T>, Consumer<T>)> for RingBuffer<T>

The compiler cannot verify that the producer/consumer are from the same RingBuffer object. Obviously if you abuse this things won’t work as expected.

I added this so you can seed a buffer before passing it to futures_ringbuf.

fn from(buffer: (Producer<T>, Consumer<T>)) -> Self

Performs the conversion.

impl<T: Sized + Copy> From<RingBuffer<T>> for RingBuffer<T>

fn from(buffer: SyncRingBuffer<T>) -> Self

Performs the conversion.