Struct futures_lite::io::BlockOn

pub struct BlockOn<T>(_);

Blocks on all async I/O operations and implements std::io traits.

Sometimes async I/O needs to be used in a blocking manner. If calling future::block_on() manually all the time becomes too tedious, use this type for more convenient blocking on async I/O operations.

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

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

Examples

use futures_lite::*;
use std::io::Read;

let reader: &[u8] = b"hello";
pin!(reader);

let mut blocking_reader = io::BlockOn::new(reader);
let mut contents = String::new();

// This line blocks - note that there is no await:
blocking_reader.read_to_string(&mut contents)?;

Implementations

impl<T> BlockOn<T>

pub fn new(io: T) -> BlockOn<T>ⓘ

Important traits for BlockOn<T>

impl<T: AsyncRead + Unpin> Read for BlockOn<T>impl<T: AsyncWrite + Unpin> Write for BlockOn<T>

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

Examples

use futures_lite::*;

let reader: &[u8] = b"hello";
pin!(reader);

let blocking_reader = io::BlockOn::new(reader);

pub fn get_ref(&self) -> &T

Gets a reference to the async I/O handle.

Examples

use futures_lite::*;

let reader: &[u8] = b"hello";
pin!(reader);

let blocking_reader = io::BlockOn::new(reader);
let r = blocking_reader.get_ref();

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

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

Examples

use futures_lite::*;

let reader: &[u8] = b"hello";
pin!(reader);

let mut blocking_reader = io::BlockOn::new(reader);
let r = blocking_reader.get_mut();

pub fn into_inner(self) -> T

Extracts the inner async I/O handle.

Examples

use futures_lite::*;

let reader: &[u8] = b"hello";
pin!(reader);

let blocking_reader = io::BlockOn::new(reader);
let inner = blocking_reader.into_inner();

Trait Implementations

impl<T: Debug> Debug for BlockOn<T>

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

Formats the value using the given formatter.

impl<T: AsyncRead + Unpin> Read for BlockOn<T>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl<T: AsyncSeek + Unpin> Seek for BlockOn<T>

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬 This is a nightly-only experimental API. (seek_convenience)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

🔬 This is a nightly-only experimental API. (seek_convenience)

Returns the current seek position from the start of the stream.

impl<T: AsyncWrite + Unpin> Write for BlockOn<T>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

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

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.