try to fix msvc once again

Author: Drevoed

src/io/buf_writer.rs

@@ -178,9 +178,9 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
         &mut self.inner
     }
 
-    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
-        self.inner()
-    }
+//    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
+//        self.inner()
+//    }
 
     /// Consumes BufWriter, returning the underlying writer
     ///
@@ -192,9 +192,9 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
         self.inner
     }
 
-    pub fn poll_into_inner(self: Pin<&mut Self>, _cx: Context<'_>) -> Poll<io::Result<usize>> {
-        unimplemented!("poll into inner method")
-    }
+//    pub fn poll_into_inner(self: Pin<&mut Self>, _cx: Context<'_>) -> Poll<io::Result<usize>> {
+//        unimplemented!("poll into inner method")
+//    }
 
     /// Returns a reference to the internally buffered data.
     ///
@@ -217,7 +217,11 @@ impl<W: AsyncWrite + Unpin> BufWriter<W> {
         &self.buf
     }
 
-
+    /// Poll buffer flushing until completion
+    ///
+    /// This is used in types that wrap around BufWrite, one such example: [`LineWriter`]
+    ///
+    /// [`LineWriter`]: struct.LineWriter.html
     pub fn poll_flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         let Self {
             inner,
@@ -289,6 +293,73 @@ impl<W: AsyncWrite + fmt::Debug + Unpin> fmt::Debug for BufWriter<W> {
     }
 }
 
+/// Wraps a writer and buffers output to it, flushing whenever a newline
+/// (`0x0a`, `'\n'`) is detected.
+///
+/// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.
+/// But it only does this batched write when it goes out of scope, or when the
+/// internal buffer is full. Sometimes, you'd prefer to write each line as it's
+/// completed, rather than the entire buffer at once. Enter `LineWriter`. It
+/// does exactly that.
+///
+/// Like [`BufWriter`][bufwriter], a `LineWriter`’s buffer will also be flushed when the
+/// `LineWriter` goes out of scope or when its internal buffer is full.
+///
+/// [bufwriter]: struct.BufWriter.html
+///
+/// If there's still a partial line in the buffer when the `LineWriter` is
+/// dropped, it will flush those contents.
+///
+/// This type is an async version of [`std::io::LineWriter`]
+///
+/// [`std::io::LineWriter`]: https://doc.rust-lang.org/std/io/struct.LineWriter.html
+///
+/// # Examples
+///
+/// We can use `LineWriter` to write one line at a time, significantly
+/// reducing the number of actual writes to the file.
+///
+/// ```no_run
+/// # #![feature(async_await)]
+/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+///     use async_std::io::{LineWriter, Write};
+///     use async_std::fs::{File, self};
+///     let road_not_taken = b"I shall be telling this with a sigh
+/// Somewhere ages and ages hence:
+/// Two roads diverged in a wood, and I -
+/// I took the one less traveled by,
+/// And that has made all the difference.";
+///
+///     let file = File::create("poem.txt").await?;
+///     let mut file = LineWriter::new(file);
+///
+///     file.write_all(b"I shall be telling this with a sigh").await?;
+///
+///     // No bytes are written until a newline is encountered (or
+///     // the internal buffer is filled).
+///     assert_eq!(fs::read_to_string("poem.txt").await?, "");
+///     file.write_all(b"\n").await?;
+///     assert_eq!(
+///         fs::read_to_string("poem.txt").await?,
+///         "I shall be telling this with a sigh\n",
+///     );
+///
+///     // Write the rest of the poem.
+///     file.write_all(b"Somewhere ages and ages hence:
+/// Two roads diverged in a wood, and I -
+/// I took the one less traveled by,
+/// And that has made all the difference.").await?;
+///
+///     // The last line of the poem doesn't end in a newline, so
+///     // we have to flush or drop the `LineWriter` to finish
+///     // writing.
+///     file.flush().await?;
+///
+///     // Confirm the whole poem was written.
+///     assert_eq!(fs::read("poem.txt").await?, &road_not_taken[..]);
+/// #
+/// # Ok(()) }) }
+/// ```
 pub struct LineWriter<W: AsyncWrite + Unpin> {
     inner: BufWriter<W>,
     need_flush: bool,
@@ -340,14 +411,57 @@ impl<W: AsyncWrite + Unpin> LineWriter<W> {
         }
     }
 
+    /// Gets a reference to the underlying writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # #![feature(async_await)]
+    /// # #![allow(unused_mut)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+    /// use async_std::io::LineWriter;
+    /// use async_std::fs::File;
+    ///
+    /// let file = File::create("poem.txt").await?;
+    /// let file = LineWriter::new(file);
+    ///
+    /// // We can use reference just like buffer
+    /// let reference = file.get_ref();
+    /// #
+    /// # Ok(()) }) }
+    /// ```
     pub fn get_ref(&self) -> &W {
         self.inner.get_ref()
     }
 
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// Caution must be taken when calling methods on the mutable reference
+    /// returned as extra writes could corrupt the output stream.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # #![feature(async_await)]
+    /// # #![allow(unused_mut)]
+    /// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+    /// use async_std::io::LineWriter;
+    /// use async_std::fs::File;
+    ///
+    /// let file = File::create("poem.txt").await?;
+    /// let mut file = LineWriter::new(file);
+    ///
+    /// // We can use reference just like buffer
+    /// let reference = file.get_mut();
+    /// #
+    /// # Ok(()) }) }
+    /// ```
     pub fn get_mut(&mut self) -> &mut W {
         self.inner.get_mut()
     }
 
+    //TODO: Implement flushing before returning inner
+    #[allow(missing_docs)]
     pub fn into_inner(self) -> W {
         self.inner.into_inner()
     }
@@ -360,7 +474,7 @@ impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<W> {
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
         if self.need_flush {
-            self.as_mut().poll_flush(cx)?;
+            let _ = self.as_mut().poll_flush(cx)?;
         }
 
         let i = match memchr::memrchr(b'\n', buf) {
@@ -380,13 +494,13 @@ impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<W> {
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.as_mut().inner().poll_flush(cx)?;
+        let _ = self.as_mut().inner().poll_flush(cx)?;
         *self.need_flush() = false;
         Poll::Ready(Ok(()))
     }
 
     fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.as_mut().inner().poll_flush(cx)?;
+        let _ = self.as_mut().inner().poll_flush(cx)?;
         self.inner().poll_close(cx)
     }
 }

src/io/mod.rs

@@ -21,8 +21,6 @@
 //! # Ok(()) }) }
 //! ```
 
-pub(crate) const DEFAULT_CAPACITY: usize = 8 * 1024;
-
 #[doc(inline)]
 pub use std::io::{Error, ErrorKind, Result, SeekFrom};