Struct bevy_internal::tasks::futures_lite::io::BlockOn

pub struct BlockOn<T>(/* private fields */);

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::io::BlockOn;
use futures_lite::pin;
use std::io::Read;

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

let mut blocking_reader = 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>

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

Examples

use futures_lite::io::BlockOn;
use futures_lite::pin;

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

let blocking_reader = BlockOn::new(reader);

pub fn get_ref(&self) -> &T

Gets a reference to the async I/O handle.

Examples

use futures_lite::io::BlockOn;
use futures_lite::pin;

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

let blocking_reader = 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::io::BlockOn;
use futures_lite::pin;

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

let mut blocking_reader = 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::io::BlockOn;
use futures_lite::pin;

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

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

Trait Implementations

impl<T> BufRead for BlockOn<T>

where T: AsyncBufRead + Unpin,

fn fill_buf(&mut self) -> Result<&[u8], Error>

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

fn consume(&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 read.

fn has_data_left(&mut self) -> Result<bool, Error>

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

Check if the underlying Read has any data left to be read.

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

Read all bytes into buf until the delimiter byte or EOF is reached.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

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

Skip all bytes until the delimiter byte or EOF is reached.

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

Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<T> Debug for BlockOn<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Read for BlockOn<T>

where T: AsyncRead + Unpin,

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

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.

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 read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl<T> Seek for BlockOn<T>

where T: AsyncSeek + Unpin,

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

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

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

Rewind to the beginning of a stream.

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

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

Returns the length of this stream (in bytes).

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

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

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

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

Seeks relative to the current position.

impl<T> Write for BlockOn<T>

where T: AsyncWrite + Unpin,

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

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

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

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 Writer 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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.