java_string/
iter.rs

Help
1use std::fmt::{Debug, Display, Formatter, Write};
2use std::iter::{Chain, Copied, Filter, FlatMap, Flatten, FusedIterator, Map};
3use std::{option, slice};
4
5use crate::validations::{next_code_point, next_code_point_reverse};
6use crate::{CharEscapeIter, JavaCodePoint, JavaStr, JavaStrPattern};
7macro_rules! delegate {
8    (Iterator for $ty:ident $(<$($lt:lifetime),+>)? => $item:ty $(, DoubleEnded = $double_ended:ty)?) => {
9        impl$(<$($lt),+>)? Iterator for $ty$(<$($lt),+>)? {
10            type Item = $item;
11
12            #[inline]
13            fn next(&mut self) -> Option<Self::Item> {
14                self.inner.next()
15            }
16
17            #[inline]
18            fn size_hint(&self) -> (usize, Option<usize>) {
19                self.inner.size_hint()
20            }
21
22            #[inline]
23            fn count(self) -> usize {
24                self.inner.count()
25            }
26
27            #[inline]
28            fn last(self) -> Option<Self::Item> {
29                self.inner.last()
30            }
31
32            #[inline]
33            fn nth(&mut self, n: usize) -> Option<Self::Item> {
34                self.inner.nth(n)
35            }
36
37            #[inline]
38            fn all<F>(&mut self, f: F) -> bool
39            where
40                F: FnMut(Self::Item) -> bool,
41            {
42                self.inner.all(f)
43            }
44
45            #[inline]
46            fn any<F>(&mut self, f: F) -> bool
47            where
48                F: FnMut(Self::Item) -> bool,
49            {
50                self.inner.any(f)
51            }
52
53            #[inline]
54            fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
55            where
56                P: FnMut(&Self::Item) -> bool,
57            {
58                self.inner.find(predicate)
59            }
60
61            #[inline]
62            fn position<P>(&mut self, predicate: P) -> Option<usize>
63            where
64                P: FnMut(Self::Item) -> bool,
65            {
66                self.inner.position(predicate)
67            }
68
69            $(
70            #[inline]
71            fn rposition<P>(&mut self, predicate: P) -> Option<usize>
72            where
73                P: FnMut(Self::Item) -> bool,
74            {
75                let _test: $double_ended = ();
76                self.inner.rposition(predicate)
77            }
78            )?
79        }
80    };
81
82    (DoubleEndedIterator for $ty:ident $(<$($lt:lifetime),+>)?) => {
83        impl$(<$($lt),+>)? DoubleEndedIterator for $ty$(<$($lt),+>)? {
84            #[inline]
85            fn next_back(&mut self) -> Option<Self::Item> {
86                self.inner.next_back()
87            }
88
89            #[inline]
90            fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
91                self.inner.nth_back(n)
92            }
93
94            #[inline]
95            fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
96            where
97                P: FnMut(&Self::Item) -> bool,
98            {
99                self.inner.rfind(predicate)
100            }
101        }
102    };
103
104    (ExactSizeIterator for $ty:ident $(<$($lt:lifetime),+>)?) => {
105        impl$(<$($lt),+>)? ExactSizeIterator for $ty$(<$($lt),+>)? {
106            #[inline]
107            fn len(&self) -> usize {
108                self.inner.len()
109            }
110        }
111    };
112
113    (FusedIterator for $ty:ident $(<$($lt:lifetime),+>)?) => {
114        impl$(<$($lt),+>)? FusedIterator for $ty$(<$($lt),+>)? {}
115    };
116
117    (Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator for $ty:ident $(<$($lt:lifetime),+>)? => $item:ty) => {
118        delegate!(Iterator for $ty$(<$($lt),+>)? => $item, DoubleEnded = ());
119        delegate!(DoubleEndedIterator for $ty$(<$($lt),+>)?);
120        delegate!(ExactSizeIterator for $ty$(<$($lt),+>)?);
121        delegate!(FusedIterator for $ty$(<$($lt),+>)?);
122    };
123}
124
125#[must_use]
126#[derive(Clone, Debug)]
127pub struct Bytes<'a> {
128    pub(crate) inner: Copied<slice::Iter<'a, u8>>,
129}
130delegate!(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator for Bytes<'a> => u8);
131
132#[derive(Clone, Debug)]
133#[must_use]
134pub struct EscapeDebug<'a> {
135    #[allow(clippy::type_complexity)]
136    pub(crate) inner: Chain<
137        Flatten<option::IntoIter<CharEscapeIter>>,
138        FlatMap<Chars<'a>, CharEscapeIter, fn(JavaCodePoint) -> CharEscapeIter>,
139    >,
140}
141delegate!(Iterator for EscapeDebug<'a> => char);
142delegate!(FusedIterator for EscapeDebug<'a>);
143impl Display for EscapeDebug<'_> {
144    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
145        self.clone().try_for_each(|c| f.write_char(c))
146    }
147}
148
149#[derive(Clone, Debug)]
150#[must_use]
151pub struct EscapeDefault<'a> {
152    pub(crate) inner: FlatMap<Chars<'a>, CharEscapeIter, fn(JavaCodePoint) -> CharEscapeIter>,
153}
154delegate!(Iterator for EscapeDefault<'a> => char);
155delegate!(FusedIterator for EscapeDefault<'a>);
156impl Display for EscapeDefault<'_> {
157    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
158        self.clone().try_for_each(|c| f.write_char(c))
159    }
160}
161
162#[derive(Clone, Debug)]
163#[must_use]
164pub struct EscapeUnicode<'a> {
165    pub(crate) inner: FlatMap<Chars<'a>, CharEscapeIter, fn(JavaCodePoint) -> CharEscapeIter>,
166}
167delegate!(Iterator for EscapeUnicode<'a> => char);
168delegate!(FusedIterator for EscapeUnicode<'a>);
169impl Display for EscapeUnicode<'_> {
170    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
171        self.clone().try_for_each(|c| f.write_char(c))
172    }
173}
174
175#[derive(Clone, Debug)]
176#[must_use]
177pub struct Lines<'a> {
178    pub(crate) inner: Map<SplitInclusive<'a, char>, fn(&JavaStr) -> &JavaStr>,
179}
180delegate!(Iterator for Lines<'a> => &'a JavaStr);
181delegate!(DoubleEndedIterator for Lines<'a>);
182delegate!(FusedIterator for Lines<'a>);
183
184#[derive(Clone)]
185#[must_use]
186pub struct Chars<'a> {
187    pub(crate) inner: slice::Iter<'a, u8>,
188}
189
190impl Iterator for Chars<'_> {
191    type Item = JavaCodePoint;
192
193    #[inline]
194    fn next(&mut self) -> Option<Self::Item> {
195        // SAFETY: `JavaStr` invariant says `self.inner` is a semi-valid UTF-8 string
196        // and the resulting `ch` is a valid Unicode Scalar Value or surrogate
197        // code point.
198        unsafe { next_code_point(&mut self.inner).map(|ch| JavaCodePoint::from_u32_unchecked(ch)) }
199    }
200
201    // TODO: std has an optimized count impl
202
203    #[inline]
204    fn size_hint(&self) -> (usize, Option<usize>) {
205        let len = self.inner.len();
206        (len.div_ceil(4), Some(len))
207    }
208
209    #[inline]
210    fn last(mut self) -> Option<JavaCodePoint> {
211        // No need to go through the entire string.
212        self.next_back()
213    }
214}
215
216impl Debug for Chars<'_> {
217    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
218        write!(f, "Chars(")?;
219        f.debug_list().entries(self.clone()).finish()?;
220        write!(f, ")")?;
221        Ok(())
222    }
223}
224
225impl DoubleEndedIterator for Chars<'_> {
226    #[inline]
227    fn next_back(&mut self) -> Option<Self::Item> {
228        // SAFETY: `JavaStr` invariant says `self.inner` is a semi-valid UTF-8 string
229        // and the resulting `ch` is a valid Unicode Scalar Value or surrogate
230        // code point.
231        unsafe {
232            next_code_point_reverse(&mut self.inner).map(|ch| JavaCodePoint::from_u32_unchecked(ch))
233        }
234    }
235}
236
237impl FusedIterator for Chars<'_> {}
238
239impl<'a> Chars<'a> {
240    #[inline]
241    #[must_use]
242    pub fn as_str(&self) -> &'a JavaStr {
243        // SAFETY: `Chars` is only made from a JavaStr, which guarantees the iter is
244        // semi-valid UTF-8.
245        unsafe { JavaStr::from_semi_utf8_unchecked(self.inner.as_slice()) }
246    }
247}
248
249#[derive(Clone, Debug)]
250#[must_use]
251pub struct CharIndices<'a> {
252    pub(crate) front_offset: usize,
253    pub(crate) inner: Chars<'a>,
254}
255
256impl Iterator for CharIndices<'_> {
257    type Item = (usize, JavaCodePoint);
258
259    #[inline]
260    fn next(&mut self) -> Option<(usize, JavaCodePoint)> {
261        let pre_len = self.inner.inner.len();
262        match self.inner.next() {
263            None => None,
264            Some(ch) => {
265                let index = self.front_offset;
266                let len = self.inner.inner.len();
267                self.front_offset += pre_len - len;
268                Some((index, ch))
269            }
270        }
271    }
272
273    #[inline]
274    fn count(self) -> usize {
275        self.inner.count()
276    }
277
278    #[inline]
279    fn size_hint(&self) -> (usize, Option<usize>) {
280        self.inner.size_hint()
281    }
282
283    #[inline]
284    fn last(mut self) -> Option<(usize, JavaCodePoint)> {
285        // No need to go through the entire string.
286        self.next_back()
287    }
288}
289
290impl DoubleEndedIterator for CharIndices<'_> {
291    #[inline]
292    fn next_back(&mut self) -> Option<(usize, JavaCodePoint)> {
293        self.inner.next_back().map(|ch| {
294            let index = self.front_offset + self.inner.inner.len();
295            (index, ch)
296        })
297    }
298}
299
300impl FusedIterator for CharIndices<'_> {}
301
302impl<'a> CharIndices<'a> {
303    #[inline]
304    #[must_use]
305    pub fn as_str(&self) -> &'a JavaStr {
306        self.inner.as_str()
307    }
308}
309
310#[must_use]
311#[derive(Debug, Clone)]
312pub struct Matches<'a, P> {
313    pub(crate) str: &'a JavaStr,
314    pub(crate) pat: P,
315}
316
317impl<'a, P> Iterator for Matches<'a, P>
318where
319    P: JavaStrPattern,
320{
321    type Item = &'a JavaStr;
322
323    #[inline]
324    fn next(&mut self) -> Option<Self::Item> {
325        if let Some((index, len)) = self.pat.find_in(self.str) {
326            // SAFETY: pattern returns valid indices
327            let ret = unsafe { self.str.get_unchecked(index..index + len) };
328            self.str = unsafe { self.str.get_unchecked(index + len..) };
329            Some(ret)
330        } else {
331            self.str = Default::default();
332            None
333        }
334    }
335}
336
337impl<P> DoubleEndedIterator for Matches<'_, P>
338where
339    P: JavaStrPattern,
340{
341    #[inline]
342    fn next_back(&mut self) -> Option<Self::Item> {
343        if let Some((index, len)) = self.pat.rfind_in(self.str) {
344            // SAFETY: pattern returns valid indices
345            let ret = unsafe { self.str.get_unchecked(index..index + len) };
346            self.str = unsafe { self.str.get_unchecked(..index) };
347            Some(ret)
348        } else {
349            self.str = Default::default();
350            None
351        }
352    }
353}
354
355#[must_use]
356#[derive(Clone, Debug)]
357pub struct RMatches<'a, P> {
358    pub(crate) inner: Matches<'a, P>,
359}
360
361impl<'a, P> Iterator for RMatches<'a, P>
362where
363    P: JavaStrPattern,
364{
365    type Item = &'a JavaStr;
366
367    #[inline]
368    fn next(&mut self) -> Option<Self::Item> {
369        self.inner.next_back()
370    }
371}
372
373impl<P> DoubleEndedIterator for RMatches<'_, P>
374where
375    P: JavaStrPattern,
376{
377    #[inline]
378    fn next_back(&mut self) -> Option<Self::Item> {
379        self.inner.next()
380    }
381}
382
383#[must_use]
384#[derive(Clone, Debug)]
385pub struct MatchIndices<'a, P> {
386    pub(crate) str: &'a JavaStr,
387    pub(crate) start: usize,
388    pub(crate) pat: P,
389}
390
391impl<'a, P> Iterator for MatchIndices<'a, P>
392where
393    P: JavaStrPattern,
394{
395    type Item = (usize, &'a JavaStr);
396
397    #[inline]
398    fn next(&mut self) -> Option<Self::Item> {
399        if let Some((index, len)) = self.pat.find_in(self.str) {
400            let full_index = self.start + index;
401            self.start = full_index + len;
402            // SAFETY: pattern returns valid indices
403            let ret = unsafe { self.str.get_unchecked(index..index + len) };
404            self.str = unsafe { self.str.get_unchecked(index + len..) };
405            Some((full_index, ret))
406        } else {
407            self.start += self.str.len();
408            self.str = Default::default();
409            None
410        }
411    }
412}
413
414impl<P> DoubleEndedIterator for MatchIndices<'_, P>
415where
416    P: JavaStrPattern,
417{
418    #[inline]
419    fn next_back(&mut self) -> Option<Self::Item> {
420        if let Some((index, len)) = self.pat.rfind_in(self.str) {
421            // SAFETY: pattern returns valid indices
422            let ret = unsafe { self.str.get_unchecked(index..index + len) };
423            self.str = unsafe { self.str.get_unchecked(..index) };
424            Some((self.start + index, ret))
425        } else {
426            self.str = Default::default();
427            None
428        }
429    }
430}
431
432#[derive(Clone, Debug)]
433pub struct RMatchIndices<'a, P> {
434    pub(crate) inner: MatchIndices<'a, P>,
435}
436
437impl<'a, P> Iterator for RMatchIndices<'a, P>
438where
439    P: JavaStrPattern,
440{
441    type Item = (usize, &'a JavaStr);
442
443    #[inline]
444    fn next(&mut self) -> Option<Self::Item> {
445        self.inner.next_back()
446    }
447}
448
449impl<P> DoubleEndedIterator for RMatchIndices<'_, P>
450where
451    P: JavaStrPattern,
452{
453    #[inline]
454    fn next_back(&mut self) -> Option<Self::Item> {
455        self.inner.next()
456    }
457}
458
459#[derive(Clone, Debug)]
460struct SplitHelper<'a, P> {
461    start: usize,
462    end: usize,
463    haystack: &'a JavaStr,
464    pat: P,
465    allow_trailing_empty: bool,
466    finished: bool,
467    had_empty_match: bool,
468}
469
470impl<'a, P> SplitHelper<'a, P>
471where
472    P: JavaStrPattern,
473{
474    #[inline]
475    fn new(haystack: &'a JavaStr, pat: P, allow_trailing_empty: bool) -> Self {
476        Self {
477            start: 0,
478            end: haystack.len(),
479            haystack,
480            pat,
481            allow_trailing_empty,
482            finished: false,
483            had_empty_match: false,
484        }
485    }
486
487    #[inline]
488    fn get_end(&mut self) -> Option<&'a JavaStr> {
489        if !self.finished {
490            self.finished = true;
491
492            if self.allow_trailing_empty || self.end - self.start > 0 {
493                // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
494                let string = unsafe { self.haystack.get_unchecked(self.start..self.end) };
495                return Some(string);
496            }
497        }
498
499        None
500    }
501
502    #[inline]
503    fn next_match(&mut self) -> Option<(usize, usize)> {
504        // SAFETY: `self.start` always lies on a unicode boundary.
505        let substr = unsafe { self.haystack.get_unchecked(self.start..) };
506
507        let result = if self.had_empty_match {
508            // if we had an empty match before, we are going to find the empty match again.
509            // don't do that, search from the next index along.
510
511            if substr.is_empty() {
512                None
513            } else {
514                // SAFETY: we can pop the string because we already checked if the string is
515                // empty above
516                let first_char_len = unsafe { substr.chars().next().unwrap_unchecked().len_utf8() };
517                let popped_str = unsafe { substr.get_unchecked(first_char_len..) };
518
519                self.pat
520                    .find_in(popped_str)
521                    .map(|(index, len)| (index + first_char_len + self.start, len))
522            }
523        } else {
524            self.pat
525                .find_in(substr)
526                .map(|(index, len)| (index + self.start, len))
527        };
528
529        self.had_empty_match = result.is_some_and(|(_, len)| len == 0);
530
531        result
532    }
533
534    #[inline]
535    fn next(&mut self) -> Option<&'a JavaStr> {
536        if self.finished {
537            return None;
538        }
539
540        match self.next_match() {
541            Some((index, len)) => unsafe {
542                // SAFETY: pattern guarantees valid indices
543                let elt = self.haystack.get_unchecked(self.start..index);
544                self.start = index + len;
545                Some(elt)
546            },
547            None => self.get_end(),
548        }
549    }
550
551    #[inline]
552    fn next_inclusive(&mut self) -> Option<&'a JavaStr> {
553        if self.finished {
554            return None;
555        }
556
557        match self.next_match() {
558            Some((index, len)) => unsafe {
559                // SAFETY: pattern guarantees valid indices
560                let elt = self.haystack.get_unchecked(self.start..index + len);
561                self.start = index + len;
562                Some(elt)
563            },
564            None => self.get_end(),
565        }
566    }
567
568    #[inline]
569    fn next_match_back(&mut self) -> Option<(usize, usize)> {
570        // SAFETY: `self.end` always lies on a unicode boundary.
571        let substr = unsafe { self.haystack.get_unchecked(..self.end) };
572
573        let result = if self.had_empty_match {
574            // if we had an empty match before, we are going to find the empty match again.
575            // don't do that, search from the next index along.
576
577            if substr.is_empty() {
578                None
579            } else {
580                // SAFETY: we can pop the string because we already checked if the string is
581                // empty above
582                let last_char_len =
583                    unsafe { substr.chars().next_back().unwrap_unchecked().len_utf8() };
584                let popped_str = unsafe { substr.get_unchecked(..substr.len() - last_char_len) };
585
586                self.pat.rfind_in(popped_str)
587            }
588        } else {
589            self.pat.rfind_in(substr)
590        };
591
592        self.had_empty_match = result.is_some_and(|(_, len)| len == 0);
593
594        result
595    }
596
597    #[inline]
598    fn next_back(&mut self) -> Option<&'a JavaStr> {
599        if self.finished {
600            return None;
601        }
602
603        if !self.allow_trailing_empty {
604            self.allow_trailing_empty = true;
605            match self.next_back() {
606                Some(elt) if !elt.is_empty() => return Some(elt),
607                _ => {
608                    if self.finished {
609                        return None;
610                    }
611                }
612            }
613        }
614
615        match self.next_match_back() {
616            Some((index, len)) => unsafe {
617                // SAFETY: pattern guarantees valid indices
618                let elt = self.haystack.get_unchecked(index + len..self.end);
619                self.end = index;
620                Some(elt)
621            },
622            None => unsafe {
623                // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
624                self.finished = true;
625                Some(self.haystack.get_unchecked(self.start..self.end))
626            },
627        }
628    }
629
630    #[inline]
631    fn next_back_inclusive(&mut self) -> Option<&'a JavaStr> {
632        if self.finished {
633            return None;
634        }
635
636        if !self.allow_trailing_empty {
637            self.allow_trailing_empty = true;
638            match self.next_back_inclusive() {
639                Some(elt) if !elt.is_empty() => return Some(elt),
640                _ => {
641                    if self.finished {
642                        return None;
643                    }
644                }
645            }
646        }
647
648        match self.next_match_back() {
649            Some((index, len)) => {
650                // SAFETY: pattern guarantees valid indices
651                let elt = unsafe { self.haystack.get_unchecked(index + len..self.end) };
652                self.end = index + len;
653                Some(elt)
654            }
655            None => {
656                self.finished = true;
657                // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
658                Some(unsafe { self.haystack.get_unchecked(self.start..self.end) })
659            }
660        }
661    }
662}
663
664#[derive(Clone, Debug)]
665pub struct Split<'a, P> {
666    inner: SplitHelper<'a, P>,
667}
668
669impl<'a, P> Split<'a, P>
670where
671    P: JavaStrPattern,
672{
673    #[inline]
674    pub(crate) fn new(haystack: &'a JavaStr, pat: P) -> Self {
675        Split {
676            inner: SplitHelper::new(haystack, pat, true),
677        }
678    }
679}
680
681impl<'a, P> Iterator for Split<'a, P>
682where
683    P: JavaStrPattern,
684{
685    type Item = &'a JavaStr;
686
687    #[inline]
688    fn next(&mut self) -> Option<Self::Item> {
689        self.inner.next()
690    }
691}
692
693impl<P> DoubleEndedIterator for Split<'_, P>
694where
695    P: JavaStrPattern,
696{
697    #[inline]
698    fn next_back(&mut self) -> Option<Self::Item> {
699        self.inner.next_back()
700    }
701}
702
703impl<P> FusedIterator for Split<'_, P> where P: JavaStrPattern {}
704
705#[derive(Clone, Debug)]
706pub struct RSplit<'a, P> {
707    inner: SplitHelper<'a, P>,
708}
709
710impl<'a, P> RSplit<'a, P>
711where
712    P: JavaStrPattern,
713{
714    #[inline]
715    pub(crate) fn new(haystack: &'a JavaStr, pat: P) -> Self {
716        RSplit {
717            inner: SplitHelper::new(haystack, pat, true),
718        }
719    }
720}
721
722impl<'a, P> Iterator for RSplit<'a, P>
723where
724    P: JavaStrPattern,
725{
726    type Item = &'a JavaStr;
727
728    #[inline]
729    fn next(&mut self) -> Option<Self::Item> {
730        self.inner.next_back()
731    }
732}
733
734impl<P> DoubleEndedIterator for RSplit<'_, P>
735where
736    P: JavaStrPattern,
737{
738    #[inline]
739    fn next_back(&mut self) -> Option<Self::Item> {
740        self.inner.next()
741    }
742}
743
744impl<P> FusedIterator for RSplit<'_, P> where P: JavaStrPattern {}
745
746#[derive(Clone, Debug)]
747pub struct SplitTerminator<'a, P> {
748    inner: SplitHelper<'a, P>,
749}
750
751impl<'a, P> SplitTerminator<'a, P>
752where
753    P: JavaStrPattern,
754{
755    #[inline]
756    pub(crate) fn new(haystack: &'a JavaStr, pat: P) -> Self {
757        SplitTerminator {
758            inner: SplitHelper::new(haystack, pat, false),
759        }
760    }
761}
762
763impl<'a, P> Iterator for SplitTerminator<'a, P>
764where
765    P: JavaStrPattern,
766{
767    type Item = &'a JavaStr;
768
769    #[inline]
770    fn next(&mut self) -> Option<Self::Item> {
771        self.inner.next()
772    }
773}
774
775impl<P> DoubleEndedIterator for SplitTerminator<'_, P>
776where
777    P: JavaStrPattern,
778{
779    #[inline]
780    fn next_back(&mut self) -> Option<Self::Item> {
781        self.inner.next_back()
782    }
783}
784
785impl<P> FusedIterator for SplitTerminator<'_, P> where P: JavaStrPattern {}
786
787#[derive(Clone, Debug)]
788pub struct RSplitTerminator<'a, P> {
789    inner: SplitHelper<'a, P>,
790}
791
792impl<'a, P> RSplitTerminator<'a, P>
793where
794    P: JavaStrPattern,
795{
796    #[inline]
797    pub(crate) fn new(haystack: &'a JavaStr, pat: P) -> Self {
798        RSplitTerminator {
799            inner: SplitHelper::new(haystack, pat, false),
800        }
801    }
802}
803
804impl<'a, P> Iterator for RSplitTerminator<'a, P>
805where
806    P: JavaStrPattern,
807{
808    type Item = &'a JavaStr;
809
810    #[inline]
811    fn next(&mut self) -> Option<Self::Item> {
812        self.inner.next_back()
813    }
814}
815
816impl<P> DoubleEndedIterator for RSplitTerminator<'_, P>
817where
818    P: JavaStrPattern,
819{
820    #[inline]
821    fn next_back(&mut self) -> Option<Self::Item> {
822        self.inner.next()
823    }
824}
825
826impl<P> FusedIterator for RSplitTerminator<'_, P> where P: JavaStrPattern {}
827
828#[derive(Clone, Debug)]
829pub struct SplitInclusive<'a, P> {
830    inner: SplitHelper<'a, P>,
831}
832
833impl<'a, P> SplitInclusive<'a, P>
834where
835    P: JavaStrPattern,
836{
837    #[inline]
838    pub(crate) fn new(haystack: &'a JavaStr, pat: P) -> Self {
839        SplitInclusive {
840            inner: SplitHelper::new(haystack, pat, false),
841        }
842    }
843}
844
845impl<'a, P> Iterator for SplitInclusive<'a, P>
846where
847    P: JavaStrPattern,
848{
849    type Item = &'a JavaStr;
850
851    #[inline]
852    fn next(&mut self) -> Option<Self::Item> {
853        self.inner.next_inclusive()
854    }
855}
856
857impl<P> DoubleEndedIterator for SplitInclusive<'_, P>
858where
859    P: JavaStrPattern,
860{
861    #[inline]
862    fn next_back(&mut self) -> Option<Self::Item> {
863        self.inner.next_back_inclusive()
864    }
865}
866
867impl<P> FusedIterator for SplitInclusive<'_, P> where P: JavaStrPattern {}
868
869#[derive(Clone, Debug)]
870pub struct SplitN<'a, P> {
871    inner: SplitHelper<'a, P>,
872    count: usize,
873}
874
875impl<'a, P> SplitN<'a, P>
876where
877    P: JavaStrPattern,
878{
879    #[inline]
880    pub(crate) fn new(haystack: &'a JavaStr, pat: P, count: usize) -> Self {
881        SplitN {
882            inner: SplitHelper::new(haystack, pat, true),
883            count,
884        }
885    }
886}
887
888impl<'a, P> Iterator for SplitN<'a, P>
889where
890    P: JavaStrPattern,
891{
892    type Item = &'a JavaStr;
893
894    #[inline]
895    fn next(&mut self) -> Option<Self::Item> {
896        match self.count {
897            0 => None,
898            1 => {
899                self.count = 0;
900                self.inner.get_end()
901            }
902            _ => {
903                self.count -= 1;
904                self.inner.next()
905            }
906        }
907    }
908}
909
910impl<P> FusedIterator for SplitN<'_, P> where P: JavaStrPattern {}
911
912#[derive(Clone, Debug)]
913pub struct RSplitN<'a, P> {
914    inner: SplitHelper<'a, P>,
915    count: usize,
916}
917
918impl<'a, P> RSplitN<'a, P>
919where
920    P: JavaStrPattern,
921{
922    #[inline]
923    pub(crate) fn new(haystack: &'a JavaStr, pat: P, count: usize) -> Self {
924        RSplitN {
925            inner: SplitHelper::new(haystack, pat, true),
926            count,
927        }
928    }
929}
930
931impl<'a, P> Iterator for RSplitN<'a, P>
932where
933    P: JavaStrPattern,
934{
935    type Item = &'a JavaStr;
936
937    #[inline]
938    fn next(&mut self) -> Option<Self::Item> {
939        match self.count {
940            0 => None,
941            1 => {
942                self.count = 0;
943                self.inner.get_end()
944            }
945            _ => {
946                self.count -= 1;
947                self.inner.next_back()
948            }
949        }
950    }
951}
952
953impl<P> FusedIterator for RSplitN<'_, P> where P: JavaStrPattern {}
954
955#[derive(Clone, Debug)]
956pub struct SplitAsciiWhitespace<'a> {
957    #[allow(clippy::type_complexity)]
958    pub(crate) inner: Map<
959        Filter<slice::Split<'a, u8, fn(&u8) -> bool>, fn(&&[u8]) -> bool>,
960        fn(&[u8]) -> &JavaStr,
961    >,
962}
963delegate!(Iterator for SplitAsciiWhitespace<'a> => &'a JavaStr);
964delegate!(DoubleEndedIterator for SplitAsciiWhitespace<'a>);
965delegate!(FusedIterator for SplitAsciiWhitespace<'a>);
966
967#[derive(Clone, Debug)]
968pub struct SplitWhitespace<'a> {
969    #[allow(clippy::type_complexity)]
970    pub(crate) inner: Filter<Split<'a, fn(JavaCodePoint) -> bool>, fn(&&JavaStr) -> bool>,
971}
972delegate!(Iterator for SplitWhitespace<'a> => &'a JavaStr);
973delegate!(DoubleEndedIterator for SplitWhitespace<'a>);
974delegate!(FusedIterator for SplitWhitespace<'a>);
java_string/iter.rs

java_string/
iter.rs
