Struct Output

pub struct Output<'a> { /* private fields */ }

A terminal Connection’s output.

Since terminal output is buffered, actually executing commands requires flushing the output. As a convenience, Output::print and Output::println write strings and Output::exec writes individual commands, while also flushing the output on every invocation.

Implementations

impl Output<'_>

pub fn print<T: AsRef<str>>(&mut self, text: T) -> Result<()>

Write and flush the text.

pub fn println<T: AsRef<str>>(&mut self, text: T) -> Result<()>

Write and flush the text followed by carriage return and line feed.

pub fn exec<C: Command>(&mut self, cmd: C) -> Result<()>

Execute the command.

This method writes the display for the given command and then flushes the terminal output.

pub fn exec_defer<C1, C2>(&mut self, cmd1: C1, cmd2: C2) -> Result<()>

where C1: Command, C2: Command + Send + 'static,

Execute one command and defer the other.

This method tries to write the first command to the terminal’s output. If that succeeds, it enqueues the second command for execution when the connection is being closed and then flushes the output.

The second command must be 'static, so that it is alive for the lifetime of the connection. It must be Send, so that connection objects can be moved across threads. Since most commands are zero-sized types, they trivially fulfill both requirements.

Trait Implementations

impl<'a> Debug for Output<'a>

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

Formats the value using the given formatter.

impl Write for Output<'_>

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

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

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

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<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬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<(), Error>

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.