blob: f58b0444c6d0748aafe2301ae82bfa11e7bc5fbc [file] [log] [blame]
use std::io::{self, Read};
use std::sync::mpsc;
use std::thread;
use sys::tty::get_tty;
/// Construct an asynchronous handle to the TTY standard input.
/// This allows you to read from standard input _without blocking_ the current thread.
/// Specifically, it works by firing up another thread to handle the event stream, which will then
/// be buffered in a mpsc queue, which will eventually be read by the current thread.
/// This will not read the piped standard input, but rather read from the TTY device, since reading
/// asyncronized from piped input would rarely make sense. In other words, if you pipe standard
/// output from another process, it won't be reflected in the stream returned by this function, as
/// this represents the TTY device, and not the piped standard input.
pub fn async_stdin() -> AsyncReader {
let (send, recv) = mpsc::channel();
thread::spawn(move || for i in get_tty().unwrap().bytes() {
if send.send(i).is_err() {
AsyncReader { recv: recv }
/// An asynchronous reader.
/// This acts as any other stream, with the exception that reading from it won't block. Instead,
/// the buffer will only be partially updated based on how much the internal buffer holds.
pub struct AsyncReader {
/// The underlying mpsc receiver.
recv: mpsc::Receiver<io::Result<u8>>,
// FIXME: Allow constructing an async reader from an arbitrary stream.
impl Read for AsyncReader {
/// Read from the byte stream.
/// This will never block, but try to drain the event queue until empty. If the total number of
/// bytes written is lower than the buffer's length, the event queue is empty or that the event
/// stream halted.
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let mut total = 0;
loop {
if total >= buf.len() {
match self.recv.try_recv() {
Ok(Ok(b)) => {
buf[total] = b;
total += 1;
Ok(Err(e)) => return Err(e),
Err(_) => break,
mod test {
use super::*;
use std::io::Read;
fn test_async_stdin() {
let stdin = async_stdin();