Struct layered_io::LayeredDuplexer

pub struct LayeredDuplexer<Inner> { /* private fields */ }

Adapts an Read + Write to implement HalfDuplexLayered.

Implementations

impl<Inner: Read + Write> LayeredDuplexer<Inner>

pub fn new(inner: Inner) -> Self

Construct a new LayeredDuplexer which wraps inner with default settings.

pub fn with_eos_as_push(inner: Inner) -> Self

Construct a new LayeredDuplexer which wraps inner. When inner reports end of stream (by returning 0), report a push but keep the stream open and continue to read data on it.

For example, when reading a file, when the reader reaches the end of the file it will report it, but consumers may wish to continue reading in case additional data is appended to the file.

pub fn line_by_line(inner: Inner) -> Self

Construct a new LayeredDuplexer which wraps an inner which reads its input line-by-line, such as stdin on a terminal.

pub fn close_into_inner(self) -> Result<Inner>

Close this LayeredDuplexer and return the inner stream.

pub fn abandon_into_inner(self) -> Option<Inner>

Consume this LayeredDuplexer and return the inner stream.

Trait Implementations

impl<Inner: Duplex + AsRawReadWriteFd> AsRawReadWriteFd for LayeredDuplexer<Inner>

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<Inner: Duplex + AsReadWriteFd> AsReadWriteFd for LayeredDuplexer<Inner>

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<Inner> Bufferable for LayeredDuplexer<Inner>

fn abandon(&mut self)

Close the resource and abandon any pending buffered contents or errors.

fn suggested_buffer_size(&self) -> usize

A suggested size, in bytes, for buffering for performance.

impl<Inner: Debug> Debug for LayeredDuplexer<Inner>

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

Formats the value using the given formatter.

impl<Inner> Drop for LayeredDuplexer<Inner>

fn drop(&mut self)

Executes the destructor for this type.

impl<Inner: Read + Write> Read for LayeredDuplexer<Inner>

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<Inner: Read + Write> ReadLayered for LayeredDuplexer<Inner>

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

Like Read::read, but also returns a Status.

fn read_vectored_with_status(
    &mut self,
    bufs: &mut [IoSliceMut<'_>]
) -> Result<(usize, Status)>

Like Read::read_vectored, but also returns a Status.

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

Like Read::read_exact, but uses read_with_status to avoid performing an extra read at the end.

fn minimum_buffer_size(&self) -> usize

Some streams require a buffer of at least a certain size.

impl<Inner: Read + Write> Write for LayeredDuplexer<Inner>

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 Selfwhere
    Self: Sized,

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

impl<Inner: Read + Write> WriteLayered for LayeredDuplexer<Inner>

fn close(&mut self) -> Result<()>

Flush any buffers and declare the end of the stream. Subsequent writes will fail.

fn flush_with_status(&mut self, status: Status) -> Result<()>

Like Write::flush, but has a status parameter describing the future of the stream:

impl<Inner: Read + Write + Duplex> Duplex for LayeredDuplexer<Inner>