Struct async_compat::Compat

pub struct Compat<T> { /* private fields */ }

Compatibility adapter for futures and I/O types.

Implementations

impl<T> Compat<T>

pub fn new(t: T) -> Compat<T>

Applies the compatibility adapter to a future or an I/O type.

Examples

Apply it to a future:

use async_compat::Compat;
use std::time::Duration;

futures::executor::block_on(Compat::new(async {
    // We can use tokio's timers because we're inside tokio context.
    tokio::time::sleep(Duration::from_secs(1)).await;
}));

Apply it to an I/O type:

use async_compat::{Compat, CompatExt};
use futures::prelude::*;

futures::executor::block_on(Compat::new(async {
    // The `write_all` method comes from `futures::io::AsyncWriteExt`.
    Compat::new(tokio::io::stdout()).write_all(b"hello\n").await?;
    Ok(())
}))

pub fn get_ref(&self) -> &T

Gets a shared reference to the inner value.

Examples

use async_compat::Compat;
use tokio::net::UdpSocket;

futures::executor::block_on(Compat::new(async {
    let socket = Compat::new(UdpSocket::bind("127.0.0.1:0").await?);
    let addr = socket.get_ref().local_addr()?;
    Ok(())
}))

pub fn get_mut(&mut self) -> &mut T

Gets a mutable reference to the inner value.

Examples

use async_compat::Compat;
use tokio::net::TcpListener;

futures::executor::block_on(Compat::new(async {
    let mut listener = Compat::new(TcpListener::bind("127.0.0.1:0").await?);
    let (stream, addr) = listener.get_mut().accept().await?;
    let stream = Compat::new(stream);
    Ok(())
}))

pub fn into_inner(self) -> T

Unwraps the compatibility adapter.

Examples

use async_compat::Compat;

let stdout = Compat::new(tokio::io::stdout());
let original = stdout.into_inner();

Trait Implementations

impl<T: AsyncBufRead> AsyncBufRead for Compat<T>

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

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<T: AsyncBufRead> AsyncBufRead for Compat<T>

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

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<T: AsyncRead> AsyncRead for Compat<T>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_> ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<T: AsyncRead> AsyncRead for Compat<T>

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

Attempt to read from the AsyncRead into buf.

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<T: AsyncSeek> AsyncSeek for Compat<T>

fn poll_seek( self: Pin<&mut Self>, cx: &mut Context<'_>, pos: SeekFrom ) -> Poll<Result<u64>>

Attempt to seek to an offset, in bytes, in a stream.

impl<T: AsyncSeek> AsyncSeek for Compat<T>

fn start_seek(self: Pin<&mut Self>, pos: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

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

Waits for a seek operation to complete.

impl<T: AsyncWrite> AsyncWrite for Compat<T>

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: AsyncWrite> AsyncWrite for Compat<T>

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<()>>

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

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

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

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

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<T: Future> Future for Compat<T>

type Output = <T as Future>::Output

The type of value produced on completion.

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

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

impl<'__pin, T> Unpin for Compat<T>where __Origin<'__pin, T>: Unpin,