Struct blocking::Unblock

pub struct Unblock<T>(_);

Async interface for blocking I/O.

Blocking I/O must be isolated from async code. This type moves blocking operations onto a special thread pool while exposing a familiar async interface.

This type implements traits Stream, AsyncRead, AsyncWrite, or AsyncSeek if the inner type implements Iterator, Read, Write, or Seek, respectively.

If writing data through the AsyncWrite trait, make sure to flush before dropping the Unblock handle or some buffered data might get lost.

Examples

use blocking::Unblock;
use futures::prelude::*;
use std::io::stdout;

let mut stdout = Unblock::new(stdout());
stdout.write_all(b"Hello world!").await?;
stdout.flush().await?;

Implementations

impl<T> Unblock<T>

pub fn new(io: T) -> Unblock<T>

Wraps a blocking I/O handle into an async interface.

Examples

use blocking::Unblock;
use std::io::stdin;

let stdin = Unblock::new(stdin());

pub async fn get_mut<'_, '_>(&'_ mut self) -> &'_ mut T

Gets a mutable reference to the blocking I/O handle.

This is an async method because the I/O handle might be on the thread pool and needs to be moved onto the current thread before we can get a reference to it.

Examples

use blocking::Unblock;
use std::fs::File;

let mut file = Unblock::new(File::create("file.txt")?);
let metadata = file.get_mut().await.metadata()?;

pub async fn with_mut<'_, R, F>(&'_ mut self, op: F) -> R where
    F: FnOnce(&mut T) -> R + Send + 'static,
    R: Send + 'static,
    T: Send + 'static, 

Performs a blocking operation on the I/O handle.

Examples

use blocking::Unblock;
use std::fs::File;

let mut file = Unblock::new(File::create("file.txt")?);
let metadata = file.with_mut(|f| f.metadata()).await?;

pub async fn into_inner(self) -> T

Extracts the inner blocking I/O handle.

This is an async method because the I/O handle might be on the thread pool and needs to be moved onto the current thread before we can extract it.

Examples

use blocking::Unblock;
use futures::prelude::*;
use std::fs::File;

let mut file = Unblock::new(File::create("file.txt")?);
file.write_all(b"Hello world!").await?;

let file = file.into_inner().await;

Trait Implementations

impl<T: Read + Send + 'static> AsyncRead for Unblock<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: Seek + Send + 'static> AsyncSeek for Unblock<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: Write + Send + 'static> AsyncWrite for Unblock<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: Debug> Debug for Unblock<T>

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

Formats the value using the given formatter.

impl<T: Iterator + Send + 'static> Stream for Unblock<T> where
    T::Item: Send + 'static, 

type Item = T::Item

Values yielded by the stream.

fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<T::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.