Struct StdWriteAdapterFuture 

pub struct StdWriteAdapterFuture<W, T, F> { /* private fields */ }

Available on crate feature io only.

An asynchronous operation implemented using a restricted function taking std::io::Write.

This is a Future that calls F each time it’s polled, passing in a restricted writer. The closure F may pass this writer to other functions which require std::io::Write as long as those functions guarantee correct restarting in the presence of WouldBlock errors.

E.g. given fn perform_single_write(&mut self, writer: impl Write) -> io::Result<()> which guarantees to keep consistent state in self even if writer returns error, one might write code like this:

StdWriteAdapterFuture::new_assuming_correct_usage(writer, |writer| {
    if self.needs_write() {
        match self.perform_single_write() {
            Ok(()) => (),
            Err(error) if error.kind() == ErrorKind::WouldBlock => {
                Poll::Pending
            }
            Err(error) => Poll::Ready(Err(error)),
        }
    } else {
        Poll::Ready(Ok(()))
    }
})

Implementations

impl<W: AsyncWrite, T, F: FnMut(StdWriteAdapter<'_, '_, Pin<&mut W>>) -> Poll<T>> StdWriteAdapterFuture<W, T, F>

pub fn new_assuming_correct_usage(writer: W, f: F) -> Self

Constructs the future.

It is required that the closure f only passes the writer given to it to functions that guarantee correct restarting in case of WouldBlock errors. In particular, the write_all method on the writer MUST NOT be called (it will panic) but also any other code that behaves similarly by keeping the state on the stack and losing it if error happens (easy to do by accident unless specific care was taken to avoid it).

Trait Implementations

impl<W: AsyncWrite, T, F: FnMut(StdWriteAdapter<'_, '_, Pin<&mut W>>) -> Poll<T>> Future for StdWriteAdapterFuture<W, T, F>

type Output = T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin, W, T, F> Unpin for StdWriteAdapterFuture<W, T, F>

where PinnedFieldsOf<__Origin<'__pin, W, T, F>>: Unpin,