diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 202ac46449754..7626b4eed7634 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -444,15 +444,14 @@ impl Result { /// ignoring I/O and parse errors: /// /// ``` - /// use std::io::{BufReader, IoResult}; + /// use std::io::IoResult; /// - /// let buffer = "1\n2\n3\n4\n"; - /// let mut reader = BufReader::new(buffer.as_bytes()); + /// let mut buffer = &mut b"1\n2\n3\n4\n"; /// /// let mut sum = 0; /// - /// while !reader.eof() { - /// let line: IoResult = reader.read_line(); + /// while !buffer.is_empty() { + /// let line: IoResult = buffer.read_line(); /// // Convert the string line to a number using `map` and `from_str` /// let val: IoResult = line.map(|line| { /// from_str::(line.as_slice().trim_right()).unwrap_or(0) diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index af1dbc2b7fca4..0a5081d07be00 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -547,7 +547,7 @@ mod tests { use self::NodeLabels::*; use super::{Id, LabelText, LabelStr, EscStr, Labeller}; use super::{Nodes, Edges, GraphWalk, render}; - use std::io::{BufReader, IoResult}; + use std::io::IoResult; use std::str; /// each node is an index in a vector in the graph. @@ -698,8 +698,7 @@ mod tests { fn test_input(g: LabelledGraph) -> IoResult { let mut writer = Vec::new(); render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer[]); - r.read_to_string() + (&mut writer.as_slice()).read_to_string() } // All of the tests use raw-strings as the format for the expected outputs, @@ -811,8 +810,7 @@ r#"digraph hasse_diagram { edge(1, 3, ";"), edge(2, 3, ";" ))); render(&g, &mut writer).unwrap(); - let mut r = BufReader::new(writer[]); - let r = r.read_to_string(); + let r = (&mut writer.as_slice()).read_to_string(); assert_eq!(r.unwrap().as_slice(), r#"digraph syntax_tree { diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index e92bad592d126..fba9e4f2e25e1 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -406,7 +406,7 @@ mod test { use prelude::*; use super::*; use super::super::{IoResult, EndOfFile}; - use super::super::mem::{MemReader, BufReader}; + use super::super::mem::MemReader; use self::test::Bencher; use str::StrPrelude; @@ -626,14 +626,14 @@ mod test { #[test] fn read_char_buffered() { let buf = [195u8, 159u8]; - let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf)); + let mut reader = BufferedReader::with_capacity(1, buf[]); assert_eq!(reader.read_char(), Ok('ß')); } #[test] fn test_chars() { let buf = [195u8, 159u8, b'a']; - let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf)); + let mut reader = BufferedReader::with_capacity(1, buf[]); let mut it = reader.chars(); assert_eq!(it.next(), Some(Ok('ß'))); assert_eq!(it.next(), Some(Ok('a'))); diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index f27951f263da2..6a9b10d2a7bd0 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -206,6 +206,41 @@ impl Buffer for MemReader { fn consume(&mut self, amt: uint) { self.pos += amt; } } +impl<'a> Reader for &'a [u8] { + #[inline] + fn read(&mut self, buf: &mut [u8]) -> IoResult { + if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); } + + let write_len = min(buf.len(), self.len()); + { + let input = self[..write_len]; + let output = buf[mut ..write_len]; + slice::bytes::copy_memory(output, input); + } + + *self = self.slice_from(write_len); + + Ok(write_len) + } +} + +impl<'a> Buffer for &'a [u8] { + #[inline] + fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { + if self.is_empty() { + Err(io::standard_error(io::EndOfFile)) + } else { + Ok(*self) + } + } + + #[inline] + fn consume(&mut self, amt: uint) { + *self = self[amt..]; + } +} + + /// Writes to a fixed-size byte slice /// /// If a write will not fit in the buffer, it returns an error and does not @@ -362,6 +397,16 @@ mod test { use self::test::Bencher; use str::StrPrelude; + #[test] + fn test_vec_writer() { + let mut writer = Vec::new(); + writer.write(&[0]).unwrap(); + writer.write(&[1, 2, 3]).unwrap(); + writer.write(&[4, 5, 6, 7]).unwrap(); + let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; + assert_eq!(writer.as_slice(), b); + } + #[test] fn test_mem_writer() { let mut writer = MemWriter::new(); @@ -385,6 +430,8 @@ mod test { assert_eq!(writer.tell(), Ok(8)); writer.write(&[]).unwrap(); assert_eq!(writer.tell(), Ok(8)); + + assert!(writer.write(&[1]).is_err()); } let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; assert_eq!(buf.as_slice(), b); @@ -457,6 +504,32 @@ mod test { assert!(reader.read(&mut buf).is_err()); } + #[test] + fn test_slice_reader() { + let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; + let mut reader = &mut in_buf.as_slice(); + let mut buf = []; + assert_eq!(reader.read(&mut buf), Ok(0)); + let mut buf = [0]; + assert_eq!(reader.read(&mut buf), Ok(1)); + assert_eq!(reader.len(), 7); + let b: &[_] = &[0]; + assert_eq!(buf.as_slice(), b); + let mut buf = [0, ..4]; + assert_eq!(reader.read(&mut buf), Ok(4)); + assert_eq!(reader.len(), 3); + let b: &[_] = &[1, 2, 3, 4]; + assert_eq!(buf.as_slice(), b); + assert_eq!(reader.read(&mut buf), Ok(3)); + let b: &[_] = &[5, 6, 7]; + assert_eq!(buf[0..3], b); + assert!(reader.read(&mut buf).is_err()); + let mut reader = &mut in_buf.as_slice(); + assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); + assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert!(reader.read(&mut buf).is_err()); + } + #[test] fn test_buf_reader() { let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index 393283ff64c5b..e78bd1dd33f32 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -273,7 +273,7 @@ impl> Reader for IterReader { #[cfg(test)] mod test { - use io::{MemReader, BufReader, ByRefReader}; + use io::{MemReader, ByRefReader}; use io; use boxed::Box; use super::*; @@ -395,8 +395,7 @@ mod test { #[test] fn limit_reader_buffer() { - let data = "0123456789\n0123456789\n"; - let mut r = BufReader::new(data.as_bytes()); + let r = &mut b"0123456789\n0123456789\n"; { let mut r = LimitReader::new(r.by_ref(), 3); assert_eq!(r.read_line(), Ok("012".to_string())); diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs index 1d5268b975481..a77a6276a8b4e 100644 --- a/src/libtime/lib.rs +++ b/src/libtime/lib.rs @@ -32,7 +32,6 @@ use self::Fmt::*; use std::fmt::Show; use std::fmt; -use std::io::BufReader; use std::num::SignedInt; use std::string::String; use std::time::Duration; @@ -1187,7 +1186,7 @@ pub fn strptime(s: &str, format: &str) -> Result { } } - let mut rdr = BufReader::new(format.as_bytes()); + let mut rdr: &[u8] = format.as_bytes(); let mut tm = Tm { tm_sec: 0_i32, tm_min: 0_i32, @@ -1211,13 +1210,13 @@ pub fn strptime(s: &str, format: &str) -> Result { let next = range.next; let mut buf = [0]; - let c = match rdr.read(&mut buf) { + let c = match (&mut rdr).read(&mut buf) { Ok(..) => buf[0] as char, Err(..) => break }; match c { '%' => { - let ch = match rdr.read(&mut buf) { + let ch = match (&mut rdr).read(&mut buf) { Ok(..) => buf[0] as char, Err(..) => break }; @@ -1233,7 +1232,7 @@ pub fn strptime(s: &str, format: &str) -> Result { } } - if pos == len && rdr.tell().unwrap() == format.len() as u64 { + if pos == len && (&mut rdr).is_empty() { Ok(Tm { tm_sec: tm.tm_sec, tm_min: tm.tm_min,