about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/fmt.rs11
-rw-r--r--src/libstd/io/buffered.rs42
-rw-r--r--src/libstd/io/extensions.rs22
-rw-r--r--src/libstd/io/mem.rs11
-rw-r--r--src/libstd/io/mod.rs6
-rw-r--r--src/libstd/io/result.rs6
-rw-r--r--src/libstd/io/util.rs10
-rw-r--r--src/libstd/macros.rs3
-rw-r--r--src/libstd/rt/backtrace.rs6
9 files changed, 63 insertions, 54 deletions
diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index eb81935a8c9..e140ddba723 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -256,7 +256,7 @@ actually invoking the `write` function defined in this module. Example usage is:
 # #![allow(unused_must_use)]
 use std::io;
 
-let mut w = io::MemWriter::new();
+let mut w = Vec::new();
 write!(&mut w as &mut io::Writer, "Hello {}!", "world");
 ```
 
@@ -415,6 +415,7 @@ use io::Writer;
 use io;
 use result::{Ok, Err};
 use string;
+use vec::Vec;
 
 pub use core::fmt::{Formatter, Result, FormatWriter, rt};
 pub use core::fmt::{Show, Bool, Char, Signed, Unsigned, Octal, Binary};
@@ -443,10 +444,10 @@ pub use core::fmt::{argument, argumentstr, argumentuint};
 /// let s = format_args!(fmt::format, "Hello, {}!", "world");
 /// assert_eq!(s, "Hello, world!".to_string());
 /// ```
