[−][src]Struct broot::io::WriteCleanup

pub struct WriteCleanup<W, F, E> where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: Display,  { /* fields omitted */ }

RAII wrapper for writer to control state transitions.

Implementations

impl<W, F, E> WriteCleanup<W, F, E> where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: Display, [src]

pub fn new(writer: W, cleanup: F) -> Self[src]

pub fn build<E2, F2: Fn(&mut W) -> Result<(), E2>>(
    writer: W,
    build: F2,
    cleanup: F
) -> Result<Self, E2>[src]

Trait Implementations

impl<W, F, E> Debug for WriteCleanup<W, F, E> where
    W: Write + Debug,
    F: Fn(&mut W) -> Result<(), E>,
    E: Display, [src]

impl<W, F, E> Drop for WriteCleanup<W, F, E> where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: Display, [src]

impl<W, F, E> Write for WriteCleanup<W, F, E> where
    W: Write,
    F: Fn(&mut W) -> Result<(), E>,
    E: Display, [src]

Auto Trait Implementations

impl<W, F, E> RefUnwindSafe for WriteCleanup<W, F, E> where
    F: RefUnwindSafe,
    W: RefUnwindSafe, 

impl<W, F, E> Send for WriteCleanup<W, F, E> where
    F: Send,
    W: Send, 

impl<W, F, E> Sync for WriteCleanup<W, F, E> where
    F: Sync,
    W: Sync, 

impl<W, F, E> Unpin for WriteCleanup<W, F, E> where
    F: Unpin,
    W: Unpin, 

impl<W, F, E> UnwindSafe for WriteCleanup<W, F, E> where
    F: UnwindSafe,
    W: UnwindSafe, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T, A> ExecutableCommand<A> for T where
    A: Display,
    T: Write, [src]

fn execute(
    &mut self,
    command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>[src]

Executes the given command directly.

The given command its ANSI escape code will be written and flushed onto Self.

Arguments

  • Command

    The command that you want to execute directly.

Example

use std::io::{Write, stdout};
use crossterm::{Result, ExecutableCommand, style::Print};

 fn main() -> Result<()> {
     // will be executed directly
      stdout()
        .execute(Print("sum:\n".to_string()))?
        .execute(Print(format!("1 + 1= {} ", 1 + 1)))?;

      Ok(())

     // ==== Output ====
     // sum:
     // 1 + 1 = 2
 }

Have a look over at the Command API for more details.

Notes

  • In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
  • In case of Windows versions lower than 10, a direct WinApi call will be made. The reason for this is that Windows versions lower than 10 do not support ANSI codes, and can therefore not be written to the given writer. Therefore, there is no difference between execute and queue for those old Windows versions.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, A> QueueableCommand<A> for T where
    A: Display,
    T: Write, [src]

fn queue(
    &mut self,
    command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>[src]

Queues the given command for further execution.

Queued commands will be executed in the following cases:

  • When flush is called manually on the given type implementing io::Write.
  • The terminal will flush automatically if the buffer is full.
  • Each line is flushed in case of stdout, because it is line buffered.

Arguments

  • Command

    The command that you want to queue for later execution.

Examples

use std::io::{Write, stdout};
use crossterm::{Result, QueueableCommand, style::Print};

 fn main() -> Result<()> {
    let mut stdout = stdout();

    // `Print` will executed executed when `flush` is called.
    stdout
        .queue(Print("foo 1\n".to_string()))?
        .queue(Print("foo 2".to_string()))?;

    // some other code (no execution happening here) ...

    // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed.
    stdout.flush()?;

    Ok(())

    // ==== Output ====
    // foo 1
    // foo 2
}

Have a look over at the Command API for more details.

Notes

  • In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
  • In case of Windows versions lower than 10, a direct WinApi call will be made. The reason for this is that Windows versions lower than 10 do not support ANSI codes, and can therefore not be written to the given writer. Therefore, there is no difference between execute and queue for those old Windows versions.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.