Struct nameless::OutputByteStream

pub struct OutputByteStream { /* private fields */ }

An output stream for binary output.

An OutputByteStream implements Write so it supports write, write_all, etc. and can be used anywhere a Write-implementing object is needed.

OutputByteStream is unbuffered (even when it is stdout), so wrapping it in a std::io::BufWriter or std::io::LineWriter is recommended for performance.

The primary way to construct an OutputByteStream is to use it as a type in a kommand argument or clap_derive struct. Command-line arguments will then be automatically converted into output streams. Currently supported syntaxes include:

• Names starting with file: are interpreted as local filesystem URLs providing paths to files to open.
• “-” is interpreted as standard output.
• “(…)” runs a command with a pipe to the child process’ stdin, on platforms whch support it.
• Names which don’t parse as URLs are interpreted as plain local filesystem paths. To force a string to be interpreted as a plain local path, arrange for it to begin with ./ or /.

Programs using OutputByteStream as an argument should avoid using std::io::stdout, std::println, or anything else which uses standard output implicitly.

Implementations

impl OutputByteStream

pub fn write_pseudonym(&mut self, pseudonym: &Pseudonym) -> Result<()>

Write the given Pseudonym to the output stream.

pub fn pseudonym(&self) -> Pseudonym

Return a Pseudonym which encapsulates this stream’s name (typically its filesystem path or its URL). This allows it to be written to an OutputByteStream while otherwise remaining entirely opaque.

pub fn media_type(&self) -> &MediaType

If the output stream metadata implies a particular media type, also known as MIME type, return it. Some output streams know their type, though many do not.

Trait Implementations

impl Bufferable for OutputByteStream

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 Debug for OutputByteStream

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

Formats the value using the given formatter.

impl Write for OutputByteStream

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 write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

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

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

Attempts to write an entire buffer into this writer.

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_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

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

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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl WriteLayered for OutputByteStream

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: