Add Read::size_snapshot

Author: sunfishcode

src/libstd/fs.rs

@@ -449,6 +449,19 @@ impl Read for File {
         self.inner.read(buf)
     }
 
+    fn size_snapshot(&self) -> Option<usize> {
+        if let Ok(meta) = self.metadata() {
+            let len = meta.len();
+            let size = len as usize;
+            // Don't trust a length of zero. For example, "pseudofiles" on Linux
+            // like /proc/meminfo report a size of 0.
+            if size != 0 && size as u64 == len {
+                return Some(size);
+            }
+        }
+        None
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         Initializer::nop()
@@ -473,6 +486,10 @@ impl<'a> Read for &'a File {
         self.inner.read(buf)
     }
 
+    fn size_snapshot(&self) -> Option<usize> {
+        (**self).size_snapshot()
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         Initializer::nop()

src/libstd/io/buffered.rs

@@ -211,6 +211,15 @@ impl<R: Read> Read for BufReader<R> {
         Ok(nread)
     }
 
+    #[inline]
+    fn size_snapshot(&self) -> Option<usize> {
+        let buffered_len = self.cap - self.pos;
+        if let Some(size) = self.inner.size_snapshot() {
+            return buffered_len.checked_add(size);
+        }
+        None
+    }
+
     // we can't skip unconditionally because of the large buffer case in read.
     unsafe fn initializer(&self) -> Initializer {
         self.inner.initializer()

src/libstd/io/cursor.rs

@@ -237,6 +237,16 @@ impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
         Ok(())
     }
 
+    fn size_snapshot(&self) -> Option<usize> {
+        if let Some(diff) = (self.inner.as_ref().len() as u64).checked_sub(self.pos) {
+            let size = diff as usize;
+            if size as u64 == diff {
+                return Some(size);
+            }
+        }
+        None
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         Initializer::nop()

src/libstd/io/impls.rs

@@ -23,6 +23,11 @@ impl<'a, R: Read + ?Sized> Read for &'a mut R {
         (**self).read(buf)
     }
 
+    #[inline]
+    fn size_snapshot(&self) -> Option<usize> {
+        (**self).size_snapshot()
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         (**self).initializer()
@@ -92,6 +97,11 @@ impl<R: Read + ?Sized> Read for Box<R> {
         (**self).read(buf)
     }
 
+    #[inline]
+    fn size_snapshot(&self) -> Option<usize> {
+        (**self).size_snapshot()
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         (**self).initializer()
@@ -181,6 +191,11 @@ impl<'a> Read for &'a [u8] {
         Ok(amt)
     }
 
+    #[inline]
+    fn size_snapshot(&self) -> Option<usize> {
+        Some(self.len())
+    }
+
     #[inline]
     unsafe fn initializer(&self) -> Initializer {
         Initializer::nop()

src/libstd/io/mod.rs

@@ -553,6 +553,21 @@ pub trait Read {
         Initializer::zeroing()
     }
 
+    /// Return a snapshot of how many bytes would be read from this source until EOF
+    /// if read immediately, or None if that is unknown. Depending on the source, the
+    /// size may change at any time, so this isn't a guarantee that exactly that number
+    /// of bytes will actually be read.
+    ///
+    /// This is used by [`read_to_end`] and [`read_to_string`] to pre-allocate a memory buffer.
+    ///
+    /// [`read_to_end`]: #method.read_to_end
+    /// [`read_to_string`]: #method.read_to_string
+    #[unstable(feature = "read_size_snapshot", issue = /* FIXME */ "0")]
+    #[inline]
+    fn size_snapshot(&self) -> Option<usize> {
+        None
+    }
+
     /// Read all bytes until EOF in this source, placing them into `buf`.
     ///
     /// All bytes read from this source will be appended to the specified buffer
@@ -1729,6 +1744,19 @@ impl<T: Read, U: Read> Read for Chain<T, U> {
         self.second.read(buf)
     }
 
+    fn size_snapshot(&self) -> Option<usize> {
+        if self.done_first {
+            self.second.size_snapshot()
+        } else {
+            if let Some(second_size) = self.second.size_snapshot() {
+                if let Some(first_size) = self.first.size_snapshot() {
+                    return first_size.checked_add(second_size);
+                }
+            }
+            None
+        }
+    }
+
     unsafe fn initializer(&self) -> Initializer {
         let initializer = self.first.initializer();
         if initializer.should_initialize() {
@@ -1927,6 +1955,17 @@ impl<T: Read> Read for Take<T> {
         Ok(n)
     }
 
+    fn size_snapshot(&self) -> Option<usize> {
+        if let Some(inner_size) = self.inner.size_snapshot() {
+            let min = cmp::min(self.limit, inner_size as u64);
+            let size = min as usize;
+            if size as u64 == min {
+                return Some(size);
+            }
+        }
+        None
+    }
+
     unsafe fn initializer(&self) -> Initializer {
         self.inner.initializer()
     }