# `raw_tty`

This crate can be used for generally interacting with a tty's mode safely, but was
created originally to solve the problem of using raw mode with /dev/tty while reading
stdin for data.

# Usage


## Raw Mode

Description from the `termion` crate:
>Managing raw mode.

>Raw mode is a particular state a TTY can have. It signifies that:

>1. No line buffering (the input is given byte-by-byte).
>2. The input is not written out, instead it has to be done manually by the programmer.
>3. The output is not canonicalized (for example, `\n` means "go one line down", not "line
>   break").

>It is essential to design terminal programs.

### Example

```rust
use raw_tty::IntoRawMode;
use std::io::{Write, stdin, stdout};
                                                                                           
fn main() {
    let stdin = stdin().into_raw_mode().unwrap();
    let mut stdout = stdout();
                                                                                           
    write!(stdout, "Hey there.").unwrap();
}
```

### Example with /dev/tty

```rust
use raw_tty::IntoRawMode;
use std::io::{self, Read, Write, stdin, stdout};
use std::fs;
                                                                                           
fn main() -> io::Result<()> {
    let mut tty = fs::OpenOptions::new().read(true).write(true).open("/dev/tty")?;
    // Can use the tty_input for keys while also reading stdin for data.
    let mut tty_input = tty.try_clone()?.into_raw_mode();
    let mut buffer = String::new();
    stdin().read_to_string(&mut buffer)?;
                                                                                           
    write!(tty, "Hey there.")
}
```

## General example

```rust
use raw_tty::GuardMode;
use std::io::{self, Write, stdin, stdout};
                                                                                           
fn test_into_raw_mode() -> io::Result<()> {
    let mut stdin = stdin().guard_mode()?;
    stdin.set_raw_mode()?;
    let mut out = stdout();
                                                                                           
    out.write_all(b"this is a test, muahhahahah\r\n")?;
                                                                                           
    drop(out);
    Ok(())
}
                                                                                           
fn main() -> io::Result<()> {
    let mut stdout = stdout().guard_mode()?;
    stdout.modify_mode(|ios| /* do stuff with termios here */ ios)?;
                                                                                           
    // Have to use &* since TtyModeGuard only implements
    // deref, unlike RawReader which implements read specifically.
    // Otherwise, it wouldn't be recognized as `Write`able.
    write!(&mut *stdout, "Hey there.")
}
                                                                                           
```