Struct basic_text::TextWriter

pub struct TextWriter<Inner> { /* fields omitted */ }

A WriteLayered implementation which translates to an output WriteLayered producing a valid Basic Text stream from an arbitrary byte sequence.

write is not guaranteed to perform a single operation, because short writes could produce invalid UTF-8, so write will retry as needed.

Implementations

impl<Inner: WriteStr + WriteLayered> TextWriter<Inner>

pub fn new(inner: Inner) -> Self

Construct a new instance of TextWriter 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: WriteStr + WriteLayered + AsRawFd> AsRawFd for TextWriter<Inner>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<Inner: WriteStr + WriteLayered> Bufferable for TextWriter<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 TextWriter<Inner>

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

Formats the value using the given formatter.

impl<Inner: OwnsRaw> OwnsRaw for TextWriter<Inner>

impl<Inner: WriteStr + WriteLayered> Write for TextWriter<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: WriteStr + WriteLayered> WriteLayered for TextWriter<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: WriteStr + WriteLayered> WriteStr for TextWriter<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: WriteStr + WriteLayered> WriteText for TextWriter<Inner>

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

Like WriteStr::write_str but writes from a TextStr.