Auto merge of #22466 - Kimundi:str_pattern_ai_safe, r=aturon
This is not a complete implementation of the RFC: - only existing methods got updated, no new ones added - doc comments are not extensive enough yet - optimizations got lost and need to be reimplemented See https://github.com/rust-lang/rfcs/pull/528 Technically a [breaking-change]
This commit is contained in:
bors
@@ -22,13 +22,13 @@ use option::Option;
|
||||
use slice::SliceExt;
|
||||
|
||||
// UTF-8 ranges and tags for encoding characters
|
||||
static TAG_CONT: u8 = 0b1000_0000u8;
|
||||
static TAG_TWO_B: u8 = 0b1100_0000u8;
|
||||
static TAG_THREE_B: u8 = 0b1110_0000u8;
|
||||
static TAG_FOUR_B: u8 = 0b1111_0000u8;
|
||||
static MAX_ONE_B: u32 = 0x80u32;
|
||||
static MAX_TWO_B: u32 = 0x800u32;
|
||||
static MAX_THREE_B: u32 = 0x10000u32;
|
||||
const TAG_CONT: u8 = 0b1000_0000u8;
|
||||
const TAG_TWO_B: u8 = 0b1100_0000u8;
|
||||
const TAG_THREE_B: u8 = 0b1110_0000u8;
|
||||
const TAG_FOUR_B: u8 = 0b1111_0000u8;
|
||||
const MAX_ONE_B: u32 = 0x80u32;
|
||||
const MAX_TWO_B: u32 = 0x800u32;
|
||||
const MAX_THREE_B: u32 = 0x10000u32;
|
||||
|
||||
/*
|
||||
Lu Uppercase_Letter an uppercase letter
|
||||
@@ -398,11 +398,14 @@ impl CharExt for char {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn len_utf8(self) -> usize {
|
||||
let code = self as u32;
|
||||
match () {
|
||||
_ if code < MAX_ONE_B => 1,
|
||||
_ if code < MAX_TWO_B => 2,
|
||||
_ if code < MAX_THREE_B => 3,
|
||||
_ => 4,
|
||||
if code < MAX_ONE_B {
|
||||
1
|
||||
} else if code < MAX_TWO_B {
|
||||
2
|
||||
} else if code < MAX_THREE_B {
|
||||
3
|
||||
} else {
|
||||
4
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -657,6 +657,8 @@ macro_rules! iterator {
|
||||
fn next(&mut self) -> Option<$elem> {
|
||||
// could be implemented with slices, but this avoids bounds checks
|
||||
unsafe {
|
||||
::intrinsics::assume(!self.ptr.is_null());
|
||||
::intrinsics::assume(!self.end.is_null());
|
||||
if self.ptr == self.end {
|
||||
None
|
||||
} else {
|
||||
@@ -693,6 +695,8 @@ macro_rules! iterator {
|
||||
fn next_back(&mut self) -> Option<$elem> {
|
||||
// could be implemented with slices, but this avoids bounds checks
|
||||
unsafe {
|
||||
::intrinsics::assume(!self.ptr.is_null());
|
||||
::intrinsics::assume(!self.end.is_null());
|
||||
if self.end == self.ptr {
|
||||
None
|
||||
} else {
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
|
||||
#![doc(primitive = "str")]
|
||||
|
||||
use self::Searcher::{Naive, TwoWay, TwoWayLong};
|
||||
use self::OldSearcher::{TwoWay, TwoWayLong};
|
||||
|
||||
use clone::Clone;
|
||||
use cmp::{self, Eq};
|
||||
@@ -36,6 +36,11 @@ use result::Result::{self, Ok, Err};
|
||||
use slice::{self, SliceExt};
|
||||
use usize;
|
||||
|
||||
pub use self::pattern::Pattern;
|
||||
pub use self::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher, SearchStep};
|
||||
|
||||
mod pattern;
|
||||
|
||||
macro_rules! delegate_iter {
|
||||
(exact $te:ty : $ti:ty) => {
|
||||
delegate_iter!{$te : $ti}
|
||||
@@ -70,7 +75,7 @@ macro_rules! delegate_iter {
|
||||
};
|
||||
(pattern $te:ty : $ti:ty) => {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, P: CharEq> Iterator for $ti {
|
||||
impl<'a, P: Pattern<'a>> Iterator for $ti {
|
||||
type Item = $te;
|
||||
|
||||
#[inline]
|
||||
@@ -83,7 +88,8 @@ macro_rules! delegate_iter {
|
||||
}
|
||||
}
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, P: CharEq> DoubleEndedIterator for $ti {
|
||||
impl<'a, P: Pattern<'a>> DoubleEndedIterator for $ti
|
||||
where P::Searcher: DoubleEndedSearcher<'a> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<$te> {
|
||||
self.0.next_back()
|
||||
@@ -92,7 +98,8 @@ macro_rules! delegate_iter {
|
||||
};
|
||||
(pattern forward $te:ty : $ti:ty) => {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, P: CharEq> Iterator for $ti {
|
||||
impl<'a, P: Pattern<'a>> Iterator for $ti
|
||||
where P::Searcher: DoubleEndedSearcher<'a> {
|
||||
type Item = $te;
|
||||
|
||||
#[inline]
|
||||
@@ -235,8 +242,10 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str {
|
||||
}
|
||||
|
||||
/// Something that can be used to compare against a character
|
||||
#[unstable(feature = "core",
|
||||
reason = "definition may change as pattern-related methods are stabilized")]
|
||||
#[unstable(feature = "core")]
|
||||
#[deprecated(since = "1.0.0",
|
||||
reason = "use `Pattern` instead")]
|
||||
// NB: Rather than removing it, make it private and move it into self::pattern
|
||||
pub trait CharEq {
|
||||
/// Determine if the splitter should split at the given character
|
||||
fn matches(&mut self, char) -> bool;
|
||||
@@ -245,6 +254,7 @@ pub trait CharEq {
|
||||
fn only_ascii(&self) -> bool;
|
||||
}
|
||||
|
||||
#[allow(deprecated) /* for CharEq */ ]
|
||||
impl CharEq for char {
|
||||
#[inline]
|
||||
fn matches(&mut self, c: char) -> bool { *self == c }
|
||||
@@ -253,6 +263,7 @@ impl CharEq for char {
|
||||
fn only_ascii(&self) -> bool { (*self as u32) < 128 }
|
||||
}
|
||||
|
||||
#[allow(deprecated) /* for CharEq */ ]
|
||||
impl<F> CharEq for F where F: FnMut(char) -> bool {
|
||||
#[inline]
|
||||
fn matches(&mut self, c: char) -> bool { (*self)(c) }
|
||||
@@ -261,13 +272,16 @@ impl<F> CharEq for F where F: FnMut(char) -> bool {
|
||||
fn only_ascii(&self) -> bool { false }
|
||||
}
|
||||
|
||||
#[allow(deprecated) /* for CharEq */ ]
|
||||
impl<'a> CharEq for &'a [char] {
|
||||
#[inline]
|
||||
#[allow(deprecated) /* for CharEq */ ]
|
||||
fn matches(&mut self, c: char) -> bool {
|
||||
self.iter().any(|&m| { let mut m = m; m.matches(c) })
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(deprecated) /* for CharEq */ ]
|
||||
fn only_ascii(&self) -> bool {
|
||||
self.iter().all(|m| m.only_ascii())
|
||||
}
|
||||
@@ -337,6 +351,7 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
|
||||
/// Reads the next code point out of a byte iterator (assuming a
|
||||
/// UTF-8-like encoding).
|
||||
#[unstable(feature = "core")]
|
||||
#[inline]
|
||||
pub fn next_code_point(bytes: &mut slice::Iter<u8>) -> Option<u32> {
|
||||
// Decode UTF-8
|
||||
let x = match bytes.next() {
|
||||
@@ -368,6 +383,38 @@ pub fn next_code_point(bytes: &mut slice::Iter<u8>) -> Option<u32> {
|
||||
Some(ch)
|
||||
}
|
||||
|
||||
/// Reads the last code point out of a byte iterator (assuming a
|
||||
/// UTF-8-like encoding).
|
||||
#[unstable(feature = "core")]
|
||||
#[inline]
|
||||
pub fn next_code_point_reverse(bytes: &mut slice::Iter<u8>) -> Option<u32> {
|
||||
// Decode UTF-8
|
||||
let w = match bytes.next_back() {
|
||||
None => return None,
|
||||
Some(&next_byte) if next_byte < 128 => return Some(next_byte as u32),
|
||||
Some(&back_byte) => back_byte,
|
||||
};
|
||||
|
||||
// Multibyte case follows
|
||||
// Decode from a byte combination out of: [x [y [z w]]]
|
||||
let mut ch;
|
||||
let z = unwrap_or_0(bytes.next_back());
|
||||
ch = utf8_first_byte!(z, 2);
|
||||
if utf8_is_cont_byte!(z) {
|
||||
let y = unwrap_or_0(bytes.next_back());
|
||||
ch = utf8_first_byte!(y, 3);
|
||||
if utf8_is_cont_byte!(y) {
|
||||
let x = unwrap_or_0(bytes.next_back());
|
||||
ch = utf8_first_byte!(x, 4);
|
||||
ch = utf8_acc_cont_byte!(ch, y);
|
||||
}
|
||||
ch = utf8_acc_cont_byte!(ch, z);
|
||||
}
|
||||
ch = utf8_acc_cont_byte!(ch, w);
|
||||
|
||||
Some(ch)
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a> Iterator for Chars<'a> {
|
||||
type Item = char;
|
||||
@@ -393,33 +440,12 @@ impl<'a> Iterator for Chars<'a> {
|
||||
impl<'a> DoubleEndedIterator for Chars<'a> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<char> {
|
||||
let w = match self.iter.next_back() {
|
||||
None => return None,
|
||||
Some(&back_byte) if back_byte < 128 => return Some(back_byte as char),
|
||||
Some(&back_byte) => back_byte,
|
||||
};
|
||||
|
||||
// Multibyte case follows
|
||||
// Decode from a byte combination out of: [x [y [z w]]]
|
||||
let mut ch;
|
||||
let z = unwrap_or_0(self.iter.next_back());
|
||||
ch = utf8_first_byte!(z, 2);
|
||||
if utf8_is_cont_byte!(z) {
|
||||
let y = unwrap_or_0(self.iter.next_back());
|
||||
ch = utf8_first_byte!(y, 3);
|
||||
if utf8_is_cont_byte!(y) {
|
||||
let x = unwrap_or_0(self.iter.next_back());
|
||||
ch = utf8_first_byte!(x, 4);
|
||||
ch = utf8_acc_cont_byte!(ch, y);
|
||||
next_code_point_reverse(&mut self.iter).map(|ch| {
|
||||
// str invariant says `ch` is a valid Unicode Scalar Value
|
||||
unsafe {
|
||||
mem::transmute(ch)
|
||||
}
|
||||
ch = utf8_acc_cont_byte!(ch, z);
|
||||
}
|
||||
ch = utf8_acc_cont_byte!(ch, w);
|
||||
|
||||
// str invariant says `ch` is a valid Unicode Scalar Value
|
||||
unsafe {
|
||||
Some(mem::transmute(ch))
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -495,22 +521,20 @@ impl<'a> Fn<(&'a u8,)> for BytesDeref {
|
||||
}
|
||||
|
||||
/// An iterator over the substrings of a string, separated by `sep`.
|
||||
#[derive(Clone)]
|
||||
struct CharSplits<'a, Sep> {
|
||||
struct CharSplits<'a, P: Pattern<'a>> {
|
||||
/// The slice remaining to be iterated
|
||||
string: &'a str,
|
||||
sep: Sep,
|
||||
start: usize,
|
||||
end: usize,
|
||||
matcher: P::Searcher,
|
||||
/// Whether an empty string at the end is allowed
|
||||
allow_trailing_empty: bool,
|
||||
only_ascii: bool,
|
||||
finished: bool,
|
||||
}
|
||||
|
||||
/// An iterator over the substrings of a string, separated by `sep`,
|
||||
/// splitting at most `count` times.
|
||||
#[derive(Clone)]
|
||||
struct CharSplitsN<'a, Sep> {
|
||||
iter: CharSplits<'a, Sep>,
|
||||
struct CharSplitsN<'a, P: Pattern<'a>> {
|
||||
iter: CharSplits<'a, P>,
|
||||
/// The number of splits remaining
|
||||
count: usize,
|
||||
invert: bool,
|
||||
@@ -528,12 +552,15 @@ pub struct LinesAny<'a> {
|
||||
inner: Map<Lines<'a>, fn(&str) -> &str>,
|
||||
}
|
||||
|
||||
impl<'a, Sep> CharSplits<'a, Sep> {
|
||||
impl<'a, P: Pattern<'a>> CharSplits<'a, P> {
|
||||
#[inline]
|
||||
fn get_end(&mut self) -> Option<&'a str> {
|
||||
if !self.finished && (self.allow_trailing_empty || self.string.len() > 0) {
|
||||
if !self.finished && (self.allow_trailing_empty || self.end - self.start > 0) {
|
||||
self.finished = true;
|
||||
Some(self.string)
|
||||
unsafe {
|
||||
let string = self.matcher.haystack().slice_unchecked(self.start, self.end);
|
||||
Some(string)
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
@@ -541,33 +568,18 @@ impl<'a, Sep> CharSplits<'a, Sep> {
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
|
||||
impl<'a, P: Pattern<'a>> Iterator for CharSplits<'a, P> {
|
||||
type Item = &'a str;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<&'a str> {
|
||||
if self.finished { return None }
|
||||
|
||||
let mut next_split = None;
|
||||
if self.only_ascii {
|
||||
for (idx, byte) in self.string.bytes().enumerate() {
|
||||
if self.sep.matches(byte as char) && byte < 128u8 {
|
||||
next_split = Some((idx, idx + 1));
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (idx, ch) in self.string.char_indices() {
|
||||
if self.sep.matches(ch) {
|
||||
next_split = Some((idx, self.string.char_range_at(idx).next));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
match next_split {
|
||||
let haystack = self.matcher.haystack();
|
||||
match self.matcher.next_match() {
|
||||
Some((a, b)) => unsafe {
|
||||
let elt = self.string.slice_unchecked(0, a);
|
||||
self.string = self.string.slice_unchecked(b, self.string.len());
|
||||
let elt = haystack.slice_unchecked(self.start, a);
|
||||
self.start = b;
|
||||
Some(elt)
|
||||
},
|
||||
None => self.get_end(),
|
||||
@@ -576,7 +588,8 @@ impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
|
||||
impl<'a, P: Pattern<'a>> DoubleEndedIterator for CharSplits<'a, P>
|
||||
where P::Searcher: DoubleEndedSearcher<'a> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<&'a str> {
|
||||
if self.finished { return None }
|
||||
@@ -588,37 +601,25 @@ impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
|
||||
_ => if self.finished { return None }
|
||||
}
|
||||
}
|
||||
let len = self.string.len();
|
||||
let mut next_split = None;
|
||||
|
||||
if self.only_ascii {
|
||||
for (idx, byte) in self.string.bytes().enumerate().rev() {
|
||||
if self.sep.matches(byte as char) && byte < 128u8 {
|
||||
next_split = Some((idx, idx + 1));
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (idx, ch) in self.string.char_indices().rev() {
|
||||
if self.sep.matches(ch) {
|
||||
next_split = Some((idx, self.string.char_range_at(idx).next));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
match next_split {
|
||||
let haystack = self.matcher.haystack();
|
||||
match self.matcher.next_match_back() {
|
||||
Some((a, b)) => unsafe {
|
||||
let elt = self.string.slice_unchecked(b, len);
|
||||
self.string = self.string.slice_unchecked(0, a);
|
||||
let elt = haystack.slice_unchecked(b, self.end);
|
||||
self.end = a;
|
||||
Some(elt)
|
||||
},
|
||||
None => { self.finished = true; Some(self.string) }
|
||||
None => unsafe {
|
||||
self.finished = true;
|
||||
Some(haystack.slice_unchecked(self.start, self.end))
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
|
||||
impl<'a, P: Pattern<'a>> Iterator for CharSplitsN<'a, P>
|
||||
where P::Searcher: DoubleEndedSearcher<'a> {
|
||||
type Item = &'a str;
|
||||
|
||||
#[inline]
|
||||
@@ -632,32 +633,6 @@ impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The internal state of an iterator that searches for matches of a substring
|
||||
/// within a larger string using naive search
|
||||
#[derive(Clone)]
|
||||
struct NaiveSearcher {
|
||||
position: usize
|
||||
}
|
||||
|
||||
impl NaiveSearcher {
|
||||
fn new() -> NaiveSearcher {
|
||||
NaiveSearcher { position: 0 }
|
||||
}
|
||||
|
||||
fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(usize, usize)> {
|
||||
while self.position + needle.len() <= haystack.len() {
|
||||
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()));
|
||||
} else {
|
||||
self.position += 1;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// The internal state of an iterator that searches for matches of a substring
|
||||
/// within a larger string using two-way search
|
||||
#[derive(Clone)]
|
||||
@@ -743,6 +718,7 @@ struct TwoWaySearcher {
|
||||
|
||||
*/
|
||||
impl TwoWaySearcher {
|
||||
#[allow(dead_code)]
|
||||
fn new(needle: &[u8]) -> TwoWaySearcher {
|
||||
let (crit_pos_false, period_false) = TwoWaySearcher::maximal_suffix(needle, false);
|
||||
let (crit_pos_true, period_true) = TwoWaySearcher::maximal_suffix(needle, true);
|
||||
@@ -852,6 +828,7 @@ impl TwoWaySearcher {
|
||||
// Specifically, returns (i, p), where i is the starting index of v in some
|
||||
// critical factorization (u, v) and p = period(v)
|
||||
#[inline]
|
||||
#[allow(dead_code)]
|
||||
fn maximal_suffix(arr: &[u8], reversed: bool) -> (usize, usize) {
|
||||
let mut left = -1; // Corresponds to i in the paper
|
||||
let mut right = 0; // Corresponds to j in the paper
|
||||
@@ -896,20 +873,26 @@ impl TwoWaySearcher {
|
||||
/// The internal state of an iterator that searches for matches of a substring
|
||||
/// within a larger string using a dynamically chosen search algorithm
|
||||
#[derive(Clone)]
|
||||
enum Searcher {
|
||||
Naive(NaiveSearcher),
|
||||
// NB: This is kept around for convenience because
|
||||
// it is planned to be used again in the future
|
||||
enum OldSearcher {
|
||||
TwoWay(TwoWaySearcher),
|
||||
TwoWayLong(TwoWaySearcher)
|
||||
TwoWayLong(TwoWaySearcher),
|
||||
}
|
||||
|
||||
impl Searcher {
|
||||
fn new(haystack: &[u8], needle: &[u8]) -> Searcher {
|
||||
impl OldSearcher {
|
||||
#[allow(dead_code)]
|
||||
fn new(haystack: &[u8], needle: &[u8]) -> OldSearcher {
|
||||
if needle.len() == 0 {
|
||||
// Handle specially
|
||||
unimplemented!()
|
||||
// FIXME: Tune this.
|
||||
// FIXME(#16715): This unsigned integer addition will probably not
|
||||
// overflow because that would mean that the memory almost solely
|
||||
// consists of the needle. Needs #16715 to be formally fixed.
|
||||
if needle.len() + 20 > haystack.len() {
|
||||
Naive(NaiveSearcher::new())
|
||||
} else if needle.len() + 20 > haystack.len() {
|
||||
// Use naive searcher
|
||||
unimplemented!()
|
||||
} else {
|
||||
let searcher = TwoWaySearcher::new(needle);
|
||||
if searcher.memory == usize::MAX { // If the period is long
|
||||
@@ -921,66 +904,58 @@ impl Searcher {
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator over the start and end indices of the matches of a
|
||||
/// substring within a larger string
|
||||
#[derive(Clone)]
|
||||
#[unstable(feature = "core", reason = "type may be removed")]
|
||||
pub struct MatchIndices<'a> {
|
||||
// NB: This is kept around for convenience because
|
||||
// it is planned to be used again in the future
|
||||
struct OldMatchIndices<'a, 'b> {
|
||||
// constants
|
||||
haystack: &'a str,
|
||||
needle: &'a str,
|
||||
searcher: Searcher
|
||||
needle: &'b str,
|
||||
searcher: OldSearcher
|
||||
}
|
||||
|
||||
/// An iterator over the substrings of a string separated by a given
|
||||
/// search string
|
||||
#[derive(Clone)]
|
||||
// FIXME: #21637 Prevents a Clone impl
|
||||
/// An iterator over the start and end indices of the matches of a
|
||||
/// substring within a larger string
|
||||
#[unstable(feature = "core", reason = "type may be removed")]
|
||||
pub struct SplitStr<'a> {
|
||||
it: MatchIndices<'a>,
|
||||
last_end: usize,
|
||||
finished: bool
|
||||
}
|
||||
pub struct MatchIndices<'a, P: Pattern<'a>>(P::Searcher);
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a> Iterator for MatchIndices<'a> {
|
||||
impl<'a, P: Pattern<'a>> Iterator for MatchIndices<'a, P> {
|
||||
type Item = (usize, usize);
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<(usize, usize)> {
|
||||
match self.searcher {
|
||||
Naive(ref mut searcher)
|
||||
=> searcher.next(self.haystack.as_bytes(), self.needle.as_bytes()),
|
||||
TwoWay(ref mut searcher)
|
||||
=> searcher.next(self.haystack.as_bytes(), self.needle.as_bytes(), false),
|
||||
TwoWayLong(ref mut searcher)
|
||||
=> searcher.next(self.haystack.as_bytes(), self.needle.as_bytes(), true)
|
||||
}
|
||||
self.0.next_match()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a> Iterator for SplitStr<'a> {
|
||||
/// An iterator over the substrings of a string separated by a given
|
||||
/// search string
|
||||
#[unstable(feature = "core")]
|
||||
#[deprecated(since = "1.0.0", reason = "use `Split` with a `&str`")]
|
||||
pub struct SplitStr<'a, P: Pattern<'a>>(Split<'a, P>);
|
||||
impl<'a, P: Pattern<'a>> Iterator for SplitStr<'a, P> {
|
||||
type Item = &'a str;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<&'a str> {
|
||||
if self.finished { return None; }
|
||||
|
||||
match self.it.next() {
|
||||
Some((from, to)) => {
|
||||
let ret = Some(&self.it.haystack[self.last_end .. from]);
|
||||
self.last_end = to;
|
||||
ret
|
||||
}
|
||||
None => {
|
||||
self.finished = true;
|
||||
Some(&self.it.haystack[self.last_end .. self.it.haystack.len()])
|
||||
}
|
||||
}
|
||||
Iterator::next(&mut self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b> OldMatchIndices<'a, 'b> {
|
||||
#[inline]
|
||||
#[allow(dead_code)]
|
||||
fn next(&mut self) -> Option<(usize, usize)> {
|
||||
match self.searcher {
|
||||
TwoWay(ref mut searcher)
|
||||
=> searcher.next(self.haystack.as_bytes(), self.needle.as_bytes(), false),
|
||||
TwoWayLong(ref mut searcher)
|
||||
=> searcher.next(self.haystack.as_bytes(), self.needle.as_bytes(), true),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Section: Comparing strings
|
||||
@@ -1298,28 +1273,39 @@ impl<'a, S: ?Sized> Str for &'a S where S: Str {
|
||||
}
|
||||
|
||||
/// Return type of `StrExt::split`
|
||||
#[derive(Clone)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct Split<'a, P>(CharSplits<'a, P>);
|
||||
delegate_iter!{pattern &'a str : Split<'a, P>}
|
||||
pub struct Split<'a, P: Pattern<'a>>(CharSplits<'a, P>);
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, P: Pattern<'a>> Iterator for Split<'a, P> {
|
||||
type Item = &'a str;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<&'a str> {
|
||||
self.0.next()
|
||||
}
|
||||
}
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, P: Pattern<'a>> DoubleEndedIterator for Split<'a, P>
|
||||
where P::Searcher: DoubleEndedSearcher<'a> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<&'a str> {
|
||||
self.0.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
/// Return type of `StrExt::split_terminator`
|
||||
#[derive(Clone)]
|
||||
#[unstable(feature = "core",
|
||||
reason = "might get removed in favour of a constructor method on Split")]
|
||||
pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct SplitTerminator<'a, P: Pattern<'a>>(CharSplits<'a, P>);
|
||||
delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
|
||||
|
||||
/// Return type of `StrExt::splitn`
|
||||
#[derive(Clone)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct SplitN<'a, P>(CharSplitsN<'a, P>);
|
||||
pub struct SplitN<'a, P: Pattern<'a>>(CharSplitsN<'a, P>);
|
||||
delegate_iter!{pattern forward &'a str : SplitN<'a, P>}
|
||||
|
||||
/// Return type of `StrExt::rsplitn`
|
||||
#[derive(Clone)]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct RSplitN<'a, P>(CharSplitsN<'a, P>);
|
||||
pub struct RSplitN<'a, P: Pattern<'a>>(CharSplitsN<'a, P>);
|
||||
delegate_iter!{pattern forward &'a str : RSplitN<'a, P>}
|
||||
|
||||
/// Methods for string slices
|
||||
@@ -1328,36 +1314,40 @@ pub trait StrExt {
|
||||
// NB there are no docs here are they're all located on the StrExt trait in
|
||||
// libcollections, not here.
|
||||
|
||||
fn contains(&self, pat: &str) -> bool;
|
||||
fn contains_char<P: CharEq>(&self, pat: P) -> bool;
|
||||
fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool;
|
||||
fn contains_char<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool;
|
||||
fn chars<'a>(&'a self) -> Chars<'a>;
|
||||
fn bytes<'a>(&'a self) -> Bytes<'a>;
|
||||
fn char_indices<'a>(&'a self) -> CharIndices<'a>;
|
||||
fn split<'a, P: CharEq>(&'a self, pat: P) -> Split<'a, P>;
|
||||
fn splitn<'a, P: CharEq>(&'a self, count: usize, pat: P) -> SplitN<'a, P>;
|
||||
fn split_terminator<'a, P: CharEq>(&'a self, pat: P) -> SplitTerminator<'a, P>;
|
||||
fn rsplitn<'a, P: CharEq>(&'a self, count: usize, pat: P) -> RSplitN<'a, P>;
|
||||
fn match_indices<'a>(&'a self, sep: &'a str) -> MatchIndices<'a>;
|
||||
fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a>;
|
||||
fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P>;
|
||||
fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P>;
|
||||
fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P>;
|
||||
fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P>;
|
||||
fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P>;
|
||||
fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P>;
|
||||
fn lines<'a>(&'a self) -> Lines<'a>;
|
||||
fn lines_any<'a>(&'a self) -> LinesAny<'a>;
|
||||
fn char_len(&self) -> usize;
|
||||
fn slice_chars<'a>(&'a self, begin: usize, end: usize) -> &'a str;
|
||||
unsafe fn slice_unchecked<'a>(&'a self, begin: usize, end: usize) -> &'a str;
|
||||
fn starts_with(&self, pat: &str) -> bool;
|
||||
fn ends_with(&self, pat: &str) -> bool;
|
||||
fn trim_matches<'a, P: CharEq>(&'a self, pat: P) -> &'a str;
|
||||
fn trim_left_matches<'a, P: CharEq>(&'a self, pat: P) -> &'a str;
|
||||
fn trim_right_matches<'a, P: CharEq>(&'a self, pat: P) -> &'a str;
|
||||
fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool;
|
||||
fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
|
||||
where P::Searcher: ReverseSearcher<'a>;
|
||||
fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
|
||||
where P::Searcher: DoubleEndedSearcher<'a>;
|
||||
fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str;
|
||||
fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
|
||||
where P::Searcher: ReverseSearcher<'a>;
|
||||
fn is_char_boundary(&self, index: usize) -> bool;
|
||||
fn char_range_at(&self, start: usize) -> CharRange;
|
||||
fn char_range_at_reverse(&self, start: usize) -> CharRange;
|
||||
fn char_at(&self, i: usize) -> char;
|
||||
fn char_at_reverse(&self, i: usize) -> char;
|
||||
fn as_bytes<'a>(&'a self) -> &'a [u8];
|
||||
fn find<P: CharEq>(&self, pat: P) -> Option<usize>;
|
||||
fn rfind<P: CharEq>(&self, pat: P) -> Option<usize>;
|
||||
fn find_str(&self, pat: &str) -> Option<usize>;
|
||||
fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>;
|
||||
fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
|
||||
where P::Searcher: ReverseSearcher<'a>;
|
||||
fn find_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>;
|
||||
fn slice_shift_char<'a>(&'a self) -> Option<(char, &'a str)>;
|
||||
fn subslice_offset(&self, inner: &str) -> usize;
|
||||
fn as_ptr(&self) -> *const u8;
|
||||
@@ -1375,13 +1365,13 @@ fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {
|
||||
|
||||
impl StrExt for str {
|
||||
#[inline]
|
||||
fn contains(&self, needle: &str) -> bool {
|
||||
self.find_str(needle).is_some()
|
||||
fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
|
||||
pat.is_contained_in(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn contains_char<P: CharEq>(&self, pat: P) -> bool {
|
||||
self.find(pat).is_some()
|
||||
fn contains_char<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
|
||||
pat.is_contained_in(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -1400,18 +1390,18 @@ impl StrExt for str {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn split<P: CharEq>(&self, pat: P) -> Split<P> {
|
||||
fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> {
|
||||
Split(CharSplits {
|
||||
string: self,
|
||||
only_ascii: pat.only_ascii(),
|
||||
sep: pat,
|
||||
start: 0,
|
||||
end: self.len(),
|
||||
matcher: pat.into_searcher(self),
|
||||
allow_trailing_empty: true,
|
||||
finished: false,
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn splitn<P: CharEq>(&self, count: usize, pat: P) -> SplitN<P> {
|
||||
fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> {
|
||||
SplitN(CharSplitsN {
|
||||
iter: self.split(pat).0,
|
||||
count: count,
|
||||
@@ -1420,7 +1410,7 @@ impl StrExt for str {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
|
||||
fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> {
|
||||
SplitTerminator(CharSplits {
|
||||
allow_trailing_empty: false,
|
||||
..self.split(pat).0
|
||||
@@ -1428,7 +1418,7 @@ impl StrExt for str {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn rsplitn<P: CharEq>(&self, count: usize, pat: P) -> RSplitN<P> {
|
||||
fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> {
|
||||
RSplitN(CharSplitsN {
|
||||
iter: self.split(pat).0,
|
||||
count: count,
|
||||
@@ -1437,22 +1427,14 @@ impl StrExt for str {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn match_indices<'a>(&'a self, sep: &'a str) -> MatchIndices<'a> {
|
||||
assert!(!sep.is_empty());
|
||||
MatchIndices {
|
||||
haystack: self,
|
||||
needle: sep,
|
||||
searcher: Searcher::new(self.as_bytes(), sep.as_bytes())
|
||||
}
|
||||
fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> {
|
||||
MatchIndices(pat.into_searcher(self))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn split_str<'a>(&'a self, sep: &'a str) -> SplitStr<'a> {
|
||||
SplitStr {
|
||||
it: self.match_indices(sep),
|
||||
last_end: 0,
|
||||
finished: false
|
||||
}
|
||||
#[allow(deprecated) /* for SplitStr */ ]
|
||||
fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> {
|
||||
SplitStr(self.split(pat))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -1500,54 +1482,69 @@ impl StrExt for str {
|
||||
#[inline]
|
||||
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
|
||||
mem::transmute(Slice {
|
||||
data: self.as_ptr().offset(begin as isize),
|
||||
data: self.as_ptr().offset(begin as int),
|
||||
len: end - begin,
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn starts_with(&self, needle: &str) -> bool {
|
||||
let n = needle.len();
|
||||
self.len() >= n && needle.as_bytes() == &self.as_bytes()[..n]
|
||||
fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
|
||||
pat.is_prefix_of(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn ends_with(&self, needle: &str) -> bool {
|
||||
let (m, n) = (self.len(), needle.len());
|
||||
m >= n && needle.as_bytes() == &self.as_bytes()[m-n..]
|
||||
fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
|
||||
where P::Searcher: ReverseSearcher<'a>
|
||||
{
|
||||
pat.is_suffix_of(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn trim_matches<P: CharEq>(&self, mut pat: P) -> &str {
|
||||
let cur = match self.find(|c: char| !pat.matches(c)) {
|
||||
None => "",
|
||||
Some(i) => unsafe { self.slice_unchecked(i, self.len()) }
|
||||
};
|
||||
match cur.rfind(|c: char| !pat.matches(c)) {
|
||||
None => "",
|
||||
Some(i) => {
|
||||
let right = cur.char_range_at(i).next;
|
||||
unsafe { cur.slice_unchecked(0, right) }
|
||||
}
|
||||
fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
|
||||
where P::Searcher: DoubleEndedSearcher<'a>
|
||||
{
|
||||
let mut i = 0;
|
||||
let mut j = 0;
|
||||
let mut matcher = pat.into_searcher(self);
|
||||
if let Some((a, b)) = matcher.next_reject() {
|
||||
i = a;
|
||||
j = b; // Rember earliest known match, correct it below if
|
||||
// last match is different
|
||||
}
|
||||
if let Some((_, b)) = matcher.next_reject_back() {
|
||||
j = b;
|
||||
}
|
||||
unsafe {
|
||||
// Searcher is known to return valid indices
|
||||
self.slice_unchecked(i, j)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn trim_left_matches<P: CharEq>(&self, mut pat: P) -> &str {
|
||||
match self.find(|c: char| !pat.matches(c)) {
|
||||
None => "",
|
||||
Some(first) => unsafe { self.slice_unchecked(first, self.len()) }
|
||||
fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {
|
||||
let mut i = self.len();
|
||||
let mut matcher = pat.into_searcher(self);
|
||||
if let Some((a, _)) = matcher.next_reject() {
|
||||
i = a;
|
||||
}
|
||||
unsafe {
|
||||
// Searcher is known to return valid indices
|
||||
self.slice_unchecked(i, self.len())
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn trim_right_matches<P: CharEq>(&self, mut pat: P) -> &str {
|
||||
match self.rfind(|c: char| !pat.matches(c)) {
|
||||
None => "",
|
||||
Some(last) => {
|
||||
let next = self.char_range_at(last).next;
|
||||
unsafe { self.slice_unchecked(0, next) }
|
||||
}
|
||||
fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
|
||||
where P::Searcher: ReverseSearcher<'a>
|
||||
{
|
||||
let mut j = 0;
|
||||
let mut matcher = pat.into_searcher(self);
|
||||
if let Some((_, b)) = matcher.next_reject_back() {
|
||||
j = b;
|
||||
}
|
||||
unsafe {
|
||||
// Searcher is known to return valid indices
|
||||
self.slice_unchecked(0, j)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1612,36 +1609,18 @@ impl StrExt for str {
|
||||
unsafe { mem::transmute(self) }
|
||||
}
|
||||
|
||||
fn find<P: CharEq>(&self, mut pat: P) -> Option<usize> {
|
||||
if pat.only_ascii() {
|
||||
self.bytes().position(|b| pat.matches(b as char))
|
||||
} else {
|
||||
for (index, c) in self.char_indices() {
|
||||
if pat.matches(c) { return Some(index); }
|
||||
}
|
||||
None
|
||||
}
|
||||
fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {
|
||||
pat.into_searcher(self).next_match().map(|(i, _)| i)
|
||||
}
|
||||
|
||||
fn rfind<P: CharEq>(&self, mut pat: P) -> Option<usize> {
|
||||
if pat.only_ascii() {
|
||||
self.bytes().rposition(|b| pat.matches(b as char))
|
||||
} else {
|
||||
for (index, c) in self.char_indices().rev() {
|
||||
if pat.matches(c) { return Some(index); }
|
||||
}
|
||||
None
|
||||
}
|
||||
fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
|
||||
where P::Searcher: ReverseSearcher<'a>
|
||||
{
|
||||
pat.into_searcher(self).next_match_back().map(|(i, _)| i)
|
||||
}
|
||||
|
||||
fn find_str(&self, needle: &str) -> Option<usize> {
|
||||
if needle.is_empty() {
|
||||
Some(0)
|
||||
} else {
|
||||
self.match_indices(needle)
|
||||
.next()
|
||||
.map(|(start, _end)| start)
|
||||
}
|
||||
fn find_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {
|
||||
self.find(pat)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
||||
495
src/libcore/str/pattern.rs
Normal file
495
src/libcore/str/pattern.rs
Normal file
@@ -0,0 +1,495 @@
|
||||
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
#![allow(deprecated) /* for CharEq */ ]
|
||||
|
||||
use prelude::*;
|
||||
use super::CharEq;
|
||||
|
||||
// Pattern
|
||||
|
||||
/// A string pattern.
|
||||
///
|
||||
/// A `Pattern<'a>` expresses that the implementing type
|
||||
/// can be used as a string pattern for searching in a `&'a str`.
|
||||
///
|
||||
/// For example, both `'a'` and `"aa"` are patterns that
|
||||
/// would match at index `1` in the string `"baaaab"`.
|
||||
///
|
||||
/// The trait itself acts as a builder for an associated
|
||||
/// `Searcher` type, which does the actual work of finding
|
||||
/// occurences of the pattern in a string.
|
||||
pub trait Pattern<'a>: Sized {
|
||||
/// Associated searcher for this pattern
|
||||
type Searcher: Searcher<'a>;
|
||||
|
||||
/// Construct the associated searcher from
|
||||
/// `self` and the `haystack` to search in.
|
||||
fn into_searcher(self, haystack: &'a str) -> Self::Searcher;
|
||||
|
||||
/// Check whether the pattern matches anywhere in the haystack
|
||||
#[inline]
|
||||
fn is_contained_in(self, haystack: &'a str) -> bool {
|
||||
self.into_searcher(haystack).next_match().is_some()
|
||||
}
|
||||
|
||||
/// Check whether the pattern matches at the front of the haystack
|
||||
#[inline]
|
||||
fn is_prefix_of(self, haystack: &'a str) -> bool {
|
||||
match self.into_searcher(haystack).next() {
|
||||
SearchStep::Match(0, _) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Check whether the pattern matches at the back of the haystack
|
||||
#[inline]
|
||||
fn is_suffix_of(self, haystack: &'a str) -> bool
|
||||
where Self::Searcher: ReverseSearcher<'a>
|
||||
{
|
||||
match self.into_searcher(haystack).next_back() {
|
||||
SearchStep::Match(_, j) if haystack.len() == j => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Searcher
|
||||
|
||||
/// Result of calling `Searcher::next()` or `ReverseSearcher::next_back()`.
|
||||
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
||||
pub enum SearchStep {
|
||||
/// Expresses that a match of the pattern has been found at
|
||||
/// `haystack[a..b]`.
|
||||
Match(usize, usize),
|
||||
/// Expresses that `haystack[a..b]` has been rejected as a possible match
|
||||
/// of the pattern.
|
||||
///
|
||||
/// Note that there might be more than one `Reject` betwen two `Match`es,
|
||||
/// there is no requirement for them to be combined into one.
|
||||
Reject(usize, usize),
|
||||
/// Expresses that every byte of the haystack has been visted, ending
|
||||
/// the iteration.
|
||||
Done
|
||||
}
|
||||
|
||||
/// A searcher for a string pattern.
|
||||
///
|
||||
/// This trait provides methods for searching for non-overlapping
|
||||
/// matches of a pattern starting from the front (left) of a string.
|
||||
///
|
||||
/// It will be implemented by associated `Searcher`
|
||||
/// types of the `Pattern` trait.
|
||||
///
|
||||
/// The trait is marked unsafe because the indices returned by the
|
||||
/// `next()` methods are required to lie on valid utf8 boundaries in
|
||||
/// the haystack. This enables consumers of this trait to
|
||||
/// slice the haystack without additional runtime checks.
|
||||
pub unsafe trait Searcher<'a> {
|
||||
/// Getter for the underlaying string to be searched in
|
||||
///
|
||||
/// Will always return the same `&str`
|
||||
fn haystack(&self) -> &'a str;
|
||||
|
||||
/// Performs the next search step starting from the front.
|
||||
///
|
||||
/// - Returns `Match(a, b)` if `haystack[a..b]` matches the pattern.
|
||||
/// - Returns `Reject(a, b)` if `haystack[a..b]` can not match the
|
||||
/// pattern, even partially.
|
||||
/// - Returns `Done` if every byte of the haystack has been visited
|
||||
///
|
||||
/// The stream of `Match` and `Reject` values up to a `Done`
|
||||
/// will contain index ranges that are adjacent, non-overlapping,
|
||||
/// covering the whole haystack, and laying on utf8 boundaries.
|
||||
///
|
||||
/// A `Match` result needs to contain the whole matched pattern,
|
||||
/// however `Reject` results may be split up into arbitrary
|
||||
/// many adjacent fragments. Both ranges may have zero length.
|
||||
///
|
||||
/// As an example, the pattern `"aaa"` and the haystack `"cbaaaaab"`
|
||||
/// might produce the stream
|
||||
/// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`
|
||||
fn next(&mut self) -> SearchStep;
|
||||
|
||||
/// Find the next `Match` result. See `next()`
|
||||
#[inline]
|
||||
fn next_match(&mut self) -> Option<(usize, usize)> {
|
||||
loop {
|
||||
match self.next() {
|
||||
SearchStep::Match(a, b) => return Some((a, b)),
|
||||
SearchStep::Done => return None,
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the next `Reject` result. See `next()`
|
||||
#[inline]
|
||||
fn next_reject(&mut self) -> Option<(usize, usize)> {
|
||||
loop {
|
||||
match self.next() {
|
||||
SearchStep::Reject(a, b) => return Some((a, b)),
|
||||
SearchStep::Done => return None,
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A reverse searcher for a string pattern.
|
||||
///
|
||||
/// This trait provides methods for searching for non-overlapping
|
||||
/// matches of a pattern starting from the back (right) of a string.
|
||||
///
|
||||
/// It will be implemented by associated `Searcher`
|
||||
/// types of the `Pattern` trait if the pattern supports searching
|
||||
/// for it from the back.
|
||||
///
|
||||
/// The index ranges returned by this trait are not required
|
||||
/// to exactly match those of the forward search in reverse.
|
||||
///
|
||||
/// For the reason why this trait is marked unsafe, see them
|
||||
/// parent trait `Searcher`.
|
||||
pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
|
||||
/// Performs the next search step starting from the back.
|
||||
///
|
||||
/// - Returns `Match(a, b)` if `haystack[a..b]` matches the pattern.
|
||||
/// - Returns `Reject(a, b)` if `haystack[a..b]` can not match the
|
||||
/// pattern, even partially.
|
||||
/// - Returns `Done` if every byte of the haystack has been visited
|
||||
///
|
||||
/// The stream of `Match` and `Reject` values up to a `Done`
|
||||
/// will contain index ranges that are adjacent, non-overlapping,
|
||||
/// covering the whole haystack, and laying on utf8 boundaries.
|
||||
///
|
||||
/// A `Match` result needs to contain the whole matched pattern,
|
||||
/// however `Reject` results may be split up into arbitrary
|
||||
/// many adjacent fragments. Both ranges may have zero length.
|
||||
///
|
||||
/// As an example, the pattern `"aaa"` and the haystack `"cbaaaaab"`
|
||||
/// might produce the stream
|
||||
/// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`
|
||||
fn next_back(&mut self) -> SearchStep;
|
||||
|
||||
/// Find the next `Match` result. See `next_back()`
|
||||
#[inline]
|
||||
fn next_match_back(&mut self) -> Option<(usize, usize)>{
|
||||
loop {
|
||||
match self.next_back() {
|
||||
SearchStep::Match(a, b) => return Some((a, b)),
|
||||
SearchStep::Done => return None,
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the next `Reject` result. See `next_back()`
|
||||
#[inline]
|
||||
fn next_reject_back(&mut self) -> Option<(usize, usize)>{
|
||||
loop {
|
||||
match self.next_back() {
|
||||
SearchStep::Reject(a, b) => return Some((a, b)),
|
||||
SearchStep::Done => return None,
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A marker trait to express that a `ReverseSearcher`
|
||||
/// can be used for a `DoubleEndedIterator` implementation.
|
||||
///
|
||||
/// For this, the impl of `Searcher` and `ReverseSearcher` need
|
||||
/// to follow these conditions:
|
||||
///
|
||||
/// - All results of `next()` need to be identical
|
||||
/// to the results of `next_back()` in reverse order.
|
||||
/// - `next()` and `next_back()` need to behave as
|
||||
/// the two ends of a range of values, that is they
|
||||
/// can not "walk past each other".
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// `char::Searcher` is a `DoubleEndedSearcher` because searching for a
|
||||
/// `char` only requires looking at one at a time, which behaves the same
|
||||
/// from both ends.
|
||||
///
|
||||
/// `(&str)::Searcher` is not a `DoubleEndedSearcher` because
|
||||
/// the pattern `"aa"` in the haystack `"aaa"` matches as either
|
||||
/// `"[aa]a"` or `"a[aa]"`, depending from which side it is searched.
|
||||
pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {}
|
||||
|
||||
// Impl for a CharEq wrapper
|
||||
|
||||
struct CharEqPattern<C: CharEq>(C);
|
||||
|
||||
struct CharEqSearcher<'a, C: CharEq> {
|
||||
char_eq: C,
|
||||
haystack: &'a str,
|
||||
char_indices: super::CharIndices<'a>,
|
||||
#[allow(dead_code)]
|
||||
ascii_only: bool,
|
||||
}
|
||||
|
||||
impl<'a, C: CharEq> Pattern<'a> for CharEqPattern<C> {
|
||||
type Searcher = CharEqSearcher<'a, C>;
|
||||
|
||||
#[inline]
|
||||
fn into_searcher(self, haystack: &'a str) -> CharEqSearcher<'a, C> {
|
||||
CharEqSearcher {
|
||||
ascii_only: self.0.only_ascii(),
|
||||
haystack: haystack,
|
||||
char_eq: self.0,
|
||||
char_indices: haystack.char_indices(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'a, C: CharEq> Searcher<'a> for CharEqSearcher<'a, C> {
|
||||
#[inline]
|
||||
fn haystack(&self) -> &'a str {
|
||||
self.haystack
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> SearchStep {
|
||||
let s = &mut self.char_indices;
|
||||
// Compare lengths of the internal byte slice iterator
|
||||
// to find length of current char
|
||||
let (pre_len, _) = s.iter.iter.size_hint();
|
||||
if let Some((i, c)) = s.next() {
|
||||
let (len, _) = s.iter.iter.size_hint();
|
||||
let char_len = pre_len - len;
|
||||
if self.char_eq.matches(c) {
|
||||
return SearchStep::Match(i, i + char_len);
|
||||
} else {
|
||||
return SearchStep::Reject(i, i + char_len);
|
||||
}
|
||||
}
|
||||
SearchStep::Done
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'a, C: CharEq> ReverseSearcher<'a> for CharEqSearcher<'a, C> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> SearchStep {
|
||||
let s = &mut self.char_indices;
|
||||
// Compare lengths of the internal byte slice iterator
|
||||
// to find length of current char
|
||||
let (pre_len, _) = s.iter.iter.size_hint();
|
||||
if let Some((i, c)) = s.next_back() {
|
||||
let (len, _) = s.iter.iter.size_hint();
|
||||
let char_len = pre_len - len;
|
||||
if self.char_eq.matches(c) {
|
||||
return SearchStep::Match(i, i + char_len);
|
||||
} else {
|
||||
return SearchStep::Reject(i, i + char_len);
|
||||
}
|
||||
}
|
||||
SearchStep::Done
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, C: CharEq> DoubleEndedSearcher<'a> for CharEqSearcher<'a, C> {}
|
||||
|
||||
// Impl for &str
|
||||
|
||||
// Todo: Optimize the naive implementation here
|
||||
|
||||
#[derive(Clone)]
|
||||
struct StrSearcher<'a, 'b> {
|
||||
haystack: &'a str,
|
||||
needle: &'b str,
|
||||
start: usize,
|
||||
end: usize,
|
||||
done: bool,
|
||||
}
|
||||
|
||||
/// Non-allocating substring search.
|
||||
///
|
||||
/// Will handle the pattern `""` as returning empty matches at each utf8
|
||||
/// boundary.
|
||||
impl<'a, 'b> Pattern<'a> for &'b str {
|
||||
type Searcher = StrSearcher<'a, 'b>;
|
||||
|
||||
#[inline]
|
||||
fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b> {
|
||||
StrSearcher {
|
||||
haystack: haystack,
|
||||
needle: self,
|
||||
start: 0,
|
||||
end: haystack.len(),
|
||||
done: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {
|
||||
#[inline]
|
||||
fn haystack(&self) -> &'a str {
|
||||
self.haystack
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> SearchStep {
|
||||
str_search_step(self,
|
||||
|m: &mut StrSearcher| {
|
||||
// Forward step for empty needle
|
||||
let current_start = m.start;
|
||||
if !m.done {
|
||||
m.start = m.haystack.char_range_at(current_start).next;
|
||||
}
|
||||
SearchStep::Match(current_start, current_start)
|
||||
},
|
||||
|m: &mut StrSearcher| {
|
||||
// Forward step for nonempty needle
|
||||
let current_start = m.start;
|
||||
// Compare byte window because this might break utf8 boundaries
|
||||
let possible_match = &m.haystack.as_bytes()[m.start .. m.start + m.needle.len()];
|
||||
if possible_match == m.needle.as_bytes() {
|
||||
m.start += m.needle.len();
|
||||
SearchStep::Match(current_start, m.start)
|
||||
} else {
|
||||
// Skip a char
|
||||
let haystack_suffix = &m.haystack[m.start..];
|
||||
m.start += haystack_suffix.chars().next().unwrap().len_utf8();
|
||||
SearchStep::Reject(current_start, m.start)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> SearchStep {
|
||||
str_search_step(self,
|
||||
|m: &mut StrSearcher| {
|
||||
// Backward step for empty needle
|
||||
let current_end = m.end;
|
||||
if !m.done {
|
||||
m.end = m.haystack.char_range_at_reverse(current_end).next;
|
||||
}
|
||||
SearchStep::Match(current_end, current_end)
|
||||
},
|
||||
|m: &mut StrSearcher| {
|
||||
// Backward step for nonempty needle
|
||||
let current_end = m.end;
|
||||
// Compare byte window because this might break utf8 boundaries
|
||||
let possible_match = &m.haystack.as_bytes()[m.end - m.needle.len() .. m.end];
|
||||
if possible_match == m.needle.as_bytes() {
|
||||
m.end -= m.needle.len();
|
||||
SearchStep::Match(m.end, current_end)
|
||||
} else {
|
||||
// Skip a char
|
||||
let haystack_prefix = &m.haystack[..m.end];
|
||||
m.end -= haystack_prefix.chars().rev().next().unwrap().len_utf8();
|
||||
SearchStep::Reject(m.end, current_end)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function for encapsulating the common control flow
|
||||
// of doing a search step from the front or doing a search step from the back
|
||||
fn str_search_step<F, G>(mut m: &mut StrSearcher,
|
||||
empty_needle_step: F,
|
||||
nonempty_needle_step: G) -> SearchStep
|
||||
where F: FnOnce(&mut StrSearcher) -> SearchStep,
|
||||
G: FnOnce(&mut StrSearcher) -> SearchStep
|
||||
{
|
||||
if m.done {
|
||||
SearchStep::Done
|
||||
} else if m.needle.len() == 0 && m.start <= m.end {
|
||||
// Case for needle == ""
|
||||
if m.start == m.end {
|
||||
m.done = true;
|
||||
}
|
||||
empty_needle_step(&mut m)
|
||||
} else if m.start + m.needle.len() <= m.end {
|
||||
// Case for needle != ""
|
||||
nonempty_needle_step(&mut m)
|
||||
} else if m.start < m.end {
|
||||
// Remaining slice shorter than needle, reject it
|
||||
m.done = true;
|
||||
SearchStep::Reject(m.start, m.end)
|
||||
} else {
|
||||
m.done = true;
|
||||
SearchStep::Done
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! associated_items {
|
||||
($t:ty, $s:ident, $e:expr) => {
|
||||
// FIXME: #22463
|
||||
//type Searcher = $t;
|
||||
|
||||
fn into_searcher(self, haystack: &'a str) -> $t {
|
||||
let $s = self;
|
||||
$e.into_searcher(haystack)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_contained_in(self, haystack: &'a str) -> bool {
|
||||
let $s = self;
|
||||
$e.is_contained_in(haystack)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_prefix_of(self, haystack: &'a str) -> bool {
|
||||
let $s = self;
|
||||
$e.is_prefix_of(haystack)
|
||||
}
|
||||
|
||||
// FIXME: #21750
|
||||
/*#[inline]
|
||||
fn is_suffix_of(self, haystack: &'a str) -> bool
|
||||
where $t: ReverseSearcher<'a>
|
||||
{
|
||||
let $s = self;
|
||||
$e.is_suffix_of(haystack)
|
||||
}*/
|
||||
}
|
||||
}
|
||||
|
||||
// CharEq delegation impls
|
||||
|
||||
/// Searches for chars that are equal to a given char
|
||||
impl<'a> Pattern<'a> for char {
|
||||
type Searcher = <CharEqPattern<Self> as Pattern<'a>>::Searcher;
|
||||
associated_items!(<CharEqPattern<Self> as Pattern<'a>>::Searcher,
|
||||
s, CharEqPattern(s));
|
||||
}
|
||||
|
||||
/// Searches for chars that are equal to any of the chars in the array
|
||||
impl<'a, 'b> Pattern<'a> for &'b [char] {
|
||||
type Searcher = <CharEqPattern<Self> as Pattern<'a>>::Searcher;
|
||||
associated_items!(<CharEqPattern<Self> as Pattern<'a>>::Searcher,
|
||||
s, CharEqPattern(s));
|
||||
}
|
||||
|
||||
/// Searches for chars that match the given predicate
|
||||
impl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool {
|
||||
type Searcher = <CharEqPattern<Self> as Pattern<'a>>::Searcher;
|
||||
associated_items!(<CharEqPattern<Self> as Pattern<'a>>::Searcher,
|
||||
s, CharEqPattern(s));
|
||||
}
|
||||
|
||||
// Deref-forward impl
|
||||
|
||||
use ops::Deref;
|
||||
|
||||
/// Delegates to the next deref coercion of `Self` that implements `Pattern`
|
||||
impl<'a, 'b, P: 'b + ?Sized, T: Deref<Target = P> + ?Sized> Pattern<'a> for &'b T
|
||||
where &'b P: Pattern<'a>
|
||||
{
|
||||
type Searcher = <&'b P as Pattern<'a>>::Searcher;
|
||||
associated_items!(<&'b P as Pattern<'a>>::Searcher,
|
||||
s, (&**s));
|
||||
}
|
||||
Reference in New Issue
Block a user