Struct async_ringbuf::producer::AsyncProducer

pub struct AsyncProducer<T, R: RbRef>where
    R::Rb: AsyncRbWrite<T>,{ /* private fields */ }

Implementations

impl<T, R: RbRef> AsyncProducer<T, R>where R::Rb: AsyncRbWrite<T>,

pub fn from_base(base: Producer<T, R>) -> Self

pub fn as_base(&self) -> &Producer<T, R>

pub fn as_mut_base(&mut self) -> &mut Producer<T, R>

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_full(&self) -> bool

pub fn len(&self) -> usize

pub fn free_len(&self) -> usize

pub fn close(&mut self)

Closes the producer. All subsequent writes will panic.

pub fn is_closed(&self) -> bool

Check if the corresponding consumer is dropped.

pub fn push(&mut self, item: T) -> PushFuture<'_, T, R>

Push item to the ring buffer waiting asynchronously if the buffer is full.

Future returns:

• Ok - item successfully pushed.
• Err(item) - the corresponding consumer was dropped, item is returned back.

pub fn push_iter<I: Iterator<Item = T>>( &mut self, iter: I ) -> PushIterFuture<'_, T, R, I>

Push items from iterator waiting asynchronously if the buffer is full.

Future returns:

• Ok - iterator ended.
• Err(iter) - the corresponding consumer was dropped, remaining iterator is returned back.

pub fn wait_free(&self, free_len: usize) -> WaitFreeFuture<'_, T, R>

Wait for the buffer to have at least free_len free places for items or to close.

Panics if free_len is greater than buffer capacity.

impl<T: Copy, R: RbRef> AsyncProducer<T, R>where R::Rb: AsyncRbWrite<T>,

pub fn push_slice<'a: 'b, 'b>( &'a mut self, slice: &'b [T] ) -> PushSliceFuture<'a, 'b, T, R>

Copy slice contents to the buffer waiting asynchronously if the buffer is full.

Future returns:

• Ok - all slice contents are copied.
• Err(count) - the corresponding consumer was dropped, number of copied items returned.

Trait Implementations

impl<R: RbRef> AsyncWrite for AsyncProducer<u8, R>where R::Rb: AsyncRbWrite<u8>,

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

Attempt to write bytes from buf into the object.

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

Attempt to flush the object, ensuring that any buffered data reach their destination.

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

Attempt to close the object.

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, R: RbRef> Drop for AsyncProducer<T, R>where R::Rb: AsyncRbWrite<T>,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, R: RbRef> Sink<T> for AsyncProducer<T, R>where R::Rb: AsyncRbWrite<T>,

type Error = ()

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.

impl<T, R: RbRef> Unpin for AsyncProducer<T, R>where R::Rb: AsyncRbWrite<T>,