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(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 + AsRawHandleOrSocket> AsRawHandleOrSocket for TextDuplexer<Inner>

fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket

Like AsRawHandle::as_raw_handle and AsRawSocket::as_raw_socket but can return either type.

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

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

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.

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

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

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

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

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.

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

Attempts to write an entire buffer into this writer.

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

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

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.

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

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