# Struct std::io::Stdin [−] [src]

    pub struct Stdin {
        // some fields omitted
    }

A handle to the standard input stream of a process.

Each handle is a shared reference to a global buffer of input data to this process. A handle can be `lock`'d to gain full access to `BufRead` methods (e.g. `.lines()`). Writes to this handle are otherwise locked with respect to other writes.

This handle implements the `Read` trait, but beware that concurrent reads of `Stdin` must be executed with care.

Created by the `io::stdin` method.

## Methods

### `impl Stdin`

#### `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.

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

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

fn main() { 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), } }

    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 Read for Stdin`

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

#### `fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>`

#### `fn read_to_string(&mut self, buf: &mut String) -> Result<usize>`

#### `fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>`

#### `fn by_ref(&mut self) -> &mut Self where Self: Sized`

#### `fn bytes(self) -> Bytes<Self> where Self: Sized`

#### `fn chars(self) -> Chars<Self> where Self: Sized`

#### `fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized`

#### `fn take(self, limit: u64) -> Take<Self> where Self: Sized`

#### `fn tee<W: Write>(self, out: W) -> Tee<Self, W> where Self: Sized`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)