diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 4478694367621..cd9ef215720f8 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -90,7 +90,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed> for Edges { fn target(&self, e: &Ed) -> Nd { let &(_,t) = e; t } } -# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) } +# pub fn main() { render_to(&mut Vec::new()) } ``` ```no_run @@ -182,7 +182,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed<'a>> for Graph { fn target(&self, e: &Ed) -> Nd { let & &(_,t) = e; t } } -# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) } +# pub fn main() { render_to(&mut Vec::new()) } ``` ```no_run @@ -246,7 +246,7 @@ impl<'a> dot::GraphWalk<'a, Nd<'a>, Ed<'a>> for Graph { fn target(&self, e: &Ed<'a>) -> Nd<'a> { let &(_,t) = e; t } } -# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) } +# pub fn main() { render_to(&mut Vec::new()) } ``` ```no_run @@ -274,7 +274,7 @@ pub fn main() { #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] -#![feature(globs)] +#![feature(globs, slicing_syntax)] pub use self::LabelText::*; @@ -553,7 +553,7 @@ mod tests { use self::NodeLabels::*; use super::{Id, LabelText, LabelStr, EscStr, Labeller}; use super::{Nodes, Edges, GraphWalk, render}; - use std::io::{MemWriter, BufReader, IoResult}; + use std::io::{BufReader, IoResult}; use std::str; /// each node is an index in a vector in the graph. @@ -702,9 +702,9 @@ mod tests { } fn test_input(g: LabelledGraph) -> IoResult { - let mut writer = MemWriter::new(); + let mut writer = Vec::new(); render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer.get_ref()); + let mut r = BufReader::new(writer[]); r.read_to_string() } @@ -809,7 +809,7 @@ r#"digraph hasse_diagram { "branch2", "afterward")); - let mut writer = MemWriter::new(); + let mut writer = Vec::new(); let g = LabelledGraphWithEscStrs::new( "syntax_tree", labels, @@ -817,7 +817,7 @@ r#"digraph hasse_diagram { edge(1, 3, ";"), edge(2, 3, ";" ))); render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer.get_ref()); + let mut r = BufReader::new(writer[]); let r = r.read_to_string(); assert_eq!(r.unwrap().as_slice(), diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index c743b1f57fd71..c773467552a75 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -122,7 +122,6 @@ use util::nodemap::NodeMap; use std::fmt; use std::io; use std::rc::Rc; -use std::str; use std::uint; use syntax::ast; use syntax::ast::*; @@ -742,7 +741,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { #[allow(unused_must_use)] fn ln_str(&self, ln: LiveNode) -> String { - let mut wr = io::MemWriter::new(); + let mut wr = Vec::new(); { let wr = &mut wr as &mut io::Writer; write!(wr, "[ln({}) of kind {} reads", ln.get(), self.ir.lnk(ln)); @@ -751,7 +750,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { self.write_vars(wr, ln, |idx| self.users[idx].writer); write!(wr, " precedes {}]", self.successors[ln.get()].to_string()); } - str::from_utf8(wr.unwrap().as_slice()).unwrap().to_string() + String::from_utf8(wr).unwrap() } fn init_empty(&mut self, ln: LiveNode, succ_ln: LiveNode) { diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index ff50636a8d982..d445da9d1340d 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -28,13 +28,13 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String { src.to_string(), "".to_string()); - let mut out = io::MemWriter::new(); + let mut out = Vec::new(); doit(&sess, lexer::StringReader::new(&sess.span_diagnostic, fm), class, id, &mut out).unwrap(); - String::from_utf8_lossy(out.unwrap().as_slice()).into_string() + String::from_utf8_lossy(out[]).into_string() } /// Exhausts the `lexer` writing the output into `out`. diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 8e9ac7095dae1..0ecb86d8bdd61 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -38,7 +38,7 @@ use std::collections::{HashMap, HashSet}; use std::collections::hash_map::{Occupied, Vacant}; use std::fmt; use std::io::fs::PathExtensions; -use std::io::{fs, File, BufferedWriter, MemWriter, BufferedReader}; +use std::io::{fs, File, BufferedWriter, BufferedReader}; use std::io; use std::str; use std::string::String; @@ -420,7 +420,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult } // Collect the index into a string - let mut w = MemWriter::new(); + let mut w = Vec::new(); try!(write!(&mut w, r#"searchIndex['{}'] = {{"items":["#, krate.name)); let mut lastpath = "".to_string(); @@ -463,7 +463,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult try!(write!(&mut w, "]}};")); - Ok(String::from_utf8(w.unwrap()).unwrap()) + Ok(String::from_utf8(w).unwrap()) } fn write_shared(cx: &Context, diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 7343d67497235..e33895bb640bd 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -28,7 +28,7 @@ extern crate "test" as testing; #[phase(plugin, link)] extern crate log; use std::io; -use std::io::{File, MemWriter}; +use std::io::File; use std::collections::HashMap; use std::collections::hash_map::{Occupied, Vacant}; use serialize::{json, Decodable, Encodable}; @@ -467,12 +467,12 @@ fn json_output(krate: clean::Crate, res: Vec , // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode // straight to the Rust JSON representation. let crate_json_str = { - let mut w = MemWriter::new(); + let mut w = Vec::new(); { let mut encoder = json::Encoder::new(&mut w as &mut io::Writer); krate.encode(&mut encoder).unwrap(); } - String::from_utf8(w.unwrap()).unwrap() + String::from_utf8(w).unwrap() }; let crate_json = match json::from_str(crate_json_str.as_slice()) { Ok(j) => j, diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 03e0452a4158d..2968c53de9aba 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -206,7 +206,6 @@ use self::InternalStackElement::*; use std; use std::collections::{HashMap, TreeMap}; use std::{char, f64, fmt, io, num, str}; -use std::io::MemWriter; use std::mem::{swap, transmute}; use std::num::{Float, FPNaN, FPInfinite, Int}; use std::str::{FromStr, ScalarValue}; @@ -412,14 +411,14 @@ impl<'a> Encoder<'a> { /// Encode the specified struct into a json [u8] pub fn buffer_encode, io::IoError>>(object: &T) -> Vec { //Serialize the object in a string using a writer - let mut m = MemWriter::new(); + let mut m = Vec::new(); // FIXME(14302) remove the transmute and unsafe block. unsafe { let mut encoder = Encoder::new(&mut m as &mut io::Writer); - // MemWriter never Errs + // Vec never Errs let _ = object.encode(transmute(&mut encoder)); } - m.unwrap() + m } } @@ -578,13 +577,13 @@ impl<'a> ::Encoder for Encoder<'a> { if idx != 0 { try!(write!(self.writer, ",")) } // ref #12967, make sure to wrap a key in double quotes, // in the event that its of a type that omits them (eg numbers) - let mut buf = MemWriter::new(); + let mut buf = Vec::new(); // FIXME(14302) remove the transmute and unsafe block. unsafe { let mut check_encoder = Encoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.get_ref()).unwrap(); + let out = str::from_utf8(buf[]).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -839,13 +838,13 @@ impl<'a> ::Encoder for PrettyEncoder<'a> { try!(spaces(self.writer, self.curr_indent)); // ref #12967, make sure to wrap a key in double quotes, // in the event that its of a type that omits them (eg numbers) - let mut buf = MemWriter::new(); + let mut buf = Vec::new(); // FIXME(14302) remove the transmute and unsafe block. unsafe { let mut check_encoder = PrettyEncoder::new(&mut buf); try!(f(transmute(&mut check_encoder))); } - let out = str::from_utf8(buf.get_ref()).unwrap(); + let out = str::from_utf8(buf[]).unwrap(); let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"'; if needs_wrapping { try!(write!(self.writer, "\"")); } try!(f(self)); @@ -892,9 +891,9 @@ impl Json { /// Encodes a json value into a string pub fn to_pretty_str(&self) -> string::String { - let mut s = MemWriter::new(); + let mut s = Vec::new(); self.to_pretty_writer(&mut s as &mut io::Writer).unwrap(); - string::String::from_utf8(s.unwrap()).unwrap() + string::String::from_utf8(s).unwrap() } /// If the Json value is an Object, returns the value associated with the provided key. @@ -2659,12 +2658,11 @@ mod tests { } fn with_str_writer(f: |&mut io::Writer|) -> string::String { - use std::io::MemWriter; use std::str; - let mut m = MemWriter::new(); + let mut m = Vec::new(); f(&mut m as &mut io::Writer); - str::from_utf8(m.unwrap().as_slice()).unwrap().to_string() + string::String::from_utf8(m).unwrap() } #[test] @@ -3286,17 +3284,15 @@ mod tests { fn test_encode_hashmap_with_numeric_key() { use std::str::from_utf8; use std::io::Writer; - use std::io::MemWriter; use std::collections::HashMap; let mut hm: HashMap = HashMap::new(); hm.insert(1, true); - let mut mem_buf = MemWriter::new(); + let mut mem_buf = Vec::new(); { let mut encoder = Encoder::new(&mut mem_buf as &mut io::Writer); hm.encode(&mut encoder).unwrap(); } - let bytes = mem_buf.unwrap(); - let json_str = from_utf8(bytes.as_slice()).unwrap(); + let json_str = from_utf8(mem_buf[]).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -3307,17 +3303,15 @@ mod tests { fn test_prettyencode_hashmap_with_numeric_key() { use std::str::from_utf8; use std::io::Writer; - use std::io::MemWriter; use std::collections::HashMap; let mut hm: HashMap = HashMap::new(); hm.insert(1, true); - let mut mem_buf = MemWriter::new(); + let mut mem_buf = Vec::new(); { let mut encoder = PrettyEncoder::new(&mut mem_buf as &mut io::Writer); hm.encode(&mut encoder).unwrap() } - let bytes = mem_buf.unwrap(); - let json_str = from_utf8(bytes.as_slice()).unwrap(); + let json_str = from_utf8(mem_buf[]).unwrap(); match from_str(json_str) { Err(_) => panic!("Unable to parse json_str: {}", json_str), _ => {} // it parsed and we are good to go @@ -3327,7 +3321,6 @@ mod tests { #[test] fn test_prettyencoder_indent_level_param() { use std::str::from_utf8; - use std::io::MemWriter; use std::collections::TreeMap; let mut tree = TreeMap::new(); @@ -3354,15 +3347,14 @@ mod tests { // Test up to 4 spaces of indents (more?) for i in range(0, 4u) { - let mut writer = MemWriter::new(); + let mut writer = Vec::new(); { let ref mut encoder = PrettyEncoder::new(&mut writer); encoder.set_indent(i); json.encode(encoder).unwrap(); } - let bytes = writer.unwrap(); - let printed = from_utf8(bytes.as_slice()).unwrap(); + let printed = from_utf8(writer[]).unwrap(); // Check for indents at each line let lines: Vec<&str> = printed.lines().collect(); diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index eb81935a8c903..e140ddba723d2 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 81dc7c8a3eef2..25e85f33aa565 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 70bf90eef9382..4b2ffb4d559c4 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 66ae88cfe5125..21de6c2013d2c 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 } } +impl Writer for Vec { + #[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 /// /// assert_eq!(w.unwrap(), vec!(0, 1, 2)); /// ``` +#[deprecated = "use the Vec Writer implementation directly"] #[deriving(Clone)] pub struct MemWriter { buf: Vec, diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 33db3c3766650..82bfa3c4e80ff 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: 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 ec856e662e33c..305bcf9ecbc9c 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 = Ok(MemWriter::new()); + let mut writer: io::IoResult> = 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 = + let mut writer: io::IoResult> = 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 e7598611ec8ae..4d491beb87ba3 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -265,7 +265,7 @@ impl> Reader for IterReader { #[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 0c91542e5eb98..26e9e70dff3e8 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 0f888bd222c27..1938ac09c7355 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] diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 81f3d977e13ff..0543b80f208b1 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -33,7 +33,7 @@ use print::pp; use ptr::P; use std::ascii; -use std::io::{IoResult, MemWriter}; +use std::io::IoResult; use std::io; use std::mem; @@ -169,17 +169,17 @@ impl<'a> State<'a> { pub fn to_string(f: |&mut State| -> IoResult<()>) -> String { use std::raw::TraitObject; - let mut s = rust_printer(box MemWriter::new()); + let mut s = rust_printer(box Vec::new()); f(&mut s).unwrap(); eof(&mut s.s).unwrap(); let wr = unsafe { // FIXME(pcwalton): A nasty function to extract the string from an `io::Writer` - // that we "know" to be a `MemWriter` that works around the lack of checked + // that we "know" to be a `Vec` that works around the lack of checked // downcasts. let obj: &TraitObject = mem::transmute(&s.s.out); - mem::transmute::<*mut (), &MemWriter>(obj.data) + mem::transmute::<*mut (), &Vec>(obj.data) }; - String::from_utf8(wr.get_ref().to_vec()).unwrap() + String::from_utf8(wr.clone()).unwrap() } pub fn binop_to_string(op: BinOpToken) -> &'static str { diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 8266765ba3f27..d5d0e7aeb1736 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -33,7 +33,7 @@ html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] -#![feature(asm, macro_rules, phase, globs)] +#![feature(asm, macro_rules, phase, globs, slicing_syntax)] extern crate getopts; extern crate regex; @@ -848,8 +848,6 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::IoR #[test] fn should_sort_failures_before_printing_them() { - use std::io::MemWriter; - let test_a = TestDesc { name: StaticTestName("a"), ignore: false, @@ -864,7 +862,7 @@ fn should_sort_failures_before_printing_them() { let mut st = ConsoleTestState { log_out: None, - out: Raw(MemWriter::new()), + out: Raw(Vec::new()), use_color: false, total: 0u, passed: 0u, @@ -878,7 +876,7 @@ fn should_sort_failures_before_printing_them() { st.write_failures().unwrap(); let s = match st.out { - Raw(ref m) => String::from_utf8_lossy(m.get_ref()), + Raw(ref m) => String::from_utf8_lossy(m[]), Pretty(_) => unreachable!() }; diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index daef41666af3c..1929f1989d624 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -1027,10 +1027,9 @@ mod tests { #[test] fn test_boxplot_nonpositive() { fn t(s: &Summary, expected: String) { - use std::io::MemWriter; - let mut m = MemWriter::new(); + let mut m = Vec::new(); write_boxplot(&mut m as &mut io::Writer, s, 30).unwrap(); - let out = String::from_utf8(m.unwrap()).unwrap(); + let out = String::from_utf8(m).unwrap(); assert_eq!(out, expected); } diff --git a/src/test/compile-fail/variance-trait-matching-2.rs b/src/test/compile-fail/variance-trait-matching-2.rs index f549c78be9d0d..ed4fdc525729e 100644 --- a/src/test/compile-fail/variance-trait-matching-2.rs +++ b/src/test/compile-fail/variance-trait-matching-2.rs @@ -10,7 +10,6 @@ extern crate serialize; -use std::io::MemWriter; use std::io; use serialize::{Encodable, Encoder}; @@ -18,14 +17,14 @@ pub fn buffer_encode<'a, T:Encodable,io::IoError>>( to_encode_object: &T) -> Vec { - let mut m = MemWriter::new(); + let mut m = Vec::new(); { let mut encoder = serialize::json::Encoder::new(&mut m as &mut io::Writer); //~^ ERROR `m` does not live long enough to_encode_object.encode(&mut encoder); } - m.unwrap() + m } fn main() {} diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 44006a0039abd..3fc2ed5468a6e 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -31,12 +31,11 @@ fn test_rbml<'a, 'b, A: Encodable> + Decodable> >(a1: &A) { - let mut wr = std::io::MemWriter::new(); + let mut wr = Vec::new(); let mut rbml_w = EBwriter::Encoder::new(&mut wr); a1.encode(&mut rbml_w); - let bytes = wr.get_ref(); - let d: serialize::rbml::Doc<'a> = EBDoc::new(bytes); + let d: serialize::rbml::Doc<'a> = EBDoc::new(wr[]); let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d); let a2: A = Decodable::decode(&mut decoder); assert!(*a1 == a2); diff --git a/src/test/run-pass/colorful-write-macros.rs b/src/test/run-pass/colorful-write-macros.rs index 60b6d8f8be064..75b8e39133105 100644 --- a/src/test/run-pass/colorful-write-macros.rs +++ b/src/test/run-pass/colorful-write-macros.rs @@ -10,7 +10,7 @@ // no-pretty-expanded -#![allow(unused_must_use, dead_code)] +#![allow(unused_must_use, dead_code, deprecated)] #![feature(macro_rules)] use std::io::MemWriter; diff --git a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs index 7164547b6b827..a846f852694d3 100644 --- a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs +++ b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs @@ -14,7 +14,6 @@ extern crate serialize; use std::cell::{Cell, RefCell}; -use std::io::MemWriter; use serialize::{Encodable, Decodable}; use serialize::json; diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index 573b57fb44a46..021b609efe251 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -19,7 +19,6 @@ extern crate rand; extern crate rbml; extern crate serialize; -use std::io::MemWriter; use rand::{random, Rand}; use rbml; use rbml::Doc; @@ -59,10 +58,10 @@ struct G { fn roundtrip<'a, T: Rand + Eq + Encodable> + Decodable>>() { let obj: T = random(); - let mut w = MemWriter::new(); + let mut w = Vec::new(); let mut e = Encoder::new(&mut w); obj.encode(&mut e); - let doc = rbml::Doc::new(@w.get_ref()); + let doc = rbml::Doc::new(@w[]); let mut dec = Decoder::new(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index b384d7c558352..59f7eda41610c 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -16,9 +16,7 @@ #![allow(unused_must_use)] use std::fmt; -use std::io::MemWriter; use std::io; -use std::str; struct A; struct B; @@ -161,7 +159,7 @@ pub fn main() { // Basic test to make sure that we can invoke the `write!` macro with an // io::Writer instance. fn test_write() { - let mut buf = MemWriter::new(); + let mut buf = Vec::new(); write!(&mut buf as &mut io::Writer, "{}", 3i); { let w = &mut buf as &mut io::Writer; @@ -171,7 +169,7 @@ fn test_write() { writeln!(w, "{foo}", foo="bar"); } - let s = str::from_utf8(buf.unwrap().as_slice()).unwrap().to_string(); + let s = String::from_utf8(buf).unwrap(); t!(s, "34helloline\nbar\n"); } @@ -188,14 +186,14 @@ fn test_print() { // Just make sure that the macros are defined, there's not really a lot that we // can do with them just yet (to test the output) fn test_format_args() { - let mut buf = MemWriter::new(); + let mut buf = Vec::new(); { let w = &mut buf as &mut io::Writer; format_args!(|args| { write!(w, "{}", args); }, "{}", 1i); format_args!(|args| { write!(w, "{}", args); }, "test"); format_args!(|args| { write!(w, "{}", args); }, "{test}", test=3i); } - let s = str::from_utf8(buf.unwrap().as_slice()).unwrap().to_string(); + let s = String::from_utf8(buf).unwrap(); t!(s, "1test3"); let s = format_args!(fmt::format, "hello {}", "world");