Struct io_streams::StreamReader

pub struct StreamReader { /* fields omitted */ }

An unbuffered and unlocked input byte stream, abstracted over the source of the input.

It primarily consists of a single file handle, and also contains any resources needed to safely hold the file handle live.

Since it is unbuffered, and since many input sources have high per-call overhead, it is often beneficial to wrap this in a BufReader.

Implementations

impl StreamReader

pub fn stdin() -> Result<Self>

Read from standard input.

Unlike std::io::stdin, this stdin returns a stream which is unbuffered and unlocked.

This acquires a std::io::StdinLock to prevent accesses to std::io::Stdin while this is live, and fails if a StreamReader or StreamDuplexer for standard input already exists.

#[must_use]pub fn file<Filelike: IntoUnsafeFile + Read + Write + Seek>(
    filelike: Filelike
) -> Self

Read from an open file, taking ownership of it.

This method can be passed a std::fs::File or similar File types.

#[must_use]pub fn tcp_stream<Socketlike: IntoUnsafeSocket>(socketlike: Socketlike) -> Self

Read from an open TCP stream, taking ownership of it.

This method can be passed a std::net::TcpStream or similar TcpStream types.

#[must_use]pub fn unix_stream(unix_stream: UnixStream) -> Self

Read from an open Unix-domain socket, taking ownership of it.

#[must_use]pub fn pipe_reader(pipe_reader: PipeReader) -> Self

Read from the reading end of an open pipe, taking ownership of it.

pub fn read_from_command(mut command: Command) -> Result<Self>

Spawn the given command and read from its standard output.

#[must_use]pub fn child_stdout(child_stdout: ChildStdout) -> Self

Read from a child process' standard output, taking ownership of it.

#[must_use]pub fn child_stderr(child_stderr: ChildStderr) -> Self

Read from a child process' standard error, taking ownership of it.

pub fn piped_thread(mut boxed_read: Box<dyn Read + Send>) -> Result<Self>

Read from a boxed Read implementation, taking ownership of it. This works by creating a new thread to read the data and write it through a pipe.

pub fn str<S: AsRef<str>>(s: S) -> Result<Self>

Read from the given string.

pub fn bytes(bytes: &[u8]) -> Result<Self>

Read from the given bytes.

Trait Implementations

impl AsRawFd for StreamReader

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for StreamReader

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

Formats the value using the given formatter.

impl Peek for StreamReader

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

Reads data from a stream without consuming it; subsequent reads will re-read the data. May return fewer bytes than requested; Ok(0) indicates that seeking is not possible (but reading may still be).

impl Read for StreamReader

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>

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>

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

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

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

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

Read the exact number of bytes required to fill buf.

pub 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.

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

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

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

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

impl ReadReady for StreamReader

fn num_ready_bytes(&self) -> Result<u64>

Return the number of bytes which are ready to be read immediately.