Struct io_streams::StreamDuplexer

pub struct StreamDuplexer { /* fields omitted */ }

An unbuffered and unlocked interactive combination input and output stream, implementing Read and Write.

This may hold two file descriptors, one for reading and one for writing, such as stdin and stdout, or it may hold one file handle for both reading and writing, such as for a TCP socket.

There is no file constructor, even though File implements both Read and Write, because normal files are not interactive. However, there is a char_device constructor for character device files.

Implementations

impl StreamDuplexer

pub fn stdin_stdout() -> Result<Self>

Duplex with stdin and stdout, taking ownership of them.

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

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

#[must_use]

pub fn tcp_stream<Socketlike: IntoUnsafeSocket>(socketlike: Socketlike) -> Self

Duplex with 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

Duplex with an open Unix-domain stream, taking ownership of it.

#[must_use]

pub fn pipe_reader_writer(
    pipe_reader: PipeReader,
    pipe_writer: PipeWriter
) -> Self

Duplex with a pair of pipe streams, taking ownership of them.

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

Spawn the given command and duplex with its standard input and output.

#[must_use]

pub fn child_stdout_stdin(
    child_stdout: ChildStdout,
    child_stdin: ChildStdin
) -> Self

Duplex with a child process’ stdout and stdin, taking ownership of them.

pub fn null() -> Result<Self>

Read and write with the null device, which ignores all data, and produces no data.

Trait Implementations

impl AsRawReadWriteFd for StreamDuplexer

fn as_raw_read_fd(&self) -> RawFd

Extracts the raw file descriptor for reading.

fn as_raw_write_fd(&self) -> RawFd

Extracts the raw file descriptor for writing.

impl Debug for StreamDuplexer

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

Formats the value using the given formatter.

impl Peek for StreamDuplexer

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 StreamDuplexer

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.

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 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 ReadReady for StreamDuplexer

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

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

impl Write for StreamDuplexer

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>

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<()>

Attempts to write an entire buffer into this writer.

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

🔬 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<()>

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.

impl Duplex for StreamDuplexer

impl OwnsRaw for StreamDuplexer