changes to libs

3 files changed, 32 insertions, 14 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 9cd8dbcc509..cbb982e731a 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -14,7 +14,7 @@
 
 use cmp;
 use collections::Collection;
-use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
+use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult, AsRefReader};
 use iter::ExactSize;
 use ops::Drop;
 use option::{Some, None, Option};
@@ -118,6 +118,8 @@ impl<R: Reader> Reader for BufferedReader<R> {
     }
 }
 
+impl<R: Reader> AsRefReader for BufferedReader<R> {}
+
 /// Wraps a Writer and buffers output to it
 ///
 /// It can be excessively inefficient to work directly with a `Writer`. For
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 2f6dd7e4795..c743bee1fc9 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -17,7 +17,7 @@ use collections::Collection;
 use option::None;
 use result::{Err, Ok};
 use io;
-use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
+use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult, AsRefReader, AsRefWriter};
 use slice;
 use slice::AsSlice;
 use vec::Vec;
@@ -97,6 +97,8 @@ impl Writer for MemWriter {
     }
 }
 
+impl AsRefWriter for MemWriter {}
+
 /// Reads from an owned byte vector
 ///
 /// # Example
@@ -163,6 +165,8 @@ impl Reader for MemReader {
     }
 }
 
+impl AsRefReader for MemReader {}
+
 impl Seek for MemReader {
     #[inline]
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
@@ -309,6 +313,8 @@ impl<'a> Reader for BufReader<'a> {
      }
 }
 
+impl<'a> AsRefReader for BufReader<'a> {}
+
 impl<'a> Seek for BufReader<'a> {
     #[inline]
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 7826a6dd9c6..6aba5f67643 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -712,17 +712,6 @@ pub trait Reader {
         })
     }
 
-    /// Create an iterator that reads a single byte on
-    /// each iteration, until EOF.
-    ///
-    /// # Error
-    ///
-    /// Any error other than `EndOfFile` that is produced by the underlying Reader
-    /// is returned by the iterator and should be handled by the caller.
-    fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, Self> {
-        extensions::Bytes::new(self)
-    }
-
     // Byte conversion helpers
 
     /// Reads `n` little-endian unsigned integer bytes.
@@ -932,7 +921,10 @@ pub trait Reader {
     fn read_i8(&mut self) -> IoResult<i8> {
         self.read_byte().map(|i| i as i8)
     }
+}
 
+/// A reader which can be converted to a RefReader.
+pub trait AsRefReader {
     /// Creates a wrapper around a mutable reference to the reader.
     ///
     /// This is useful to allow applying adaptors while still
@@ -942,6 +934,20 @@ pub trait Reader {
     }
 }
 
+/// A reader which can be converted to bytes.
+pub trait BytesReader: Reader {
+    /// Create an iterator that reads a single byte on
+    /// each iteration, until EOF.
+    ///
+    /// # Error
+    ///
+    /// Any error other than `EndOfFile` that is produced by the underlying Reader
+    /// is returned by the iterator and should be handled by the caller.
+    fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, Self> {
+        extensions::Bytes::new(self)
+    }
+}
+
 impl<'a> Reader for Box<Reader+'a> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         let reader: &mut Reader = &mut **self;
@@ -986,6 +992,7 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -
 /// # fn process_input<R: Reader>(r: R) {}
 /// # fn foo() {
 /// use std::io;
+/// use std::io::AsRefReader;
 /// use std::io::util::LimitReader;
 ///
 /// let mut stream = io::stdin();
@@ -1268,7 +1275,10 @@ pub trait Writer {
     fn write_i8(&mut self, n: i8) -> IoResult<()> {
         self.write([n as u8])
     }
+}
 
+/// A writer which can be converted to a RefWriter.
+pub trait AsRefWriter {
     /// Creates a wrapper around a mutable reference to the writer.
     ///
     /// This is useful to allow applying wrappers while still
@@ -1309,7 +1319,7 @@ impl<'a> Writer for &'a mut Writer+'a {
 /// # fn process_input<R: Reader>(r: R) {}
 /// # fn foo () {
 /// use std::io::util::TeeReader;
-/// use std::io::{stdin, MemWriter};
+/// use std::io::{stdin, MemWriter, AsRefWriter};
 ///
 /// let mut output = MemWriter::new();
 ///