mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Review and rebasing changes

Browse source
This commit is contained in:
Nick Cameron 2014-09-30 15:34:27 +13:00
parent 95cfc35607
commit 6e0611a487
8 changed files with 103 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/libcollections/slice.rs
View file

@ -44,7 +44,8 @@
//!
//! A number of traits add methods that allow you to accomplish tasks with slices.
//! These traits include `ImmutableSlice`, which is defined for `&[T]` types,
//! and `MutableSlice`, defined for `&mut [T]` types.
//! `MutableSlice`, defined for `&mut [T]` types, and `Slice` and `SliceMut`
//! which are defined for `[T]`.
//!
//! An example is the `slice` method which enables slicing syntax `[a..b]` that
//! returns an immutable "view" into a `Vec` or another slice from the index

29
src/libcollections/string.rs
View file

@ -927,6 +927,7 @@ impl<S: Str> Add<S, String> for String {
}
}
#[cfg(stage0)]
impl ops::Slice<uint, str> for String {
#[inline]
fn as_slice_<'a>(&'a self) -> &'a str {
@ -949,6 +950,34 @@ impl ops::Slice<uint, str> for String {
}
}
#[cfg(not(stage0))]
#[inline]
fn str_to_slice<'a, U: Str>(this: &'a U) -> &'a str {
this.as_slice()
}
#[cfg(not(stage0))]
impl ops::Slice<uint, str> for String {
#[inline]
fn as_slice<'a>(&'a self) -> &'a str {
str_to_slice(self)
}
#[inline]
fn slice_from<'a>(&'a self, from: &uint) -> &'a str {
self[][*from..]
}
#[inline]
fn slice_to<'a>(&'a self, to: &uint) -> &'a str {
self[][..*to]
}
#[inline]
fn slice<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
self[][*from..*to]
}
}
/// Unsafe operations
#[unstable = "waiting on raw module conventions"]
pub mod raw {

15
src/libcollections/vec.rs
View file

@ -462,6 +462,7 @@ impl<T> Index<uint,T> for Vec<T> {
// Annoying helper function because there are two Slice::as_slice functions in
// scope.
#[cfg(not(stage0))]
#[inline]
fn slice_to_slice<'a, T, U: Slice<T>>(this: &'a U) -> &'a [T] {
this.as_slice()
@ -983,7 +984,6 @@ impl<T> Vec<T> {
/// assert!(vec[0..2] == [1, 2]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] {
self[start..end]
}
@ -1019,7 +1019,7 @@ impl<T> Vec<T> {
/// assert!(vec.tailn(2) == [3, 4]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_from"]
pub fn tailn<'a>(&'a self, n: uint) -> &'a [T] {
self[n..]
}
@ -1229,7 +1229,7 @@ impl<T> Vec<T> {
}
/// Deprecated: use `slice_mut`.
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_from"]
pub fn mut_slice<'a>(&'a mut self, start: uint, end: uint)
-> &'a mut [T] {
self[mut start..end]
@ -1249,14 +1249,13 @@ impl<T> Vec<T> {
/// assert!(vec[mut 0..2] == [1, 2]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice_mut<'a>(&'a mut self, start: uint, end: uint)
-> &'a mut [T] {
self[mut start..end]
}
/// Deprecated: use "slice_from_mut".
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_from_mut"]
pub fn mut_slice_from<'a>(&'a mut self, start: uint) -> &'a mut [T] {
self[mut start..]
}
@ -1274,13 +1273,12 @@ impl<T> Vec<T> {
/// assert!(vec[mut 2..] == [3, 4]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
self[mut start..]
}
/// Deprecated: use `slice_to_mut`.
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_to_mut"]
pub fn mut_slice_to<'a>(&'a mut self, end: uint) -> &'a mut [T] {
self[mut ..end]
}
@ -1298,7 +1296,6 @@ impl<T> Vec<T> {
/// assert!(vec[mut ..2] == [1, 2]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
self[mut ..end]
}
@ -1375,7 +1372,6 @@ impl<T> Vec<T> {
/// assert!(vec[1..] == [2, 3]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
self[start..]
}
@ -1393,7 +1389,6 @@ impl<T> Vec<T> {
/// assert!(vec[..2] == [1, 2]);
/// ```
#[inline]
#[deprecated = "use slicing syntax"]
pub fn slice_to<'a>(&'a self, end: uint) -> &'a [T] {
self[..end]
}

8
src/libcore/slice.rs
View file

@ -152,7 +152,7 @@ pub trait ImmutableSlice<'a, T> {
fn tail(&self) -> &'a [T];
/// Returns all but the first `n' elements of a slice.
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_from"]
fn tailn(&self, n: uint) -> &'a [T];
/// Returns all but the last element of a slice.
@ -161,7 +161,6 @@ pub trait ImmutableSlice<'a, T> {
/// Returns all but the last `n' elements of a slice.
#[deprecated = "use slice_to but note the arguments are different"]
#[deprecated = "use slicing syntax, but note the arguments are different"]
fn initn(&self, n: uint) -> &'a [T];
/// Returns the last element of a slice, or `None` if it is empty.
@ -321,7 +320,7 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
fn tail(&self) -> &'a [T] { (*self)[1..] }
#[inline]
#[deprecated = "use slicing syntax"]
#[deprecated = "use slice_from"]
fn tailn(&self, n: uint) -> &'a [T] { (*self)[n..] }
#[inline]
@ -330,7 +329,7 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
}
#[inline]
#[deprecated = "use slicing syntax but note the arguments are different"]
#[deprecated = "use slice_to but note the arguments are different"]
fn initn(&self, n: uint) -> &'a [T] {
(*self)[..self.len() - n]
}
@ -543,7 +542,6 @@ pub trait MutableSlice<'a, T> {
fn get_mut(self, index: uint) -> Option<&'a mut T>;
/// Work with `self` as a mut slice.
/// Primarily intended for getting a &mut [T] from a [T, ..N].
#[deprecated = "use slicing syntax"]
fn as_mut_slice(self) -> &'a mut [T];
/// Deprecated: use `iter_mut`.

