diff options
Diffstat (limited to 'src/libcore')
| -rw-r--r-- | src/libcore/fmt/float.rs | 8 | ||||
| -rw-r--r-- | src/libcore/fmt/mod.rs | 8 | ||||
| -rw-r--r-- | src/libcore/fmt/num.rs | 4 | ||||
| -rw-r--r-- | src/libcore/slice.rs | 75 | ||||
| -rw-r--r-- | src/libcore/str.rs | 16 |
5 files changed, 51 insertions, 60 deletions
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 92ef0c281f2..343ab7cfd28 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -17,7 +17,7 @@ use iter::{range, DoubleEndedIterator}; use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive}; use num::{Zero, One, cast}; use result::Ok; -use slice::{ImmutableSlice, MutableSlice}; +use slice::MutableSlice; use slice; use str::StrSlice; @@ -173,7 +173,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>( _ => () } - buf.slice_to_mut(end).reverse(); + buf[mut ..end].reverse(); // Remember start of the fractional digits. // Points one beyond end of buf if none get generated, @@ -310,7 +310,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>( impl<'a> fmt::FormatWriter for Filler<'a> { fn write(&mut self, bytes: &[u8]) -> fmt::Result { - slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end), + slice::bytes::copy_memory(self.buf[mut *self.end..], bytes); *self.end += bytes.len(); Ok(()) @@ -328,5 +328,5 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>( } } - f(buf.slice_to(end)) + f(buf[..end]) } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 7bab59960b0..28ee522346f 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -423,7 +423,7 @@ impl<'a> Formatter<'a> { for c in sign.into_iter() { let mut b = [0, ..4]; let n = c.encode_utf8(b).unwrap_or(0); - try!(f.buf.write(b.slice_to(n))); + try!(f.buf.write(b[..n])); } if prefixed { f.buf.write(prefix.as_bytes()) } else { Ok(()) } @@ -530,13 +530,13 @@ impl<'a> Formatter<'a> { let len = self.fill.encode_utf8(fill).unwrap_or(0); for _ in range(0, pre_pad) { - try!(self.buf.write(fill.slice_to(len))); + try!(self.buf.write(fill[..len])); } try!(f(self)); for _ in range(0, post_pad) { - try!(self.buf.write(fill.slice_to(len))); + try!(self.buf.write(fill[..len])); } Ok(()) @@ -611,7 +611,7 @@ impl Char for char { let mut utf8 = [0u8, ..4]; let amt = self.encode_utf8(utf8).unwrap_or(0); - let s: &str = unsafe { mem::transmute(utf8.slice_to(amt)) }; + let s: &str = unsafe { mem::transmute(utf8[..amt]) }; secret_string(&s, f) } } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index afcd0d1d645..e57c4999483 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -18,7 +18,7 @@ use collections::Collection; use fmt; use iter::DoubleEndedIterator; use num::{Int, cast, zero}; -use slice::{ImmutableSlice, MutableSlice}; +use slice::{MutableSlice}; /// A type that represents a specific radix #[doc(hidden)] @@ -60,7 +60,7 @@ trait GenericRadix { if x == zero() { break; } // No more digits left to accumulate. } } - f.pad_integral(is_positive, self.prefix(), buf.slice_from(curr)) + f.pad_integral(is_positive, self.prefix(), buf[curr..]) } } diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index c7ffd8f5617..e1afd1a647a 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -67,7 +67,7 @@ pub trait ImmutableSlice<'a, T> { /// original slice (i.e. when `end > self.len()`) or when `start > end`. /// /// Slicing with `start` equal to `end` yields an empty slice. - #[unstable = "waiting on final error conventions"] + #[unstable = "waiting on final error conventions/slicing syntax"] fn slice(&self, start: uint, end: uint) -> &'a [T]; /// Returns a subslice from `start` to the end of the slice. @@ -75,7 +75,7 @@ pub trait ImmutableSlice<'a, T> { /// Fails when `start` is strictly greater than the length of the original slice. /// /// Slicing from `self.len()` yields an empty slice. - #[unstable = "waiting on final error conventions"] + #[unstable = "waiting on final error conventions/slicing syntax"] fn slice_from(&self, start: uint) -> &'a [T]; /// Returns a subslice from the start of the slice to `end`. @@ -83,7 +83,7 @@ pub trait ImmutableSlice<'a, T> { /// Fails when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[unstable = "waiting on final error conventions"] + #[unstable = "waiting on final error conventions/slicing syntax"] fn slice_to(&self, end: uint) -> &'a [T]; /// Divides one slice into two at an index. @@ -262,7 +262,7 @@ pub trait ImmutableSlice<'a, T> { * ```ignore * if self.len() == 0 { return None } * let head = &self[0]; - * *self = self.slice_from(1); + * *self = self[1..]; * Some(head) * ``` * @@ -281,7 +281,7 @@ pub trait ImmutableSlice<'a, T> { * ```ignore * if self.len() == 0 { return None; } * let tail = &self[self.len() - 1]; - * *self = self.slice_to(self.len() - 1); + * *self = self[..self.len() - 1]; * Some(tail) * ``` * @@ -299,9 +299,9 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] { assert!(end <= self.len()); unsafe { transmute(RawSlice { - data: self.as_ptr().offset(start as int), - len: (end - start) - }) + data: self.as_ptr().offset(start as int), + len: (end - start) + }) } } @@ -317,7 +317,7 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] { #[inline] fn split_at(&self, mid: uint) -> (&'a [T], &'a [T]) { - (self.slice(0, mid), self.slice(mid, self.len())) + ((*self)[..mid], (*self)[mid..]) } #[inline] @@ -386,21 +386,21 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] { } #[inline] - fn tail(&self) -> &'a [T] { self.slice(1, self.len()) } + fn tail(&self) -> &'a [T] { (*self)[1..] } #[inline] #[deprecated = "use slice_from"] - fn tailn(&self, n: uint) -> &'a [T] { self.slice(n, self.len()) } + fn tailn(&self, n: uint) -> &'a [T] { (*self)[n..] } #[inline] fn init(&self) -> &'a [T] { - self.slice(0, self.len() - 1) + (*self)[..self.len() - 1] } #[inline] #[deprecated = "use slice_to but note the arguments are different"] fn initn(&self, n: uint) -> &'a [T] { - self.slice(0, self.len() - n) + (*self)[..self.len() - n] } #[inline] @@ -556,7 +556,7 @@ pub trait MutableSlice<'a, T> { fn as_mut_slice(self) -> &'a mut [T]; /// Deprecated: use `slice_mut`. - #[deprecated = "use slice_mut"] + #[deprecated = "slice_mut"] fn mut_slice(self, start: uint, end: uint) -> &'a mut [T] { self.slice_mut(start, end) } @@ -681,7 +681,7 @@ pub trait MutableSlice<'a, T> { * ```ignore * if self.len() == 0 { return None; } * let head = &mut self[0]; - * *self = self.slice_from_mut(1); + * *self = self[mut 1..]; * Some(head) * ``` * @@ -700,7 +700,7 @@ pub trait MutableSlice<'a, T> { * ```ignore * if self.len() == 0 { return None; } * let tail = &mut self[self.len() - 1]; - * *self = self.slice_to_mut(self.len() - 1); + * *self = self[mut ..self.len() - 1]; * Some(tail) * ``` * @@ -826,33 +826,24 @@ impl<'a,T> MutableSlice<'a, T> for &'a mut [T] { fn as_mut_slice(self) -> &'a mut [T] { self } fn slice_mut(self, start: uint, end: uint) -> &'a mut [T] { - assert!(start <= end); - assert!(end <= self.len()); - unsafe { - transmute(RawSlice { - data: self.as_mut_ptr().offset(start as int) as *const T, - len: (end - start) - }) - } + self[mut start..end] } #[inline] fn slice_from_mut(self, start: uint) -> &'a mut [T] { - let len = self.len(); - self.slice_mut(start, len) + self[mut start..] } #[inline] fn slice_to_mut(self, end: uint) -> &'a mut [T] { - self.slice_mut(0, end) + self[mut ..end] } #[inline] fn split_at_mut(self, mid: uint) -> (&'a mut [T], &'a mut [T]) { unsafe { - let len = self.len(); let self2: &'a mut [T] = mem::transmute_copy(&self); - (self.slice_mut(0, mid), self2.slice_mut(mid, len)) + (self[mut ..mid], self2[mut mid..]) } } @@ -889,13 +880,13 @@ impl<'a,T> MutableSlice<'a, T> for &'a mut [T] { #[inline] fn tail_mut(self) -> &'a mut [T] { let len = self.len(); - self.slice_mut(1, len) + self[mut 1..len] } #[inline] fn init_mut(self) -> &'a mut [T] { let len = self.len(); - self.slice_mut(0, len - 1) + self[mut 0..len - 1] } #[inline] @@ -1042,13 +1033,13 @@ impl<'a,T:PartialEq> ImmutablePartialEqSlice<T> for &'a [T] { #[inline] fn starts_with(&self, needle: &[T]) -> bool { let n = needle.len(); - self.len() >= n && needle == self.slice_to(n) + self.len() >= n && needle == (*self)[..n] } #[inline] fn ends_with(&self, needle: &[T]) -> bool { let (m, n) = (self.len(), needle.len()); - m >= n && needle == self.slice_from(m - n) + m >= n && needle == (*self)[m-n..] } } @@ -1339,8 +1330,8 @@ impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> { match self.v.iter().position(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v.slice(0, idx)); - self.v = self.v.slice(idx + 1, self.v.len()); + let ret = Some(self.v[..idx]); + self.v = self.v[idx + 1..]; ret } } @@ -1365,8 +1356,8 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> { match self.v.iter().rposition(|x| (self.pred)(x)) { None => self.finish(), Some(idx) => { - let ret = Some(self.v.slice(idx + 1, self.v.len())); - self.v = self.v.slice(0, idx); + let ret = Some(self.v[idx + 1..]); + self.v = self.v[..idx]; ret } } @@ -1416,7 +1407,7 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { Some(idx) => { let tmp = mem::replace(&mut self.v, &mut []); let (head, tail) = tmp.split_at_mut(idx); - self.v = tail.slice_from_mut(1); + self.v = tail[mut 1..]; Some(head) } } @@ -1450,7 +1441,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> { let tmp = mem::replace(&mut self.v, &mut []); let (head, tail) = tmp.split_at_mut(idx); self.v = head; - Some(tail.slice_from_mut(1)) + Some(tail[mut 1..]) } } } @@ -1498,8 +1489,8 @@ impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> { if self.size > self.v.len() { None } else { - let ret = Some(self.v.slice(0, self.size)); - self.v = self.v.slice(1, self.v.len()); + let ret = Some(self.v[..self.size]); + self.v = self.v[1..]; ret } } @@ -1583,7 +1574,7 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> { let mut hi = lo + self.size; if hi < lo || hi > self.v.len() { hi = self.v.len(); } - Some(self.v.slice(lo, hi)) + Some(self.v[lo..hi]) } else { None } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index fd7c63a6b32..f3a10a0a3ae 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -30,7 +30,7 @@ use iter::range; use num::{CheckedMul, Saturating}; use option::{Option, None, Some}; use raw::Repr; -use slice::{ImmutableSlice, MutableSlice}; +use slice::ImmutableSlice; use slice; use uint; @@ -393,7 +393,7 @@ impl NaiveSearcher { fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> { while self.position + needle.len() <= haystack.len() { - if haystack.slice(self.position, self.position + needle.len()) == needle { + if haystack[self.position .. self.position + needle.len()] == needle { let match_pos = self.position; self.position += needle.len(); // add 1 for all matches return Some((match_pos, match_pos + needle.len())); @@ -514,10 +514,10 @@ impl TwoWaySearcher { // // What's going on is we have some critical factorization (u, v) of the // needle, and we want to determine whether u is a suffix of - // v.slice_to(period). If it is, we use "Algorithm CP1". Otherwise we use + // v[..period]. If it is, we use "Algorithm CP1". Otherwise we use // "Algorithm CP2", which is optimized for when the period of the needle // is large. - if needle.slice_to(crit_pos) == needle.slice(period, period + crit_pos) { + if needle[..crit_pos] == needle[period.. period + crit_pos] { TwoWaySearcher { crit_pos: crit_pos, period: period, @@ -741,7 +741,7 @@ impl<'a> Iterator<u16> for Utf16CodeUnits<'a> { let mut buf = [0u16, ..2]; self.chars.next().map(|ch| { - let n = ch.encode_utf16(buf.as_mut_slice()).unwrap_or(0); + let n = ch.encode_utf16(buf[mut]).unwrap_or(0); if n == 2 { self.extra = buf[1]; } buf[0] }) @@ -1007,7 +1007,7 @@ pub fn utf16_items<'a>(v: &'a [u16]) -> Utf16Items<'a> { pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { match v.iter().position(|c| *c == 0) { // don't include the 0 - Some(i) => v.slice_to(i), + Some(i) => v[..i], None => v } } @@ -1994,13 +1994,13 @@ impl<'a> StrSlice<'a> for &'a str { #[inline] fn starts_with<'a>(&self, needle: &'a str) -> bool { let n = needle.len(); - self.len() >= n && needle.as_bytes() == self.as_bytes().slice_to(n) + self.len() >= n && needle.as_bytes() == self.as_bytes()[..n] } #[inline] fn ends_with(&self, needle: &str) -> bool { let (m, n) = (self.len(), needle.len()); - m >= n && needle.as_bytes() == self.as_bytes().slice_from(m - n) + m >= n && needle.as_bytes() == self.as_bytes()[m-n..] } #[inline] |