Struct io_streams::StreamReader

pub struct StreamReader { /* private fields */ }

An unbuffered and unlocked input byte stream, implementing Read, 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.

Since it is unbuffered, it is often beneficial to wrap the resulting StreamReader in a BufReader.

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

pub fn file<Filelike: IntoFilelike + 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.

Examples found in repository

src/streams.rs (line 321)

    pub fn null() -> io::Result<Self> {
        #[cfg(not(windows))]
        {
            Ok(Self::file(File::open("/dev/null")?))
        }

        #[cfg(windows)]
        {
            Ok(Self::file(File::open("nul")?))
        }
    }

pub fn tcp_stream<Socketlike: IntoSocketlike>(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.

pub fn unix_stream(unix_stream: UnixStream) -> Self

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

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(command: Command) -> Result<Self>

Spawn the given command and read from its standard output.

pub fn child_stdout(child_stdout: ChildStdout) -> Self

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

pub fn child_stderr(child_stderr: ChildStderr) -> Self

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

pub fn piped_thread(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.

Examples found in repository

src/streams.rs (line 354)

    pub fn bytes(bytes: &[u8]) -> io::Result<Self> {
        // If we can write it to a new pipe without blocking, do so.
        #[cfg(not(any(windows, target_os = "redox")))]
        if bytes.len() <= rustix::io::PIPE_BUF {
            let (pipe_reader, mut pipe_writer) = pipe()?;

            pipe_writer.write_all(bytes)?;
            pipe_writer.flush()?;
            drop(pipe_writer);

            let handle = pipe_reader.as_raw_grip();
            return Ok(Self::handle(handle, ReadResources::PipeReader(pipe_reader)));
        }

        // Otherwise, launch a thread.
        Self::piped_thread(Box::new(Cursor::new(bytes.to_vec())))
    }

pub fn null() -> Result<Self>

Read from the null device, which produces no data.

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.

Examples found in repository

src/streams.rs (line 334)

    pub fn str<S: AsRef<str>>(s: S) -> io::Result<Self> {
        Self::bytes(s.as_ref().as_bytes())
    }

Trait Implementations

impl AsFd for StreamReader

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

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.

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 Selfwhere
    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 ReadReady for StreamReader

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

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