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};

let mut buffer = String::new();
let stdin = io::stdin();
let mut handle = stdin.lock();

handle.read_to_string(&mut buffer)?;

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

Formats the value using the given formatter. Read more

Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more

Determines if this Reader can work with buffers of uninitialized memory. Read more

Read all bytes until EOF in this source, placing them into buf. Read more

Read all bytes until EOF in this source, placing them into buf. Read more

Read the exact number of bytes required to fill buf. Read more

Creates a "by reference" adaptor for this instance of Read. Read more

Transforms this Read instance to an [Iterator] over its bytes. Read more

Transforms this Read instance to an [Iterator] over [char]s. Read more

Creates an adaptor which will chain this stream with another. Read more

Creates an adaptor which will read at most limit bytes from it. Read more

Extracts the raw file descriptor. Read more

Extracts the raw handle, without taking any ownership.