-pub fn format(args: &Arguments) -> string::String{
-    let mut output = io::MemWriter::new();
-    let _ = write!(&mut output, "{}", args);
-    string::String::from_utf8(output.unwrap()).unwrap()
+pub fn format(args: &Arguments) -> string::String {
+    let mut output = Vec::new();
+    let _ = write!(&mut output as &mut Writer, "{}", args);
+    string::String::from_utf8(output).unwrap()
 }
 
 impl<'a> Writer for Formatter<'a> {
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 81dc7c8a3ee..25e85f33aa5 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -374,7 +374,7 @@ mod test {
     use prelude::*;
     use super::*;
     use super::super::{IoResult, EndOfFile};
-    use super::super::mem::{MemReader, MemWriter, BufReader};
+    use super::super::mem::{MemReader, BufReader};
     use self::test::Bencher;
     use str::StrPrelude;
 
@@ -447,57 +447,57 @@ mod test {
 
     #[test]
     fn test_buffered_writer() {
-        let inner = MemWriter::new();
+        let inner = Vec::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
         writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
 
         writer.write(&[2]).unwrap();
         let b: &[_] = &[0, 1];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
 
         writer.write(&[3]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
 
         writer.flush().unwrap();
         let a: &[_] = &[0, 1, 2, 3];
-        assert_eq!(a, writer.get_ref().get_ref());
+        assert_eq!(a, writer.get_ref()[]);
 
         writer.write(&[4]).unwrap();
         writer.write(&[5]).unwrap();
-        assert_eq!(a, writer.get_ref().get_ref());
+        assert_eq!(a, writer.get_ref()[]);
 
         writer.write(&[6]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5];
         assert_eq!(a,
-                   writer.get_ref().get_ref());
+                   writer.get_ref()[]);
 
         writer.write(&[7, 8]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
         assert_eq!(a,
-                   writer.get_ref().get_ref());
+                   writer.get_ref()[]);
 
         writer.write(&[9, 10, 11]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         assert_eq!(a,
-                   writer.get_ref().get_ref());
+                   writer.get_ref()[]);
 
         writer.flush().unwrap();
         assert_eq!(a,
-                   writer.get_ref().get_ref());
+                   writer.get_ref()[]);
     }
 
     #[test]
     fn test_buffered_writer_inner_flushes() {
-        let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
+        let mut w = BufferedWriter::with_capacity(3, Vec::new());
         w.write(&[0, 1]).unwrap();
         let a: &[_] = &[];
-        assert_eq!(a, w.get_ref().get_ref());
+        assert_eq!(a, w.get_ref()[]);
         let w = w.unwrap();
         let a: &[_] = &[0, 1];
-        assert_eq!(a, w.get_ref());
+        assert_eq!(a, w[]);
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -536,24 +536,24 @@ mod test {
 
     #[test]
     fn test_line_buffer() {
-        let mut writer = LineBufferedWriter::new(MemWriter::new());
+        let mut writer = LineBufferedWriter::new(Vec::new());
         writer.write(&[0]).unwrap();
         let b: &[_] = &[];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
         writer.write(&[1]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
         writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
         writer.write(&[3, b'\n']).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
-        assert_eq!(writer.get_ref().get_ref(), b);
+        assert_eq!(writer.get_ref()[], b);
     }
 
     #[test]
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 70bf90eef93..4b2ffb4d559 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -171,7 +171,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
 mod test {
     use prelude::*;
     use io;
-    use io::{MemReader, MemWriter, BytesReader};
+    use io::{MemReader, BytesReader};
 
     struct InitialZeroByteReader {
         count: int,
@@ -397,12 +397,12 @@ mod test {
     fn test_read_write_le_mem() {
         let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::MAX];
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         for i in uints.iter() {
             writer.write_le_u64(*i).unwrap();
         }
 
-        let mut reader = MemReader::new(writer.unwrap());
+        let mut reader = MemReader::new(writer);
         for i in uints.iter() {
             assert!(reader.read_le_u64().unwrap() == *i);
         }
@@ -413,12 +413,12 @@ mod test {
     fn test_read_write_be() {
         let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::MAX];
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         for i in uints.iter() {
             writer.write_be_u64(*i).unwrap();
         }
 
-        let mut reader = MemReader::new(writer.unwrap());
+        let mut reader = MemReader::new(writer);
         for i in uints.iter() {
             assert!(reader.read_be_u64().unwrap() == *i);
         }
@@ -428,12 +428,12 @@ mod test {
     fn test_read_be_int_n() {
         let ints = [::i32::MIN, -123456, -42, -5, 0, 1, ::i32::MAX];
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         for i in ints.iter() {
             writer.write_be_i32(*i).unwrap();
         }
 
-        let mut reader = MemReader::new(writer.unwrap());
+        let mut reader = MemReader::new(writer);
         for i in ints.iter() {
             // this tests that the sign extension is working
             // (comparing the values as i32 would not test this)
@@ -446,10 +446,10 @@ mod test {
         //big-endian floating-point 8.1250
         let buf = vec![0x41, 0x02, 0x00, 0x00];
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         writer.write(buf.as_slice()).unwrap();
 
-        let mut reader = MemReader::new(writer.unwrap());
+        let mut reader = MemReader::new(writer);
         let f = reader.read_be_f32().unwrap();
         assert!(f == 8.1250);
     }
@@ -458,11 +458,11 @@ mod test {
     fn test_read_write_f32() {
         let f:f32 = 8.1250;
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         writer.write_be_f32(f).unwrap();
         writer.write_le_f32(f).unwrap();
 
-        let mut reader = MemReader::new(writer.unwrap());
+        let mut reader = MemReader::new(writer);
         assert!(reader.read_be_f32().unwrap() == 8.1250);
         assert!(reader.read_le_f32().unwrap() == 8.1250);
     }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 66ae88cfe51..21de6c2013d 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -12,6 +12,8 @@
 
 //! Readers and Writers for in-memory buffers
 
+#![allow(deprecated)]
+
 use cmp::min;
 use option::None;
 use result::{Err, Ok};
@@ -41,6 +43,14 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
     }
 }
 
+impl Writer for Vec<u8> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+        self.push_all(buf);
+        Ok(())
+    }
+}
+
 /// Writes to an owned, growable byte vector
 ///
 /// # Example
@@ -54,6 +64,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
 ///
 /// assert_eq!(w.unwrap(), vec!(0, 1, 2));
 /// ```
+#[deprecated = "use the Vec<u8> Writer implementation directly"]
 #[deriving(Clone)]
 pub struct MemWriter {
     buf: Vec<u8>,
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 33db3c37666..82bfa3c4e80 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1297,9 +1297,9 @@ 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, ByRefWriter};
+/// use std::io::{stdin, ByRefWriter};
 ///
-/// let mut output = MemWriter::new();
+/// let mut output = Vec::new();
 ///
 /// {
 ///     // Don't give ownership of 'output' to the 'tee'. Instead we keep a
@@ -1308,7 +1308,7 @@ impl<'a> Writer for &'a mut Writer+'a {
 ///     process_input(tee);
 /// }
 ///
-/// println!("input processed: {}", output.unwrap());
+/// println!("input processed: {}", output);
 /// # }
 /// ```
 pub struct RefWriter<'a, W:'a> {
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index ec856e662e3..305bcf9ecbc 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -84,15 +84,15 @@ mod test {
 
     #[test]
     fn test_option_writer() {
-        let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
+        let mut writer: io::IoResult<Vec<u8>> = Ok(Vec::new());
         writer.write(&[0, 1, 2]).unwrap();
         writer.flush().unwrap();
-        assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2));
+        assert_eq!(writer.unwrap(), vec!(0, 1, 2));
     }
 
     #[test]
     fn test_option_writer_error() {
-        let mut writer: io::IoResult<MemWriter> =
+        let mut writer: io::IoResult<Vec<u8>> =
             Err(io::standard_error(io::EndOfFile));
 
         match writer.write(&[0, 0, 0]) {
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index e7598611ec8..4d491beb87b 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -265,7 +265,7 @@ impl<T: Iterator<u8>> Reader for IterReader<T> {
 
 #[cfg(test)]
 mod test {
-    use io::{MemReader, MemWriter, BufReader, ByRefReader};
+    use io::{MemReader, BufReader, ByRefReader};
     use io;
     use boxed::Box;
     use super::*;
@@ -371,18 +371,18 @@ mod test {
     #[test]
     fn test_tee_reader() {
         let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
-                                   MemWriter::new());
+                                   Vec::new());
         assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
         let (_, w) = r.unwrap();
-        assert_eq!(vec!(0, 1, 2), w.unwrap());
+        assert_eq!(vec!(0, 1, 2), w);
     }
 
     #[test]
     fn test_copy() {
         let mut r = MemReader::new(vec!(0, 1, 2, 3, 4));
-        let mut w = MemWriter::new();
+        let mut w = Vec::new();
         copy(&mut r, &mut w).unwrap();
-        assert_eq!(vec!(0, 1, 2, 3, 4), w.unwrap());
+        assert_eq!(vec!(0, 1, 2, 3, 4), w);
     }
 
     #[test]
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 0c91542e5eb..26e9e70dff3 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -253,9 +253,8 @@ macro_rules! format(
 ///
 /// ```
 /// # #![allow(unused_must_use)]
-/// use std::io::MemWriter;
 ///
-/// let mut w = MemWriter::new();
+/// let mut w = Vec::new();
 /// write!(&mut w, "test");
 /// write!(&mut w, "formatted {}", "arguments");
 /// ```
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 0f888bd222c..1938ac09c73 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -1009,12 +1009,10 @@ mod imp {
 #[cfg(test)]
 mod test {
     use prelude::*;
-    use io::MemWriter;
-
     macro_rules! t( ($a:expr, $b:expr) => ({
-        let mut m = MemWriter::new();
+        let mut m = Vec::new();
         super::demangle(&mut m, $a).unwrap();
-        assert_eq!(String::from_utf8(m.unwrap()).unwrap(), $b.to_string());
+        assert_eq!(String::from_utf8(m).unwrap(), $b.to_string());
     }) )
 
     #[test]
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-15 08:29:38 +0000