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

Replace full slice notation with index calls

Browse source
This commit is contained in:
Nick Cameron 2015-01-02 13:56:28 +13:00
parent 918255ef8c
commit f7ff37e4c5
225 changed files with 2166 additions and 2139 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -15,7 +15,7 @@
use cmp;
use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
use iter::{IteratorExt, ExactSizeIterator};
use ops::Drop;
use ops::{Drop, Index};
use option::Option;
use option::Option::{Some, None};
use result::Result::Ok;
@ -100,7 +100,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
self.pos = 0;
}
Ok(self.buf[self.pos..self.cap])
Ok(self.buf.index(&(self.pos..self.cap)))
}
fn consume(&mut self, amt: uint) {
@ -117,7 +117,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
let nread = {
let available = try!(self.fill_buf());
let nread = cmp::min(available.len(), buf.len());
slice::bytes::copy_memory(buf, available[..nread]);
slice::bytes::copy_memory(buf, available.index(&(0..nread)));
nread
};
self.pos += nread;
@ -171,7 +171,7 @@ impl<W: Writer> BufferedWriter<W> {
fn flush_buf(&mut self) -> IoResult<()> {
if self.pos != 0 {
let ret = self.inner.as_mut().unwrap().write(self.buf[..self.pos]);
let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos)));
self.pos = 0;
ret
} else {
@ -263,9 +263,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match buf.iter().rposition(|&b| b == b'\n') {
Some(i) => {
try!(self.inner.write(buf[..i + 1]));
try!(self.inner.write(buf.index(&(0..(i + 1)))));
try!(self.inner.flush());
try!(self.inner.write(buf[i + 1..]));
try!(self.inner.write(buf.index(&((i + 1)..))));
Ok(())
}
None => self.inner.write(buf),
@ -517,7 +517,7 @@ mod test {
assert_eq!(a, w.get_ref()[]);
let w = w.into_inner();
let a: &[_] = &[0, 1];
assert_eq!(a, w[]);
assert_eq!(a, w.index(&FullRange));
}
// This is just here to make sure that we don't infinite loop in the
@ -614,14 +614,14 @@ mod test {
#[test]
fn read_char_buffered() {
let buf = [195u8, 159u8];
let mut reader = BufferedReader::with_capacity(1, buf[]);
let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
assert_eq!(reader.read_char(), Ok('ß'));
}
#[test]
fn test_chars() {
let buf = [195u8, 159u8, b'a'];
let mut reader = BufferedReader::with_capacity(1, buf[]);
let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
let mut it = reader.chars();
assert_eq!(it.next(), Some(Ok('ß')));
assert_eq!(it.next(), Some(Ok('a')));

3
src/libstd/io/comm_adapters.rs
View file

@ -13,6 +13,7 @@ use cmp;
use sync::mpsc::{Sender, Receiver};
use io;
use option::Option::{None, Some};
use ops::Index;
use result::Result::{Ok, Err};
use slice::{bytes, SliceExt};
use super::{Buffer, Reader, Writer, IoResult};
@ -90,7 +91,7 @@ impl Reader for ChanReader {
Some(src) => {
let dst = buf.slice_from_mut(num_read);
let count = cmp::min(src.len(), dst.len());
bytes::copy_memory(dst, src[..count]);
bytes::copy_memory(dst, src.index(&(0..count)));
count
},
None => 0,

2
src/libstd/io/fs.rs
View file

@ -889,7 +889,7 @@ mod test {
let mut read_buf = [0; 1028];
let read_str = match check!(read_stream.read(&mut read_buf)) {
-1|0 => panic!("shouldn't happen"),
n => str::from_utf8(read_buf[..n]).unwrap().to_string()
n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string()
};
assert_eq!(read_str.as_slice(), message);
}

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

@ -13,6 +13,7 @@
//! Readers and Writers for in-memory buffers
use cmp::min;
use prelude::Index;
use option::Option::None;
use result::Result::{Err, Ok};
use io;
@ -159,7 +160,7 @@ impl Reader for MemReader {
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = self.buf[self.pos.. self.pos + write_len];
let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
let output = buf.slice_to_mut(write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
@ -187,7 +188,7 @@ impl Buffer for MemReader {
#[inline]
fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
if self.pos < self.buf.len() {
Ok(self.buf[self.pos..])
Ok(self.buf.index(&(self.pos..)))
} else {
Err(io::standard_error(io::EndOfFile))
}
@ -204,7 +205,7 @@ impl<'a> Reader for &'a [u8] {
let write_len = min(buf.len(), self.len());
{
let input = self[..write_len];
let input = self.index(&(0..write_len));
let output = buf.slice_to_mut(write_len);
slice::bytes::copy_memory(output, input);
}
@ -227,7 +228,7 @@ impl<'a> Buffer for &'a [u8] {
#[inline]
fn consume(&mut self, amt: uint) {
*self = self[amt..];
*self = self.index(&(amt..));
}
}
@ -286,7 +287,7 @@ impl<'a> Writer for BufWriter<'a> {
Ok(())
} else {
slice::bytes::copy_memory(dst, src[..dst_len]);
slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
self.pos += dst_len;
@ -349,7 +350,7 @@ impl<'a> Reader for BufReader<'a> {
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = self.buf[self.pos.. self.pos + write_len];
let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
let output = buf.slice_to_mut(write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
@ -377,7 +378,7 @@ impl<'a> Buffer for BufReader<'a> {
#[inline]
fn fill_buf(&mut self) -> IoResult<&[u8]> {
if self.pos < self.buf.len() {
Ok(self.buf[self.pos..])
Ok(self.buf.index(&(self.pos..)))
} else {
Err(io::standard_error(io::EndOfFile))
}
@ -498,7 +499,7 @@ mod test {
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
assert_eq!(buf[0..3], b);
assert_eq!(buf.index(&(0..3)), b);
assert!(reader.read(&mut buf).is_err());
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));
@ -524,7 +525,7 @@ mod test {
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_eq!(buf.index(&(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));
@ -551,7 +552,7 @@ mod test {
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
assert_eq!(buf[0..3], b);
assert_eq!(buf.index(&(0..3)), b);
assert!(reader.read(&mut buf).is_err());
let mut reader = BufReader::new(in_buf.as_slice());
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));

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

@ -234,7 +234,7 @@ use int;
use iter::{Iterator, IteratorExt};
use kinds::Sized;
use mem::transmute;
use ops::FnOnce;
use ops::{FnOnce, Index};
use option::Option;
use option::Option::{Some, None};
use os;
@ -1068,7 +1068,7 @@ pub trait Writer {
fn write_char(&mut self, c: char) -> IoResult<()> {
let mut buf = [0u8; 4];
let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
self.write(buf[..n])
self.write(buf.index(&(0..n)))
}
/// Write the result of passing n through `int::to_str_bytes`.
@ -1453,7 +1453,7 @@ pub trait Buffer: Reader {
};
match available.iter().position(|&b| b == byte) {
Some(i) => {
res.push_all(available[..i + 1]);
res.push_all(available.index(&(0..(i + 1))));
used = i + 1;
break
}
@ -1492,7 +1492,7 @@ pub trait Buffer: Reader {
}
}
}
match str::from_utf8(buf[..width]).ok() {
match str::from_utf8(buf.index(&(0..width))).ok() {
Some(s) => Ok(s.char_at(0)),
None => Err(standard_error(InvalidInput))
}

4
src/libstd/io/net/ip.rs
View file

@ -22,7 +22,7 @@ use fmt;
use io::{self, IoResult, IoError};
use io::net;
use iter::{Iterator, IteratorExt};
use ops::{FnOnce, FnMut};
use ops::{FnOnce, FnMut, Index};
use option::Option;
use option::Option::{None, Some};
use result::Result::{Ok, Err};
@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
let mut tail = [0u16; 8];
let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
Some(ipv6_addr_from_head_tail(head[..head_size], tail[..tail_size]))
Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size))))
}
fn read_ipv6_addr(&mut self) -> Option<IpAddr> {

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

@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> {
impl<R: Buffer> Buffer for LimitReader<R> {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
let amt = try!(self.inner.fill_buf());
let buf = amt[..cmp::min(amt.len(), self.limit)];
let buf = amt.index(&(0..cmp::min(amt.len(), self.limit)));
if buf.len() == 0 {
Err(io::standard_error(io::EndOfFile))
} else {
@ -220,7 +220,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
self.reader.read(buf).and_then(|len| {
self.writer.write(buf[mut ..len]).map(|()| len)
self.writer.write(buf.index_mut(&(0..len))).map(|()| len)
})
}
}
@ -234,7 +234,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
Err(e) => return Err(e),
};
try!(w.write(buf[..len]));
try!(w.write(buf.index(&(0..len))));
}
}