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> TextDuplexer<Utf8Duplexer<LayeredDuplexer<Inner>>>

pub fn new(inner: Inner) -> Self

Construct a new instance of TextDuplexer wrapping inner, which can be anything that implements HalfDuplex.

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 with_nel_compatibility(inner: Inner) -> Result<Self>

Like new, but replaces U+85 (NEL) with U+A instead of U+20.

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

Like new, but replaces U+2028 (LS) and U+2029 (PS) with U+A instead of U+20.

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

pub fn from_utf8(inner: Inner) -> Self

Construct a new instance of TextDuplexer wrapping inner.

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

Like from_utf8, 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 from_utf8_with_crlf_compatibility(inner: Inner) -> Self

Like from_utf8, 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 from_utf8_with_nel_compatibility(inner: Inner) -> Result<Self>

Like from_utf8, but replaces U+85 (NEL) with U+A instead of U+20.

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

Like from_utf8, but replaces U+2028 (LS) and U+2029 (PS) with U+A instead of U+20.

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> 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_substr(&mut self, buf: &mut TextSubstr) -> Result<usize>

Like read_str but for reading Basic Text content. Note that the resulting data may not be a Basic Text string, as it may be eg. a portion of a stream that starts with a non-starter.

fn read_exact_text_substr(&mut self, buf: &mut TextSubstr) -> Result<()>

Like read_exact_str but for reading Basic Text content. As with read_text, the resulting string may not be a Basic Text string.

fn read_to_text_string(&mut self, buf: &mut TextString) -> Result<usize>

Like read_to_string, but reads into a TextString.

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

fn read_text_substr_with_status(
    &mut self,
    buf: &mut TextSubstr
) -> Result<(usize, Status)>

Like read_str_with_status but for reading Basic Text data. Note that the resulting data may not be a Basic Text string, as it may be eg. a portion of a stream that starts with a non-starter.

fn read_exact_text_substr_using_status(
    &mut self,
    buf: &mut TextSubstr
) -> Result<Status>

Like read_exact_str_using_status but for reading Basic Text content. As with read_text, the resulting string may not be a Basic Text string.

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_substr(&mut self, s: &TextSubstr) -> Result<()>

Like WriteStr::write_str but writes from a TextSubstr.

fn write_text(&mut self, buf: &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>