Struct kiro_editor::StdinRawMode

pub struct StdinRawMode { /* fields omitted */ }

Methods

impl StdinRawMode

pub fn new() -> Result<StdinRawMode>

pub fn input_keys(self) -> InputSequences

Methods from Deref<Target = Stdin>

pub fn lock(&self) -> StdinLock

Locks this handle to the standard input stream, returning a readable guard.

The lock is released when the returned lock goes out of scope. The returned guard also implements the Read and BufRead traits for accessing the underlying data.

Examples

use std::io::{self, Read};

fn main() -> io::Result<()> {
    let mut buffer = String::new();
    let stdin = io::stdin();
    let mut handle = stdin.lock();

    handle.read_to_string(&mut buffer)?;
    Ok(())
}

pub fn read_line(&self, buf: &mut String) -> Result<usize, Error>

Locks this handle and reads a line of input into the specified buffer.

For detailed semantics of this method, see the documentation on BufRead::read_line.

Examples

use std::io;

let mut input = String::new();
match io::stdin().read_line(&mut input) {
    Ok(n) => {
        println!("{} bytes read", n);
        println!("{}", input);
    }
    Err(error) => println!("error: {}", error),
}

You can run the example one of two ways:

• Pipe some text to it, e.g., printf foo | path/to/executable
• Give it text interactively by running the executable directly, in which case it will wait for the Enter key to be pressed before continuing

Trait Implementations

impl Drop for StdinRawMode

fn drop(&mut self)

Executes the destructor for this type.

impl DerefMut for StdinRawMode

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Deref for StdinRawMode

type Target = Stdin

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.