Locking for stdin

src/io/stderr.rs

@@ -1,3 +1,4 @@
+use lazy_static::lazy_static;
 use std::pin::Pin;
 use std::sync::Mutex;
 
@@ -43,6 +44,11 @@ pub fn stderr() -> Stderr {
 #[derive(Debug)]
 pub struct Stderr(Mutex<State>);
 
+#[derive(Debug)]
+pub struct StderrLock<'a>(std::io::StderrLock<'a>);
+
+unsafe impl Send for StderrLock<'_> {}
+
 /// The state of the asynchronous stderr.
 ///
 /// The stderr can be either idle or busy performing an asynchronous operation.
@@ -77,6 +83,35 @@ enum Operation {
     Flush(io::Result<()>),
 }
 
+impl Stderr {
+    /// Locks this handle to the standard error stream, returning a writable guard.
+    ///
+    /// The lock is released when the returned lock goes out of scope. The returned guard also implements the Write trait for writing data.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+    /// #
+    /// use async_std::io;
+    /// use std::io::Write;
+    ///
+    /// let stderr = io::stderr();
+    /// let mut handle = stderr.lock().await;
+    ///
+    /// handle.write_all(b"hello world")?;
+    /// #
+    /// # Ok(()) }) }
+    /// ```
+    pub async fn lock(&self) -> StderrLock<'static> {
+        lazy_static! {
+            static ref STDERR: std::io::Stderr = std::io::stderr();
+        }
+
+        blocking::spawn(move || StderrLock(STDERR.lock())).await
+    }
+}
+
 impl Write for Stderr {
     fn poll_write(
         mut self: Pin<&mut Self>,
@@ -179,3 +214,21 @@ cfg_windows! {
         }
     }
 }
+
+impl Write for StderrLock<'_> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        unimplemented!()
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        unimplemented!()
+    }
+
+    fn poll_close(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        unimplemented!()
+    }
+}

src/io/stdin.rs

@@ -1,3 +1,4 @@
+use lazy_static::lazy_static;
 use std::pin::Pin;
 use std::sync::Mutex;
 
@@ -44,6 +45,11 @@ pub fn stdin() -> Stdin {
 #[derive(Debug)]
 pub struct Stdin(Mutex<State>);
 
+#[derive(Debug)]
+pub struct StdinLock<'a>(std::io::StdinLock<'a>);
+
+unsafe impl Send for StdinLock<'_> {}
+
 /// The state of the asynchronous stdin.
 ///
 /// The stdin can be either idle or busy performing an asynchronous operation.
@@ -132,6 +138,35 @@ impl Stdin {
         })
         .await
     }
+
+    /// 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
+    ///
+    /// ```no_run
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+    /// #
+    /// use async_std::io;
+    /// use crate::async_std::prelude::*;
+    ///
+    /// let mut buffer = String::new();
+    ///
+    /// let stdin = io::stdin();
+    /// let mut handle = stdin.lock().await;
+    ///
+    /// handle.read_to_string(&mut buffer).await?;
+    /// #
+    /// # Ok(()) }) }
+    /// ```
+    pub async fn lock(&self) -> StdinLock<'static> {
+        lazy_static! {
+            static ref STDIN: std::io::Stdin = std::io::stdin();
+        }
+
+        blocking::spawn(move || StdinLock(STDIN.lock())).await
+    }
 }
 
 impl Read for Stdin {
@@ -203,3 +238,13 @@ cfg_windows! {
         }
     }
 }
+
+impl Read for StdinLock<'_> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        unimplemented!()
+    }
+}

src/io/stdout.rs

@@ -1,3 +1,4 @@
+use lazy_static::lazy_static;
 use std::pin::Pin;
 use std::sync::Mutex;
 
@@ -43,6 +44,11 @@ pub fn stdout() -> Stdout {
 #[derive(Debug)]
 pub struct Stdout(Mutex<State>);
 
+#[derive(Debug)]
+pub struct StdoutLock<'a>(std::io::StdoutLock<'a>);
+
+unsafe impl Send for StdoutLock<'_> {}
+
 /// The state of the asynchronous stdout.
 ///
 /// The stdout can be either idle or busy performing an asynchronous operation.
@@ -77,6 +83,35 @@ enum Operation {
     Flush(io::Result<()>),
 }
 
+impl Stdout {
+    /// Locks this handle to the standard error stream, returning a writable guard.
+    ///
+    /// The lock is released when the returned lock goes out of scope. The returned guard also implements the Write trait for writing data.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+    /// #
+    /// use async_std::io;
+    /// use std::io::Write;
+    ///
+    /// let stdout = io::stdout();
+    /// let mut handle = stdout.lock().await;
+    ///
+    /// handle.write_all(b"hello world")?;
+    /// #
+    /// # Ok(()) }) }
+    /// ```
+    pub async fn lock(&self) -> StdoutLock<'static> {
+        lazy_static! {
+            static ref STDOUT: std::io::Stdout = std::io::stdout();
+        }
+
+        blocking::spawn(move || StdoutLock(STDOUT.lock())).await
+    }
+}
+
 impl Write for Stdout {
     fn poll_write(
         mut self: Pin<&mut Self>,
@@ -179,3 +214,21 @@ cfg_windows! {
         }
     }
 }
+
+impl Write for StdoutLock<'_> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        unimplemented!()
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        unimplemented!()
+    }
+
+    fn poll_close(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        unimplemented!()
+    }
+}