Move std::io::read_to_string to alloc::io

library/alloc/src/io/cursor.rs

@@ -1,11 +1,108 @@
 use crate::alloc::Allocator;
 use crate::boxed::Box;
 use crate::io::{
-    self, Cursor, ErrorKind, IoSlice, WriteThroughCursor, slice_write, slice_write_all,
-    slice_write_all_vectored, slice_write_vectored,
+    self, BorrowedCursor, Cursor, ErrorKind, IoSlice, IoSliceMut, Read, WriteThroughCursor,
+    slice_write, slice_write_all, slice_write_all_vectored, slice_write_vectored,
 };
+use crate::string::String;
 use crate::vec::Vec;
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> Read for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let n = Read::read(&mut Cursor::split(self).1, buf)?;
+        self.set_position(self.position() + n as u64);
+        Ok(n)
+    }
+
+    fn read_buf(&mut self, mut cursor: BorrowedCursor<'_, u8>) -> io::Result<()> {
+        let prev_written = cursor.written();
+
+        Read::read_buf(&mut Cursor::split(self).1, cursor.reborrow())?;
+
+        self.set_position(self.position() + (cursor.written() - prev_written) as u64);
+
+        Ok(())
+    }
+
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        let mut nread = 0;
+        for buf in bufs {
+            let n = self.read(buf)?;
+            nread += n;
+            if n < buf.len() {
+                break;
+            }
+        }
+        Ok(nread)
+    }
+
+    fn is_read_vectored(&self) -> bool {
+        true
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        let result = Read::read_exact(&mut Cursor::split(self).1, buf);
+
+        match result {
+            Ok(_) => self.set_position(self.position() + buf.len() as u64),
+            // The only possible error condition is EOF, so place the cursor at "EOF"
+            Err(_) => self.set_position(self.get_ref().as_ref().len() as u64),
+        }
+
+        result
+    }
+
+    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_, u8>) -> io::Result<()> {
+        let prev_written = cursor.written();
+
+        let result = Read::read_buf_exact(&mut Cursor::split(self).1, cursor.reborrow());
+        self.set_position(self.position() + (cursor.written() - prev_written) as u64);
+
+        result
+    }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let content = Cursor::split(self).1;
+        let len = content.len();
+        buf.try_reserve(len)?;
+        cfg_select! {
+            no_global_oom_handling => {
+                buf.try_extend_from_slice_of_bytes(content)?;
+            }
+            _ => {
+                buf.extend_from_slice(content);
+            }
+        }
+        self.set_position(self.position() + len as u64);
+
+        Ok(len)
+    }
+
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        let content =
+            crate::str::from_utf8(Cursor::split(self).1).map_err(|_| io::Error::INVALID_UTF8)?;
+        let len = content.len();
+        buf.try_reserve(len)?;
+
+        cfg_select! {
+            no_global_oom_handling => {
+                buf.try_push_str(content)?;
+            }
+            _ => {
+                buf.push_str(content);
+            }
+        }
+
+        self.set_position(self.position() + len as u64);
+
+        Ok(len)
+    }
+}
+
 /// Reserves the required space, and pads the vec with 0s if necessary.
 fn reserve_and_pad<A: Allocator>(
     pos_mut: &mut u64,