Implement Container for some Reader/Writers

src/libstd/io/buffered.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -113,6 +113,12 @@ impl<R: Reader> Reader for BufferedReader<R> {
     }
 }
 
+impl<R: Container> Container for BufferedReader<R> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 /// Wraps a Writer and buffers output to it
 ///
 /// Note that `BufferedWriter` will NOT flush its buffer when dropped.
@@ -200,6 +206,12 @@ impl<W: Writer> Writer for BufferedWriter<W> {
     }
 }
 
+impl<W: Container> Container for BufferedWriter<W> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 /// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
 /// `'\n'`) is detected.
 ///
@@ -245,6 +257,12 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
 }
 
+impl<W: Container> Container for LineBufferedWriter<W> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 struct InternalBufferedWriter<W>(BufferedWriter<W>);
 
 impl<W> InternalBufferedWriter<W> {
@@ -260,6 +278,13 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
     }
 }
 
+impl<W: Container> Container for InternalBufferedWriter<W> {
+    fn len(&self) -> uint {
+        let InternalBufferedWriter(ref inner) = *self;
+        inner.len()
+    }
+}
+
 /// Wraps a Stream and buffers input and output to and from it
 ///
 /// Note that `BufferedStream` will NOT flush its output buffer when dropped.
@@ -344,13 +369,20 @@ impl<S: Stream> Writer for BufferedStream<S> {
     }
 }
 
