Struct basic_text::TextDuplexer

pub struct TextDuplexer<Inner: HalfDuplex + ReadStr + WriteStr> { /* fields omitted */ }

A HalfDuplex implementation which translates from an input HalfDuplex implementation producing an arbitrary byte sequence into a valid Basic Text stream.

Implementations

impl<Inner: HalfDuplex + ReadStr + ReadLayered + ReadStrLayered + WriteStr + WriteLayered> TextDuplexer<Inner>

pub fn new(inner: Inner) -> Self

Construct a new instance of TextDuplexer wrapping inner.

pub fn with_bom_compatibility(mut inner: Inner) -> Result<Self>

Like new, but writes a U+FEFF (BOM) to the beginning of the output stream for compatibility with consumers that require that to determine the text encoding.

pub fn with_crlf_compatibility(inner: Inner) -> Self

Like new, but enables CRLF output mode, which translates "\n" to "\r\n" for compatibility with consumers that need that.

Note: This is not often needed; even on Windows these days most things are ok with plain '\n' line endings, including Windows Notepad. The main notable things that really need them are IETF RFCs, for example RFC-5198.

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

Flush and close the underlying stream and return the underlying stream object.

pub fn abandon_into_inner(self) -> Inner

Return the underlying stream object.

Trait Implementations

impl<Inner: HalfDuplexLayered + ReadStr + WriteStr + AsRawFd> AsRawFd for TextDuplexer<Inner>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> Bufferable for TextDuplexer<Inner>

fn suggested_buffer_size(&self) -> usize

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

fn abandon(&mut self)

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

impl<Inner: HalfDuplexLayered + ReadStr + WriteStr + Debug> Debug for TextDuplexer<Inner>

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

Formats the value using the given formatter.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> Duplex for TextDuplexer<Inner>

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> Read for TextDuplexer<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_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.

pub fn read_vectored(
    &mut self,
    bufs: &mut [IoSliceMut<'_>]
) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

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

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 read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

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<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> ReadLayered for TextDuplexer<Inner>

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

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

fn minimum_buffer_size(&self) -> usize

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

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

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

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

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

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> ReadStr for TextDuplexer<Inner>

fn read_str(&mut self, buf: &mut str) -> Result<usize>

Like read but produces the result in a str. Be sure to check the size field of the return value to see how many bytes were written.

fn read_exact_str(&mut self, buf: &mut str) -> Result<()>

Like read_exact but produces the result in a str.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> ReadStrLayered for TextDuplexer<Inner>

fn read_str_with_status(&mut self, buf: &mut str) -> Result<(usize, Status)>

Like read_with_status but produces the result in a str. Be sure to check the return value to see how many bytes were written.

fn read_exact_str_using_status(&mut self, buf: &mut str) -> Result<Status>

Like read_exact but produces the result in a str.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> ReadText for TextDuplexer<Inner>

fn read_text(&mut self, buf: &mut TextStr) -> Result<usize>

Like read but produces the result in a TextStr. Be sure to check the size field of the return value to see how many bytes were written.

fn read_exact_text(&mut self, buf: &mut TextStr) -> Result<()>

Like read_exact but produces the result in a TextStr.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> Write for TextDuplexer<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 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_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

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.

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

Attempts to write an entire buffer into this writer.

pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

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

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

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> WriteLayered for TextDuplexer<Inner>

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

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

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

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

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> WriteStr for TextDuplexer<Inner>

fn write_str(&mut self, s: &str) -> Result<()>

Like Write::write_all, but takes a &str, allowing implementors which require valid UTF-8 to avoid re-validating the data.

impl<Inner: HalfDuplexLayered + ReadStrLayered + WriteStr> WriteText for TextDuplexer<Inner>

fn write_text(&mut self, s: &TextStr) -> Result<()>

Like WriteStr::write_str but writes from a TextStr.