Struct futures_test_sink::SinkMock

pub struct SinkMock<FlushI, ReadyI, SendI, Item> { /* fields omitted */ }

This struct represent correct implementation of sink according to sink doc.

Panics:

1. Calling start_send without calling 'poll_ready() with result Poll::Ready(Ok(()))' panic!
2. Calling any method after poll_close() returned Poll::Ready(Ok(())) once panic!
3. When flush_feedback iterator return None.

Methods

impl<FlushI, ReadyI, SendI, Item> SinkMock<FlushI, ReadyI, SendI, Item>

pub fn set_flush_at_once(&mut self, flush_at_once: NonZeroUsize) -> &mut Self

Change how many buffered item will be discarded when flush_feedback yield Poll::Ready(Ok(()))

pub fn set_max_item(&mut self, max_item: usize) -> &mut Self

Set how many item can be buffered by this sink before needing to flush.

impl<FlushI, E, ReadyI, SendI, Item> SinkMock<FlushI, ReadyI, SendI, Item> where
    FlushI: Iterator<Item = Poll<Result<(), E>>>,
    ReadyI: Iterator<Item = E>,
    SendI: Iterator<Item = E>, 

pub fn new(
    flush_feedback: FlushI,
    ready_fallback: ReadyI,
    send_fallback: SendI,
    max_item: usize,
    flush_at_once: usize
) -> Self

Create a new instance of SinkMock

Arguments

• flush_feedback - an iterator that represent reaction on flushing data to it. Every time when poll_flush() is called the item from iterator is taken and unwrapped and depends on result an special action is taken:

  • Poll::Ready(Ok(())) discard flush_at_once items from buffer. Repeat
  • Poll::Ready(Err(e)) forward error
  • Poll::Pending wake up Waker from Context and return Poll::Pending

• send_fallback - an iterator that represent when start start_send() called with item: Item should return error. If iterator yield iter_item start_send() returns Err(iter_item) discarding item. If iterator return None item is buffered.

• ready_fallback - an iterator that represent when poll_ready() should return error. If iterator yield iter_item poll_ready() returns Err(iter_item). Otherwise return Poll::Ready(Ok(()) if can buffer next item else return result from calling poll_flush()

• max_item - how many item this sink can buffer

• flush_at_once - how many item will be removed from buffer when flush_feedback return Poll::Ready(Ok(()))

impl<FlushI, E, Item> SinkMock<FlushI, Empty<E>, Empty<E>, Item> where
    FlushI: Iterator<Item = Poll<Result<(), E>>>, 

pub fn with_flush_feedback(flush_feedback: FlushI) -> Self

Create a sink that will never return Error on start_send and poll_ready.

This method will use

Trait Implementations

impl<Item, FlushI, ReadyI, SendI, E> Sink<Item> for SinkMock<FlushI, ReadyI, SendI, Item> where
    FlushI: Iterator<Item = Poll<Result<(), E>>>,
    ReadyI: Iterator<Item = E>,
    SendI: Iterator<Item = E>, 

type Error = E

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: Item) -> 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<FlushI, ReadyI, SendI, Item> Unpin for SinkMock<FlushI, ReadyI, SendI, Item>