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.

pub fn char_device(char_device: CharDevice) -> Self

This is supported on crate feature char-device only.

Duplex with an open character device, taking ownership of it.

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

pub fn unix_stream(unix_stream: UnixStream) -> Self

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

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 socketpair_stream(stream: SocketpairStream) -> Self

This is supported on non-WASI and crate feature socketpair only.

Duplex with one end of a socketpair stream, taking ownership of it.

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

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

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 socketed_thread_read_first(
    boxed_duplex: Box<dyn HalfDuplex + Send>
) -> Result<Self>

This is supported on non-WASI and crate feature socketpair only.

Duplex with a duplexer from on another thread through a socketpair.

A socketpair is created, new thread is created, boxed_duplex is read from and written to over the socketpair.

Writes to the pipe aren’t synchronous with writes to the boxed Write implementation. To ensure data is flushed all the way through the thread and into the boxed Write implementation, call flush(), which synchronizes with the thread to ensure that is has completed writing all pending output.

pub fn socketed_thread_write_first(
    boxed_duplex: Box<dyn HalfDuplex + Send>
) -> Result<Self>

This is supported on non-WASI and crate feature socketpair only.

Duplex with a duplexer from on another thread through a socketpair.

A socketpair is created, new thread is created, boxed_duplex is written to and read from over the socketpair.

Writes to the pipe aren’t synchronous with writes to the boxed Write implementation. To ensure data is flushed all the way through the thread and into the boxed Write implementation, call flush(), which synchronizes with the thread to ensure that is has completed writing all pending output.

pub fn socketed_thread(
    boxed_duplex: Box<dyn HalfDuplexReadReady + Send>
) -> Result<Self>

This is supported on non-WASI and crate feature socketpair only.

Duplex with a duplexer from on another thread through a socketpair.

A socketpair is created, new thread is created, boxed_duplex is written to and/or read from over the socketpair. ReadReady::num_ready_bytes is used to determine whether to read from or write to boxed_duplex first. This may be inefficient, so if you know which direction should go first, use socketed_thread_read_first or socketed_thread_write_first instead.

Writes to the pipe aren’t synchronous with writes to the boxed Write implementation. To ensure data is flushed all the way through the thread and into the boxed Write implementation, call flush(), which synchronizes with the thread to ensure that is has completed writing all pending output.

pub fn socketed_thread_func(
    func: Box<dyn Send + FnOnce(SocketpairStream) -> Result<SocketpairStream>>
) -> Result<Self>

This is supported on non-WASI and crate feature socketpair only.

Duplex with a function running on another thread through a socketpair.

A socketpair is created, new thread is created, func is called in the new thread and passed one of the ends of the socketstream.

Writes to the pipe aren’t synchronous with writes to the boxed Write implementation. To ensure data is flushed all the way through the thread and into the boxed Write implementation, call flush(), which synchronizes with the thread to ensure that is has completed writing all pending output.

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

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

Extracts the file descriptor for reading.

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

Extracts the 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.

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

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

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 adapter which will chain this stream with another.

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

Creates an adapter 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” adapter for this instance of Write.

impl Duplex for StreamDuplexer