Struct blocking::Blocking

pub struct Blocking<T>(_);

Async I/O that runs on a thread.

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

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

Examples

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

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

Implementations

impl<T> Blocking<T>

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

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

Examples

use blocking::Blocking;
use std::io::stdin;

// Create an async handle to standard input.
let stdin = Blocking::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::Blocking;
use std::fs::File;

let mut file = Blocking::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::Blocking;
use std::fs::File;

let mut file = Blocking::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::Blocking;
use futures::prelude::*;
use std::fs::File;

let mut file = Blocking::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 Blocking<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: Write + Send + 'static> AsyncWrite for Blocking<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, R> Future for Blocking<T> where
    T: FnOnce() -> R + Send + 'static,
    R: Send + 'static, 

type Output = R

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<T: Iterator + Send + 'static> Stream for Blocking<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.