84
src/libcore/str.rs
View file

@ -1164,6 +1164,7 @@ pub mod traits {
fn equiv(&self, other: &S) -> bool { eq_slice(*self, other.as_slice()) }
}
#[cfg(stage0)]
impl ops::Slice<uint, str> for str {
#[inline]
fn as_slice_<'a>(&'a self) -> &'a str {
@ -1172,17 +1173,39 @@ pub mod traits {
#[inline]
fn slice_from_<'a>(&'a self, from: &uint) -> &'a str {
self.slice_from(*from)
super::slice_from_impl(&self, *from)
}
#[inline]
fn slice_to_<'a>(&'a self, to: &uint) -> &'a str {
self.slice_to(*to)
super::slice_to_impl(&self, *to)
}
#[inline]
fn slice_<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
self.slice(*from, *to)
super::slice_impl(&self, *from, *to)
}
}
#[cfg(not(stage0))]
impl ops::Slice<uint, str> for str {
#[inline]
fn as_slice<'a>(&'a self) -> &'a str {
self
}
#[inline]
fn slice_from<'a>(&'a self, from: &uint) -> &'a str {
super::slice_from_impl(&self, *from)
}
#[inline]
fn slice_to<'a>(&'a self, to: &uint) -> &'a str {
super::slice_to_impl(&self, *to)
}
#[inline]
fn slice<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
super::slice_impl(&self, *from, *to)
}
}
}
@ -1835,6 +1858,38 @@ fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
begin, end, s);
}
#[inline]
fn slice_impl<'a>(this: &&'a str, begin: uint, end: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if begin <= end &&
this.is_char_boundary(begin) &&
this.is_char_boundary(end) {
unsafe { raw::slice_unchecked(*this, begin, end) }
} else {
slice_error_fail(*this, begin, end)
}
}
#[inline]
fn slice_from_impl<'a>(this: &&'a str, begin: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if this.is_char_boundary(begin) {
unsafe { raw::slice_unchecked(*this, begin, this.len()) }
} else {
slice_error_fail(*this, begin, this.len())
}
}
#[inline]
fn slice_to_impl<'a>(this: &&'a str, end: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if this.is_char_boundary(end) {
unsafe { raw::slice_unchecked(*this, 0, end) }
} else {
slice_error_fail(*this, 0, end)
}
}
impl<'a> StrSlice<'a> for &'a str {
#[inline]
fn contains<'a>(&self, needle: &'a str) -> bool {
@ -1938,34 +1993,17 @@ impl<'a> StrSlice<'a> for &'a str {
#[inline]
fn slice(&self, begin: uint, end: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if begin <= end &&
self.is_char_boundary(begin) &&
self.is_char_boundary(end) {
unsafe { raw::slice_unchecked(*self, begin, end) }
} else {
slice_error_fail(*self, begin, end)
}
slice_impl(self, begin, end)
}
#[inline]
fn slice_from(&self, begin: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if self.is_char_boundary(begin) {
unsafe { raw::slice_unchecked(*self, begin, self.len()) }
} else {
slice_error_fail(*self, begin, self.len())
}
slice_from_impl(self, begin)
}
#[inline]
fn slice_to(&self, end: uint) -> &'a str {
// is_char_boundary checks that the index is in [0, .len()]
if self.is_char_boundary(end) {
unsafe { raw::slice_unchecked(*self, 0, end) }
} else {
slice_error_fail(*self, 0, end)
}
slice_to_impl(self, end)
}
fn slice_chars(&self, begin: uint, end: uint) -> &'a str {

2
src/libnative/io/pipe_windows.rs
View file

@ -448,7 +448,7 @@ impl rtio::RtioPipe for UnixStream {
}
let ret = unsafe {
libc::WriteFile(self.handle(),
buf.slice_from(offset).as_ptr() as libc::LPVOID,
buf[offset..].as_ptr() as libc::LPVOID,
(buf.len() - offset) as libc::DWORD,
&mut bytes_written,
&mut overlapped)

2
src/libstd/os.rs
View file

@ -144,7 +144,7 @@ pub mod windows {
use option::{None, Option};
use option;
use os::TMPBUF_SZ;
use slice::{MutableSlice, ImmutableSlice};
use slice::MutableSlice;
use string::String;
use str::StrSlice;
use vec::Vec;

2
src/libstd/rt/backtrace.rs
View file

@ -999,7 +999,7 @@ mod imp {
let bytes = cstr.as_bytes();
match cstr.as_str() {
Some(s) => try!(super::demangle(w, s)),
None => try!(w.write(bytes.slice_to(bytes.len() - 1))),
None => try!(w.write(bytes[..bytes.len()-1])),
}
}
try!(w.write(['\n' as u8]));