+impl<S: Container> Container for BufferedStream<S> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 #[cfg(test)]
 mod test {
     extern crate test;
+    use container::Container;
     use io;
     use prelude::*;
     use super::*;
-    use super::super::mem::{MemReader, MemWriter, BufReader};
+    use super::super::mem::{MemReader, MemWriter, BufReader, BufWriter};
     use Harness = self::test::BenchHarness;
 
     /// A type, free to create, primarily intended for benchmarking creation of
@@ -563,6 +595,44 @@ mod test {
         assert_eq!(it.next(), None);
     }
 
+    #[test]
+    fn len() {
+        let buf = [0xff];
+        let r = BufferedReader::new(BufReader::new(buf));
+        assert_eq!(r.len(), buf.len());
+
+        let mut buf = [0];
+        let r = BufferedWriter::new(BufWriter::new(buf));
+        assert_eq!(r.len(), 1);
+
+        let mut buf = [0];
+        let r = LineBufferedWriter::new(BufWriter::new(buf));
+        assert_eq!(r.len(), 1);
+
+        struct S;
+
+        impl io::Writer for S {
+            fn write(&mut self, _: &[u8]) -> io::IoResult<()> {
+                Err(io::standard_error(io::EndOfFile))
+            }
+        }
+
+        impl io::Reader for S {
+            fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+                Err(io::standard_error(io::EndOfFile))
+            }
+        }
+
+        impl Container for S {
+            fn len(&self) -> uint {
+                0
+            }
+        }
+
+        let s = BufferedStream::new(S);
+        assert_eq!(s.len(), 0);
+    }
+
     #[bench]
     fn bench_buffered_reader(bh: &mut Harness) {
         bh.iter(|| {

src/libstd/io/mem.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -119,6 +119,12 @@ impl Seek for MemWriter {
     }
 }
 
+impl Container for MemWriter {
+    fn len(&self) -> uint {
+        self.buf.len()
+    }
+}
+
 /// Reads from an owned byte vector
 ///
 /// # Example
@@ -200,6 +206,12 @@ impl Buffer for MemReader {
     fn consume(&mut self, amt: uint) { self.pos += amt; }
 }
 
+impl Container for MemReader {
+    fn len(&self) -> uint {
+        self.buf.len()
+    }
+}
+
 /// Writes to a fixed-size byte slice
 ///
 /// If a write will not fit in the buffer, it returns an error and does not
@@ -259,6 +271,12 @@ impl<'a> Seek for BufWriter<'a> {
     }
 }
 
+impl<'a> Container for BufWriter<'a> {
+    fn len(&self) -> uint {
+        self.buf.len()
+    }
+}
+
 /// Reads from a fixed-size byte slice
 ///
 /// # Example
@@ -330,12 +348,19 @@ impl<'a> Buffer for BufReader<'a> {
     fn consume(&mut self, amt: uint) { self.pos += amt; }
 }
 
+impl<'a> Container for BufReader<'a> {
+    fn len(&self) -> uint {
+        self.buf.len()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use prelude::*;
     use super::*;
     use io::*;
     use io;
+    use container::Container;
 
     #[test]
     fn test_mem_writer() {
@@ -553,4 +578,23 @@ mod test {
         let mut r = BufWriter::new(buf);
         assert!(r.seek(-1, SeekSet).is_err());
     }
+
+    #[test]
+    fn len() {
+        let buf = [0xff];
+        let r = BufReader::new(buf);
+        assert_eq!(r.len(), buf.len());
+
+        let r = MemReader::new(~[10]);
+        assert_eq!(r.len(), 1);
+
+        let mut r = MemWriter::new();
+        let str = "abc";
+        r.write_str(str).unwrap();
+        assert_eq!(r.len(), str.len());
+
+        let mut buf = [0];
+        let r = BufWriter::new(buf);
+        assert_eq!(r.len(), 1);
+    }
 }

src/libstd/io/mod.rs

@@ -677,6 +677,12 @@ impl<'a, R: Reader> Reader for RefReader<'a, R> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.inner.read(buf) }
 }
 
+impl<'a, R: Container> Container for RefReader<'a, R> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 fn extend_sign(val: u64, nbytes: uint) -> i64 {
     let shift = (8 - nbytes) * 8;
     (val << shift) as i64 >> shift
@@ -886,6 +892,12 @@ impl<'a, W: Writer> Writer for RefWriter<'a, W> {
     fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
 }
 
+impl<'a, W: Container> Container for RefWriter<'a, W> {
+    fn len(&self) -> uint {
+        self.inner.len()
+    }
+}
+
 
 pub trait Stream: Reader + Writer { }
 
@@ -1310,3 +1322,24 @@ pub static UserExec: FilePermission = UserDir;
 
 /// A mask for all possible permission bits
 pub static AllPermissions: FilePermission = 0x1ff;
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+    use io::*;
+    use io::mem::{BufReader, BufWriter};
+    use container::Container;
+
+    #[test]
+    fn len() {
+        let buf = [0xff];
+        let mut r = BufReader::new(buf);
+        let r = r.by_ref();
+        assert_eq!(r.len(), buf.len());
+
+        let mut buf = [0];
+        let mut r = BufWriter::new(buf);
+        let r = r.by_ref();
+        assert_eq!(r.len(), 1);
+    }
+}

src/libstd/io/util.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -10,6 +10,7 @@
 
 use prelude::*;
 use cmp;
+use container::Container;
 use io;
 use vec::bytes::MutableByteVector;
 
@@ -52,6 +53,12 @@ impl<R: Reader> Reader for LimitReader<R> {
     }
 }
 
+impl<R> Container for LimitReader<R> {
+    fn len(&self) -> uint {
+        self.limit
+    }
+}
+
 /// A `Writer` which ignores bytes written to it, like /dev/null.
 pub struct NullWriter;
 
@@ -199,6 +206,7 @@ mod test {
     use io::{MemReader, MemWriter};
     use super::*;
     use prelude::*;
+    use container::Container;
 
     #[test]
     fn test_limit_reader_unlimited() {
@@ -305,4 +313,11 @@ mod test {
         copy(&mut r, &mut w).unwrap();
         assert_eq!(~[0, 1, 2, 3, 4], w.unwrap());
     }
+
+    #[test]
+    fn len() {
+        let r = MemReader::new(~[0, 1, 2, 4]);
+        let r = LimitReader::new(r, 3);
+        assert_eq!(r.len(), 3);
+    }
 }