Integerate generic string slice code

Integrate matches() and match_indices()

Integrate splits variations

Integrated starts_with and ends_with

Integrated trim_*

Integrated [r]find

Add impl for regex

Added `core::slice::raw::[mut_]slice_unchecked`

Add test for empty strings

Export Utf8Char

Made searcher haystack simpler to access

src/compiletest/header.rs

@@ -268,7 +268,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
pub fn parse_name_value_directive(line: &str, directive: &str)
                                  -> Option<String> {
    let keycolon = format!("{}:", directive);
    match line.find_str(keycolon.as_slice()) {
    match line.find(keycolon.as_slice()) {
        Some(colon) => {
            let value = line.slice(colon + keycolon.len(),
                                   line.len()).to_string();

src/compiletest/runtest.rs

@@ -696,7 +696,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
            check_lines.iter().map(|s| {
                s.as_slice()
                 .trim()
                 .split_str("[...]")
                 .split("[...]")
                 .map(|x| x.to_string())
                 .collect()
            }).collect();
@@ -715,7 +715,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                        None
                    }
                } else {
                    rest.find_str(frag.as_slice())
                    rest.find(frag.as_slice())
                };
                match found {
                    None => {

src/libcollections/str.rs

@@ -87,12 +87,23 @@ use unicode;
use vec::Vec;

pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
pub use core::str::Utf8Char;
pub use core::str::{Bytes, CharSplits};
pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
pub use core::str::{CharSplitsN, AnyLines, StrSplits};
pub use core::str::{eq_slice, is_utf8, is_utf16, Utf16Items};
pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
pub use core::str::{Str, StrSlice};
pub use core::str::{Pattern};
pub use core::str::{Matcher, LeftMatcher, RightMatcher, DoubleEndedMatcher};
pub use core::str::{CharMatcher, StrMatcher, CharFnMatcher};
pub use core::str::{CharSliceMatcher, CharClosureMatcher};
pub use core::str::{CharEqMatcher, CharEqPattern};
pub use core::str::{Matches, RMatches};
pub use core::str::{MatchIndices, RMatchIndices};
pub use core::str::{Splits, RSplits};
pub use core::str::{NSplits, RNSplits};
pub use core::str::{TermSplits, RTermSplits};
pub use unicode::str::{UnicodeStrSlice, Words, Graphemes, GraphemeIndices};

/*
@@ -428,7 +439,8 @@ impl<'a> Iterator<char> for Recompositions<'a> {
pub fn replace(s: &str, from: &str, to: &str) -> String {
    let mut result = String::new();
    let mut last_end = 0;
    for (start, end) in s.match_indices(from) {
    for (start, match_str) in s.match_indices(from) {
        let end = start + match_str.len();
        result.push_str(unsafe{raw::slice_bytes(s, last_end, start)});
        result.push_str(to);
        last_end = end;
@@ -753,15 +765,7 @@ pub trait StrAllocating: Str {
    /// ```
    fn replace(&self, from: &str, to: &str) -> String {
        let me = self.as_slice();
        let mut result = String::new();
        let mut last_end = 0;
        for (start, end) in me.match_indices(from) {
            result.push_str(unsafe{raw::slice_bytes(me, last_end, start)});
            result.push_str(to);
            last_end = end;
        }
        result.push_str(unsafe{raw::slice_bytes(me, last_end, me.len())});
        result
        replace(me, from, to)
    }

    #[allow(missing_doc)]
@@ -1787,10 +1791,12 @@ mod tests {
        rsplit.reverse();
        assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);

        let split: Vec<&str> = data.split(|c: char| c == ' ').collect();
        let f = |c: char| c == ' ';
        let split: Vec<&str> = data.split(f).collect();
        assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);

        let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect();
        let f = |c: char| c == ' ';
        let mut rsplit: Vec<&str> = data.split(f).rev().collect();
        rsplit.reverse();
        assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);

@@ -1802,10 +1808,12 @@ mod tests {
        rsplit.reverse();
        assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);

        let split: Vec<&str> = data.split(|c: char| c == 'ä').collect();
        let f = |c: char| c == 'ä';
        let split: Vec<&str> = data.split(f).collect();
        assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);

        let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect();
        let f = |c: char| c == 'ä';
        let mut rsplit: Vec<&str> = data.split(f).rev().collect();
        rsplit.reverse();
        assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
    }
@@ -1817,14 +1825,16 @@ mod tests {
        let split: Vec<&str> = data.splitn(3, ' ').collect();
        assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);

        let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
        let f = |c: char| c == ' ';
        let split: Vec<&str> = data.splitn(3, f).collect();
        assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);

        // Unicode
        let split: Vec<&str> = data.splitn(3, 'ä').collect();
        assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);

        let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
        let f = |c: char| c == 'ä';
        let split: Vec<&str> = data.splitn(3, f).collect();
        assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
    }

@@ -1836,7 +1846,8 @@ mod tests {
        split.reverse();
        assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);

        let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect();
        let f = |c: char| c == ' ';
        let mut split: Vec<&str> = data.rsplitn(3, f).collect();
        split.reverse();
        assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);

@@ -1845,7 +1856,8 @@ mod tests {
        split.reverse();
        assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);

        let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect();
        let f = |c: char| c == 'ä';
        let mut split: Vec<&str> = data.rsplitn(3, f).collect();
        split.reverse();
        assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
    }
@@ -2458,7 +2470,7 @@ mod bench {
        }
        let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";

        b.iter(|| assert_eq!(s.split(NotAscii('V')).count(), 3));
        b.iter(|| assert_eq!(s.split(CharEqPattern(NotAscii('V'))).count(), 3));
    }


@@ -2484,7 +2496,7 @@ mod bench {
        let s = "Mary had a little lamb, Little lamb, little-lamb.";
        let len = s.split(' ').count();

        b.iter(|| assert_eq!(s.split(NotAscii(' ')).count(), len));
        b.iter(|| assert_eq!(s.split(CharEqPattern(NotAscii(' '))).count(), len));
    }

    #[bench]
@@ -2501,7 +2513,10 @@ mod bench {
        let s = "Mary had a little lamb, Little lamb, little-lamb.";
        let len = s.split(' ').count();

        b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
        b.iter(|| {
            let f = |c: char| c == ' ';
            assert_eq!(s.split(f).count(), len)
        });
    }

    #[bench]

src/libcore/slice.rs

@@ -287,10 +287,7 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
        assert!(start <= end);
        assert!(end <= self.len());
        unsafe {
            transmute(RawSlice {
                    data: self.as_ptr().offset(start as int),
                    len: (end - start)
                })
            raw::slice_unchecked(*self, start, end)
        }
    }

@@ -700,10 +697,7 @@ impl<'a,T> MutableSlice<'a, T> for &'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)
                })
            raw::mut_slice_unchecked(self, start, end)
        }
    }

@@ -1526,6 +1520,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
/// Unsafe operations
#[experimental = "needs review"]
pub mod raw {
    use super::{ImmutableSlice, MutableSlice};
    use mem::transmute;
    use ptr::RawPtr;
    use raw::Slice;
@@ -1566,7 +1561,7 @@ pub mod raw {
     * slice so it no longer contains that element. Returns None
     * if the slice is empty. O(1).
     */
     #[inline]
    #[inline]
    pub unsafe fn shift_ptr<T>(slice: &mut Slice<T>) -> Option<*const T> {
        if slice.len == 0 { return None; }
        let head: *const T = slice.data;
@@ -1580,13 +1575,35 @@ pub mod raw {
     * slice so it no longer contains that element. Returns None
     * if the slice is empty. O(1).
     */
     #[inline]
    #[inline]
    pub unsafe fn pop_ptr<T>(slice: &mut Slice<T>) -> Option<*const T> {
        if slice.len == 0 { return None; }
        let tail: *const T = slice.data.offset((slice.len - 1) as int);
        slice.len -= 1;
        Some(tail)
    }

    /// Create a slice without doing any bound checking
    #[inline]
    pub unsafe fn slice_unchecked<'a, T>(slice: &'a [T],
                                         start: uint,
                                         end: uint) -> &'a [T] {
        transmute(Slice {
            data: slice.as_ptr().offset(start as int),
            len: (end - start)
        })
    }

    /// Create a mutable slice without doing any bound checking
    #[inline]
    pub unsafe fn mut_slice_unchecked<'a, T>(slice: &'a mut [T],
                                             start: uint,
                                             end: uint) -> &'a mut [T] {
        transmute(Slice {
            data: slice.as_mut_ptr().offset(start as int) as *const T,
            len: (end - start)
        })
    }
}

/// Operations on `[u8]`.