user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

De-~[] Mem{Reader,Writer}

Browse source
This commit is contained in:
Steven Fackler 2014-03-26 22:46:25 -07:00
parent d0e60b72ee
commit 49a8081095
21 changed files with 66 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libstd/io/buffered.rs
View file

@ -405,7 +405,7 @@ mod test {
#[test]
fn test_buffered_reader() {
let inner = MemReader::new(~[0, 1, 2, 3, 4]);
let inner = MemReader::new(vec!(0, 1, 2, 3, 4));
let mut reader = BufferedReader::with_capacity(2, inner);
let mut buf = [0, 0, 0];
@ -502,7 +502,7 @@ mod test {
#[test]
fn test_read_until() {
let inner = MemReader::new(~[0, 1, 2, 1, 0]);
let inner = MemReader::new(vec!(0, 1, 2, 1, 0));
let mut reader = BufferedReader::with_capacity(2, inner);
assert_eq!(reader.read_until(0), Ok(vec!(0)));
assert_eq!(reader.read_until(2), Ok(vec!(1, 2)));
@ -533,7 +533,7 @@ mod test {
#[test]
fn test_read_line() {
let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
let mut reader = BufferedReader::with_capacity(2, in_buf);
assert_eq!(reader.read_line(), Ok(~"a\n"));
assert_eq!(reader.read_line(), Ok(~"b\n"));
@ -543,7 +543,7 @@ mod test {
#[test]
fn test_lines() {
let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
let mut reader = BufferedReader::with_capacity(2, in_buf);
let mut it = reader.lines();
assert_eq!(it.next(), Some(Ok(~"a\n")));

10
src/libstd/io/extensions.rs
View file

@ -267,7 +267,7 @@ mod test {
#[test]
fn read_byte() {
let mut reader = MemReader::new(~[10]);
let mut reader = MemReader::new(vec!(10));
let byte = reader.read_byte();
assert!(byte == Ok(10));
}
@ -321,7 +321,7 @@ mod test {
#[test]
fn read_bytes() {
let mut reader = MemReader::new(~[10, 11, 12, 13]);
let mut reader = MemReader::new(vec!(10, 11, 12, 13));
let bytes = reader.read_exact(4).unwrap();
assert!(bytes == vec!(10, 11, 12, 13));
}
@ -337,13 +337,13 @@ mod test {
#[test]
fn read_bytes_eof() {
let mut reader = MemReader::new(~[10, 11]);
let mut reader = MemReader::new(vec!(10, 11));
assert!(reader.read_exact(4).is_err());
}
#[test]
fn push_exact() {
let mut reader = MemReader::new(~[10, 11, 12, 13]);
let mut reader = MemReader::new(vec!(10, 11, 12, 13));
let mut buf = vec!(8, 9);
reader.push_exact(&mut buf, 4).unwrap();
assert!(buf == vec!(8, 9, 10, 11, 12, 13));
@ -361,7 +361,7 @@ mod test {
#[test]
fn push_exact_eof() {
let mut reader = MemReader::new(~[10, 11]);
let mut reader = MemReader::new(vec!(10, 11));
let mut buf = vec!(8, 9);
assert!(reader.push_exact(&mut buf, 4).is_err());
assert!(buf == vec!(8, 9, 10, 11));

27
src/libstd/io/mem.rs
View file

@ -18,6 +18,7 @@ use io;
use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
use slice;
use slice::{Vector, ImmutableVector, MutableVector, OwnedCloneableVector};
use vec::Vec;
fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
// compute offset as signed and clamp to prevent overflow
@ -49,10 +50,10 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
/// let mut w = MemWriter::new();
/// w.write([0, 1, 2]);
///
/// assert_eq!(w.unwrap(), ~[0, 1, 2]);
/// assert_eq!(w.unwrap(), vec!(0, 1, 2));
/// ```
pub struct MemWriter {
buf: ~[u8],
buf: Vec<u8>,
pos: uint,
}
@ -64,7 +65,7 @@ impl MemWriter {
/// Create a new `MemWriter`, allocating at least `n` bytes for
/// the internal buffer.
pub fn with_capacity(n: uint) -> MemWriter {
MemWriter { buf: slice::with_capacity(n), pos: 0 }
MemWriter { buf: Vec::with_capacity(n), pos: 0 }
}
/// Acquires an immutable reference to the underlying buffer of this
@ -75,7 +76,7 @@ impl MemWriter {
pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
/// Unwraps this `MemWriter`, returning the underlying buffer
pub fn unwrap(self) -> ~[u8] { self.buf }
pub fn unwrap(self) -> Vec<u8> { self.buf }
}
impl Writer for MemWriter {
@ -127,19 +128,19 @@ impl Seek for MemWriter {
/// # #[allow(unused_must_use)];
/// use std::io::MemReader;
///
/// let mut r = MemReader::new(~[0, 1, 2]);
/// let mut r = MemReader::new(vec!(0, 1, 2));
///
/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
/// ```
pub struct MemReader {
buf: ~[u8],
buf: Vec<u8>,
pos: uint
}
impl MemReader {
/// Creates a new `MemReader` which will read the buffer given. The buffer
/// can be re-acquired through `unwrap`
pub fn new(buf: ~[u8]) -> MemReader {
pub fn new(buf: Vec<u8>) -> MemReader {
MemReader {
buf: buf,
pos: 0
@ -159,7 +160,7 @@ impl MemReader {
pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
/// Unwraps this `MemReader`, returning the underlying buffer
pub fn unwrap(self) -> ~[u8] { self.buf }
pub fn unwrap(self) -> Vec<u8> { self.buf }
}
impl Reader for MemReader {
@ -425,7 +426,7 @@ mod test {
#[test]
fn test_mem_reader() {
let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
let mut buf = [];
assert_eq!(reader.read(buf), Ok(0));
assert_eq!(reader.tell(), Ok(0));
@ -440,7 +441,7 @@ mod test {
assert_eq!(reader.read(buf), Ok(3));
assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
assert!(reader.read(buf).is_err());
let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
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(buf).is_err());
@ -525,7 +526,7 @@ mod test {
r.seek(10, SeekSet).unwrap();
assert!(r.read(&mut []).is_err());
let mut r = MemReader::new(~[10]);
let mut r = MemReader::new(vec!(10));
r.seek(10, SeekSet).unwrap();
assert!(r.read(&mut []).is_err());
@ -545,7 +546,7 @@ mod test {
let mut r = BufReader::new(buf);
assert!(r.seek(-1, SeekSet).is_err());
let mut r = MemReader::new(~[10]);
let mut r = MemReader::new(vec!(10));
assert!(r.seek(-1, SeekSet).is_err());
let mut r = MemWriter::new();
@ -558,7 +559,7 @@ mod test {
#[test]
fn io_fill() {
let mut r = MemReader::new(~[1, 2, 3, 4, 5, 6, 7, 8]);
let mut r = MemReader::new(vec!(1, 2, 3, 4, 5, 6, 7, 8));
let mut buf = [0, ..3];
assert_eq!(r.fill(buf), Ok(()));
assert_eq!(buf.as_slice(), &[1, 2, 3]);

4
src/libstd/io/result.rs
View file

@ -87,7 +87,7 @@ mod test {
let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
writer.write([0, 1, 2]).unwrap();
writer.flush().unwrap();
assert_eq!(writer.unwrap().unwrap(), ~[0, 1, 2]);
assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2));
}
#[test]
@ -108,7 +108,7 @@ mod test {
#[test]
fn test_option_reader() {
let mut reader: io::IoResult<MemReader> =
Ok(MemReader::new(~[0, 1, 2, 3]));
Ok(MemReader::new(vec!(0, 1, 2, 3)));
let mut buf = [0, 0];
reader.read(buf).unwrap();
assert_eq!(buf.as_slice(), &[0, 1]);

18
src/libstd/io/util.rs
View file

@ -204,7 +204,7 @@ mod test {
#[test]
fn test_limit_reader_unlimited() {
let mut r = MemReader::new(~[0, 1, 2]);
let mut r = MemReader::new(vec!(0, 1, 2));
{
let mut r = LimitReader::new(r.by_ref(), 4);
assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
@ -213,7 +213,7 @@ mod test {
#[test]
fn test_limit_reader_limited() {
let mut r = MemReader::new(~[0, 1, 2]);
let mut r = MemReader::new(vec!(0, 1, 2));
{
let mut r = LimitReader::new(r.by_ref(), 2);
assert_eq!(vec!(0, 1), r.read_to_end().unwrap());
@ -223,7 +223,7 @@ mod test {
#[test]
fn test_limit_reader_limit() {
let r = MemReader::new(~[0, 1, 2]);
let r = MemReader::new(vec!(0, 1, 2));
let mut r = LimitReader::new(r, 3);
assert_eq!(3, r.limit());
assert_eq!(0, r.read_byte().unwrap());
@ -285,26 +285,26 @@ mod test {
#[test]
fn test_chained_reader() {
let rs = ~[MemReader::new(~[0, 1]), MemReader::new(~[]),
MemReader::new(~[2, 3])];
let rs = ~[MemReader::new(vec!(0, 1)), MemReader::new(vec!()),
MemReader::new(vec!(2, 3))];
let mut r = ChainedReader::new(rs.move_iter());
assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap());
}
#[test]
fn test_tee_reader() {
let mut r = TeeReader::new(MemReader::new(~[0, 1, 2]),
let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
MemWriter::new());
assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
let (_, w) = r.unwrap();
assert_eq!(~[0, 1, 2], w.unwrap());
assert_eq!(vec!(0, 1, 2), w.unwrap());
}
#[test]
fn test_copy() {
let mut r = MemReader::new(~[0, 1, 2, 3, 4]);
let mut r = MemReader::new(vec!(0, 1, 2, 3, 4));
let mut w = MemWriter::new();
copy(&mut r, &mut w).unwrap();
assert_eq!(~[0, 1, 2, 3, 4], w.unwrap());
assert_eq!(vec!(0, 1, 2, 3, 4), w.unwrap());
}
}