Struct basic_text::TextWriter

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

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.

Examples

use basic_text::TextWriter;
use layered_io::WriteLayered;

let mut output = TextWriter::new(std::io::stdout());

// write to `output`

output.close().unwrap();

Implementations

impl<Inner: Write> TextWriter<Utf8Writer<LayeredWriter<Inner>>>

pub fn new(inner: Inner) -> Self

Construct a new instance of TextWriter wrapping inner, which can be anything that implements Write.

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.

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

pub fn from_utf8(inner: Inner) -> Self

Construct a new instance of TextWriter wrapping inner, which can be anything that implements WriteStr + WriteLayered, such as a Utf8Writer.

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 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 + AsHandleOrSocket> AsHandleOrSocket for TextWriter<Inner>

fn as_handle_or_socket(&self) -> BorrowedHandleOrSocket<'_>

Like AsHandle::as_handle and AsSocket::as_socket but can return either type.

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

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

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