}
/// A reader which can be converted to a RefReader.
+#[deprecated = "use ByRefReader instead"]
pub trait AsRefReader {
/// Creates a wrapper around a mutable reference to the reader.
///
fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self>;
}
+#[allow(deprecated)]
impl<T: Reader> AsRefReader for T {
fn by_ref<'a>(&'a mut self) -> RefReader<'a, T> {
RefReader { inner: self }
}
}
+/// A reader which can be converted to a RefReader.
+pub trait ByRefReader {
+ /// Creates a wrapper around a mutable reference to the reader.
+ ///
+ /// This is useful to allow applying adaptors while still
+ /// retaining ownership of the original value.
+ fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self>;
+}
+
+impl<T: Reader> ByRefReader for T {
+ fn by_ref<'a>(&'a mut self) -> RefReader<'a, T> {
+ RefReader { inner: self }
+ }
+}
+
/// A reader which can be converted to bytes.
pub trait BytesReader {
/// Create an iterator that reads a single byte on
/// # fn process_input<R: Reader>(r: R) {}
/// # fn foo() {
/// use std::io;
-/// use std::io::AsRefReader;
+/// use std::io::ByRefReader;
/// use std::io::util::LimitReader;
///
/// let mut stream = io::stdin();
}
/// A writer which can be converted to a RefWriter.
+#[deprecated = "use ByRefWriter instead"]
pub trait AsRefWriter {
/// Creates a wrapper around a mutable reference to the writer.
///
fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self>;
}
+#[allow(deprecated)]
impl<T: Writer> AsRefWriter for T {
fn by_ref<'a>(&'a mut self) -> RefWriter<'a, T> {
RefWriter { inner: self }
}
}
+/// A writer which can be converted to a RefWriter.
+pub trait ByRefWriter {
+ /// Creates a wrapper around a mutable reference to the writer.
+ ///
+ /// This is useful to allow applying wrappers while still
+ /// retaining ownership of the original value.
+ #[inline]
+ fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self>;
+}
+
+impl<T: Writer> ByRefWriter for T {
+ fn by_ref<'a>(&'a mut self) -> RefWriter<'a, T> {
+ RefWriter { inner: self }
+ }
+}
+
impl<'a> Writer for Box<Writer+'a> {
#[inline]
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
/// # fn process_input<R: Reader>(r: R) {}
/// # fn foo () {
/// use std::io::util::TeeReader;
-/// use std::io::{stdin, MemWriter, AsRefWriter};
+/// use std::io::{stdin, MemWriter, ByRefWriter};
///
/// let mut output = MemWriter::new();
///