pattern-3 0.5.0

Needle API (née Pattern API 3.0), generalization of `std::str::pattern`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use needle::*;
use haystack::{Haystack, Span};
use memchr::{memchr, memrchr};
use std::ops::Range;

#[derive(Debug, Clone)]
pub struct CharSearcher {
    // safety invariant: `utf8_size` must be less than 5
    utf8_size: usize,

    /// A utf8 encoded copy of the `needle`
    utf8_encoded: [u8; 4],

    /// The character currently being searched.
    c: char,
}

impl CharSearcher {
    #[inline]
    fn as_bytes(&self) -> &[u8] {
        &self.utf8_encoded[..self.utf8_size]
    }

    #[inline]
    fn last_byte(&self) -> u8 {
        self.utf8_encoded[self.utf8_size - 1]
    }

    #[inline]
    fn new(c: char) -> Self {
        let mut utf8_encoded = [0u8; 4];
        let utf8_size = c.encode_utf8(&mut utf8_encoded).len();
        CharSearcher {
            utf8_size,
            utf8_encoded,
            c,
        }
    }
}

unsafe impl Searcher<str> for CharSearcher {
    #[inline]
    fn search(&mut self, span: Span<&str>) -> Option<Range<usize>> {
        let (hay, range) = span.into_parts();
        let mut finger = range.start;
        let bytes = hay.as_bytes();
        loop {
            let index = memchr(self.last_byte(), &bytes[finger..range.end])?;
            finger += index + 1;
            if finger >= self.utf8_size {
                let found = &bytes[(finger - self.utf8_size)..finger];
                if found == self.as_bytes() {
                    return Some((finger - self.utf8_size)..finger);
                }
            }
        }
    }
}

unsafe impl Consumer<str> for CharSearcher {
    #[inline]
    fn consume(&mut self, span: Span<&str>) -> Option<usize> {
        let mut consumer = Needle::<&[u8]>::into_consumer(self.as_bytes());
        consumer.consume(span.as_bytes())
    }

    #[inline]
    fn trim_start(&mut self, hay: &str) -> usize {
        let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
        consumer.trim_start(hay)
    }
}

unsafe impl ReverseSearcher<str> for CharSearcher {
    #[inline]
    fn rsearch(&mut self, span: Span<&str>) -> Option<Range<usize>> {
        let (hay, range) = span.into_parts();
        let start = range.start;
        let mut bytes = hay[range].as_bytes();
        loop {
            let index = memrchr(self.last_byte(), bytes)? + 1;
            if index >= self.utf8_size {
                let found = &bytes[(index - self.utf8_size)..index];
                if found == self.as_bytes() {
                    let index = index + start;
                    return Some((index - self.utf8_size)..index);
                }
            }
            bytes = &bytes[..(index - 1)];
        }
    }
}

unsafe impl ReverseConsumer<str> for CharSearcher {
    #[inline]
    fn rconsume(&mut self, span: Span<&str>) -> Option<usize> {
        if self.utf8_size == 1 {
            let mut consumer = Needle::<&[u8]>::into_consumer(|b: &u8| *b == self.c as u8);
            consumer.rconsume(span.as_bytes())
        } else {
            let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
            consumer.rconsume(span)
        }
    }

    #[inline]
    fn trim_end(&mut self, haystack: &str) -> usize {
        let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
        consumer.trim_end(haystack)
    }
}

unsafe impl DoubleEndedSearcher<str> for CharSearcher {}
unsafe impl DoubleEndedConsumer<str> for CharSearcher {}

impl<H: Haystack<Target = str>> Needle<H> for char {
    type Searcher = CharSearcher;
    type Consumer = CharSearcher;

    #[inline]
    fn into_searcher(self) -> Self::Searcher {
        CharSearcher::new(self)
    }

    #[inline]
    fn into_consumer(self) -> Self::Consumer {
        CharSearcher::new(self)
    }
}