Struct CommandQueue 

pub struct CommandQueue<W> { /* private fields */ }

Available on crate feature term only.

A buffered queue of terminal commands for a Compio asynchronous writer.

Commands are encoded with Command::write_ansi and written in one ordered batch when flush is awaited. The writer can be Compio’s standard output handle or any other type that implements compio_io::AsyncWrite.

Call flush before this value is dropped. Dropping it discards commands that are still queued.

Example

use std::io;

use compio_term::{Queueable, cursor::MoveTo, style::Print};

#[compio_macros::main]
async fn main() -> io::Result<()> {
    let mut stdout = compio_fs::stdout();
    let mut output = stdout.queue(MoveTo(0, 0))?;
    output.queue_many((Print("ready"), Print("\r\n")))?;
    output.flush().await
}

Implementations

impl<W> CommandQueue<W>

pub fn queue( &mut self, command: impl Command, ) -> Result<&mut CommandQueue<W>, Error>

Adds a command without writing to the underlying writer.

If the command cannot render its ANSI representation, this method removes any bytes that the failed command added. Commands that were already queued remain intact.

pub fn queue_many( &mut self, commands: impl Commands, ) -> Result<&mut CommandQueue<W>, Error>

Adds an ordered batch of commands without writing to the underlying writer.

If any command cannot render its ANSI representation, this method removes every byte added by this call. Commands that were already queued remain intact.

impl<W> CommandQueue<W>

pub fn new(writer: W) -> CommandQueue<W>

Creates an empty command queue for writer.

pub fn with_capacity(capacity: usize, writer: W) -> CommandQueue<W>

Creates an empty command queue with space for at least capacity bytes.

pub fn buffered_len(&self) -> usize

Returns the number of command bytes that have not been written.

pub fn is_empty(&self) -> bool

Returns true when no command bytes are waiting to be written.

impl CommandQueue<Stdout>

pub fn stdout() -> CommandQueue<Stdout>

Creates an empty command queue that writes to standard output.

impl CommandQueue<Stderr>

pub fn stderr() -> CommandQueue<Stderr>

Creates an empty command queue that writes to standard error.

impl<W> CommandQueue<W>

where W: AsyncWrite,

pub async fn flush(&mut self) -> Result<(), Error>

Writes all queued commands and flushes the underlying writer.

A partial write is resumed at the first unwritten byte if this method is called again after a write error. Commands queued after that error stay after the remaining bytes from the failed batch.

Trait Implementations

impl<W> Debug for CommandQueue<W>

where W: Debug,

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

Formats the value using the given formatter.