1 //! Iterators for `str` methods.
4 use crate::fmt::{self, Write};
5 use crate::iter::{Chain, FlatMap, Flatten};
6 use crate::iter::{Copied, Filter, FusedIterator, Map, TrustedLen};
7 use crate::iter::{TrustedRandomAccess, TrustedRandomAccessNoCoerce};
10 use crate::slice::{self, Split as SliceSplit};
12 use super::from_utf8_unchecked;
13 use super::pattern::Pattern;
14 use super::pattern::{DoubleEndedSearcher, ReverseSearcher, Searcher};
15 use super::validations::{next_code_point, next_code_point_reverse};
16 use super::LinesAnyMap;
17 use super::{BytesIsNotEmpty, UnsafeBytesToStr};
18 use super::{CharEscapeDebugContinue, CharEscapeDefault, CharEscapeUnicode};
19 use super::{IsAsciiWhitespace, IsNotEmpty, IsWhitespace};
21 /// An iterator over the [`char`]s of a string slice.
24 /// This struct is created by the [`chars`] method on [`str`].
25 /// See its documentation for more.
27 /// [`char`]: prim@char
28 /// [`chars`]: str::chars
30 #[must_use = "iterators are lazy and do nothing unless consumed"]
31 #[stable(feature = "rust1", since = "1.0.0")]
32 pub struct Chars<'a> {
33 pub(super) iter: slice::Iter<'a, u8>,
36 #[stable(feature = "rust1", since = "1.0.0")]
37 impl<'a> Iterator for Chars<'a> {
41 fn next(&mut self) -> Option<char> {
42 // SAFETY: `str` invariant says `self.iter` is a valid UTF-8 string and
43 // the resulting `ch` is a valid Unicode Scalar Value.
44 unsafe { next_code_point(&mut self.iter).map(|ch| char::from_u32_unchecked(ch)) }
48 fn count(self) -> usize {
49 super::count::count_chars(self.as_str())
53 fn size_hint(&self) -> (usize, Option<usize>) {
54 let len = self.iter.len();
55 // `(len + 3)` can't overflow, because we know that the `slice::Iter`
56 // belongs to a slice in memory which has a maximum length of
57 // `isize::MAX` (that's well below `usize::MAX`).
58 ((len + 3) / 4, Some(len))
62 fn last(mut self) -> Option<char> {
63 // No need to go through the entire string.
68 #[stable(feature = "chars_debug_impl", since = "1.38.0")]
69 impl fmt::Debug for Chars<'_> {
70 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
72 f.debug_list().entries(self.clone()).finish()?;
78 #[stable(feature = "rust1", since = "1.0.0")]
79 impl<'a> DoubleEndedIterator for Chars<'a> {
81 fn next_back(&mut self) -> Option<char> {
82 // SAFETY: `str` invariant says `self.iter` is a valid UTF-8 string and
83 // the resulting `ch` is a valid Unicode Scalar Value.
84 unsafe { next_code_point_reverse(&mut self.iter).map(|ch| char::from_u32_unchecked(ch)) }
88 #[stable(feature = "fused", since = "1.26.0")]
89 impl FusedIterator for Chars<'_> {}
92 /// Views the underlying data as a subslice of the original data.
94 /// This has the same lifetime as the original slice, and so the
95 /// iterator can continue to be used while this exists.
100 /// let mut chars = "abc".chars();
102 /// assert_eq!(chars.as_str(), "abc");
104 /// assert_eq!(chars.as_str(), "bc");
107 /// assert_eq!(chars.as_str(), "");
109 #[stable(feature = "iter_to_slice", since = "1.4.0")]
112 pub fn as_str(&self) -> &'a str {
113 // SAFETY: `Chars` is only made from a str, which guarantees the iter is valid UTF-8.
114 unsafe { from_utf8_unchecked(self.iter.as_slice()) }
118 /// An iterator over the [`char`]s of a string slice, and their positions.
120 /// This struct is created by the [`char_indices`] method on [`str`].
121 /// See its documentation for more.
123 /// [`char`]: prim@char
124 /// [`char_indices`]: str::char_indices
125 #[derive(Clone, Debug)]
126 #[must_use = "iterators are lazy and do nothing unless consumed"]
127 #[stable(feature = "rust1", since = "1.0.0")]
128 pub struct CharIndices<'a> {
129 pub(super) front_offset: usize,
130 pub(super) iter: Chars<'a>,
133 #[stable(feature = "rust1", since = "1.0.0")]
134 impl<'a> Iterator for CharIndices<'a> {
135 type Item = (usize, char);
138 fn next(&mut self) -> Option<(usize, char)> {
139 let pre_len = self.iter.iter.len();
140 match self.iter.next() {
143 let index = self.front_offset;
144 let len = self.iter.iter.len();
145 self.front_offset += pre_len - len;
152 fn count(self) -> usize {
157 fn size_hint(&self) -> (usize, Option<usize>) {
158 self.iter.size_hint()
162 fn last(mut self) -> Option<(usize, char)> {
163 // No need to go through the entire string.
168 #[stable(feature = "rust1", since = "1.0.0")]
169 impl<'a> DoubleEndedIterator for CharIndices<'a> {
171 fn next_back(&mut self) -> Option<(usize, char)> {
172 self.iter.next_back().map(|ch| {
173 let index = self.front_offset + self.iter.iter.len();
179 #[stable(feature = "fused", since = "1.26.0")]
180 impl FusedIterator for CharIndices<'_> {}
182 impl<'a> CharIndices<'a> {
183 /// Views the underlying data as a subslice of the original data.
185 /// This has the same lifetime as the original slice, and so the
186 /// iterator can continue to be used while this exists.
187 #[stable(feature = "iter_to_slice", since = "1.4.0")]
190 pub fn as_str(&self) -> &'a str {
194 /// Returns the byte position of the next character, or the length
195 /// of the underlying string if there are no more characters.
200 /// #![feature(char_indices_offset)]
201 /// let mut chars = "a楽".char_indices();
203 /// assert_eq!(chars.offset(), 0);
204 /// assert_eq!(chars.next(), Some((0, 'a')));
206 /// assert_eq!(chars.offset(), 1);
207 /// assert_eq!(chars.next(), Some((1, '楽')));
209 /// assert_eq!(chars.offset(), 4);
210 /// assert_eq!(chars.next(), None);
214 #[unstable(feature = "char_indices_offset", issue = "83871")]
215 pub fn offset(&self) -> usize {
220 /// An iterator over the bytes of a string slice.
222 /// This struct is created by the [`bytes`] method on [`str`].
223 /// See its documentation for more.
225 /// [`bytes`]: str::bytes
226 #[must_use = "iterators are lazy and do nothing unless consumed"]
227 #[stable(feature = "rust1", since = "1.0.0")]
228 #[derive(Clone, Debug)]
229 pub struct Bytes<'a>(pub(super) Copied<slice::Iter<'a, u8>>);
231 #[stable(feature = "rust1", since = "1.0.0")]
232 impl Iterator for Bytes<'_> {
236 fn next(&mut self) -> Option<u8> {
241 fn size_hint(&self) -> (usize, Option<usize>) {
246 fn count(self) -> usize {
251 fn last(self) -> Option<Self::Item> {
256 fn nth(&mut self, n: usize) -> Option<Self::Item> {
261 fn all<F>(&mut self, f: F) -> bool
263 F: FnMut(Self::Item) -> bool,
269 fn any<F>(&mut self, f: F) -> bool
271 F: FnMut(Self::Item) -> bool,
277 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
279 P: FnMut(&Self::Item) -> bool,
281 self.0.find(predicate)
285 fn position<P>(&mut self, predicate: P) -> Option<usize>
287 P: FnMut(Self::Item) -> bool,
289 self.0.position(predicate)
293 fn rposition<P>(&mut self, predicate: P) -> Option<usize>
295 P: FnMut(Self::Item) -> bool,
297 self.0.rposition(predicate)
301 unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> u8 {
302 // SAFETY: the caller must uphold the safety contract
303 // for `Iterator::__iterator_get_unchecked`.
304 unsafe { self.0.__iterator_get_unchecked(idx) }
308 #[stable(feature = "rust1", since = "1.0.0")]
309 impl DoubleEndedIterator for Bytes<'_> {
311 fn next_back(&mut self) -> Option<u8> {
316 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
321 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
323 P: FnMut(&Self::Item) -> bool,
325 self.0.rfind(predicate)
329 #[stable(feature = "rust1", since = "1.0.0")]
330 impl ExactSizeIterator for Bytes<'_> {
332 fn len(&self) -> usize {
337 fn is_empty(&self) -> bool {
342 #[stable(feature = "fused", since = "1.26.0")]
343 impl FusedIterator for Bytes<'_> {}
345 #[unstable(feature = "trusted_len", issue = "37572")]
346 unsafe impl TrustedLen for Bytes<'_> {}
349 #[unstable(feature = "trusted_random_access", issue = "none")]
350 unsafe impl TrustedRandomAccess for Bytes<'_> {}
353 #[unstable(feature = "trusted_random_access", issue = "none")]
354 unsafe impl TrustedRandomAccessNoCoerce for Bytes<'_> {
355 const MAY_HAVE_SIDE_EFFECT: bool = false;
358 /// This macro generates a Clone impl for string pattern API
359 /// wrapper types of the form X<'a, P>
360 macro_rules! derive_pattern_clone {
361 (clone $t:ident with |$s:ident| $e:expr) => {
362 impl<'a, P> Clone for $t<'a, P>
364 P: Pattern<'a, Searcher: Clone>,
366 fn clone(&self) -> Self {
374 /// This macro generates two public iterator structs
375 /// wrapping a private internal one that makes use of the `Pattern` API.
377 /// For all patterns `P: Pattern<'a>` the following items will be
378 /// generated (generics omitted):
380 /// struct $forward_iterator($internal_iterator);
381 /// struct $reverse_iterator($internal_iterator);
383 /// impl Iterator for $forward_iterator
384 /// { /* internal ends up calling Searcher::next_match() */ }
386 /// impl DoubleEndedIterator for $forward_iterator
387 /// where P::Searcher: DoubleEndedSearcher
388 /// { /* internal ends up calling Searcher::next_match_back() */ }
390 /// impl Iterator for $reverse_iterator
391 /// where P::Searcher: ReverseSearcher
392 /// { /* internal ends up calling Searcher::next_match_back() */ }
394 /// impl DoubleEndedIterator for $reverse_iterator
395 /// where P::Searcher: DoubleEndedSearcher
396 /// { /* internal ends up calling Searcher::next_match() */ }
398 /// The internal one is defined outside the macro, and has almost the same
399 /// semantic as a DoubleEndedIterator by delegating to `pattern::Searcher` and
400 /// `pattern::ReverseSearcher` for both forward and reverse iteration.
402 /// "Almost", because a `Searcher` and a `ReverseSearcher` for a given
403 /// `Pattern` might not return the same elements, so actually implementing
404 /// `DoubleEndedIterator` for it would be incorrect.
405 /// (See the docs in `str::pattern` for more details)
407 /// However, the internal struct still represents a single ended iterator from
408 /// either end, and depending on pattern is also a valid double ended iterator,
409 /// so the two wrapper structs implement `Iterator`
410 /// and `DoubleEndedIterator` depending on the concrete pattern type, leading
411 /// to the complex impls seen above.
412 macro_rules! generate_pattern_iterators {
416 $(#[$forward_iterator_attribute:meta])*
417 struct $forward_iterator:ident;
421 $(#[$reverse_iterator_attribute:meta])*
422 struct $reverse_iterator:ident;
424 // Stability of all generated items
426 $(#[$common_stability_attribute:meta])*
428 // Internal almost-iterator that is being delegated to
430 $internal_iterator:ident yielding ($iterty:ty);
432 // Kind of delegation - either single ended or double ended
435 $(#[$forward_iterator_attribute])*
436 $(#[$common_stability_attribute])*
437 pub struct $forward_iterator<'a, P: Pattern<'a>>(pub(super) $internal_iterator<'a, P>);
439 $(#[$common_stability_attribute])*
440 impl<'a, P> fmt::Debug for $forward_iterator<'a, P>
442 P: Pattern<'a, Searcher: fmt::Debug>,
444 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
445 f.debug_tuple(stringify!($forward_iterator))
451 $(#[$common_stability_attribute])*
452 impl<'a, P: Pattern<'a>> Iterator for $forward_iterator<'a, P> {
456 fn next(&mut self) -> Option<$iterty> {
461 $(#[$common_stability_attribute])*
462 impl<'a, P> Clone for $forward_iterator<'a, P>
464 P: Pattern<'a, Searcher: Clone>,
466 fn clone(&self) -> Self {
467 $forward_iterator(self.0.clone())
471 $(#[$reverse_iterator_attribute])*
472 $(#[$common_stability_attribute])*
473 pub struct $reverse_iterator<'a, P: Pattern<'a>>(pub(super) $internal_iterator<'a, P>);
475 $(#[$common_stability_attribute])*
476 impl<'a, P> fmt::Debug for $reverse_iterator<'a, P>
478 P: Pattern<'a, Searcher: fmt::Debug>,
480 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
481 f.debug_tuple(stringify!($reverse_iterator))
487 $(#[$common_stability_attribute])*
488 impl<'a, P> Iterator for $reverse_iterator<'a, P>
490 P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
495 fn next(&mut self) -> Option<$iterty> {
500 $(#[$common_stability_attribute])*
501 impl<'a, P> Clone for $reverse_iterator<'a, P>
503 P: Pattern<'a, Searcher: Clone>,
505 fn clone(&self) -> Self {
506 $reverse_iterator(self.0.clone())
510 #[stable(feature = "fused", since = "1.26.0")]
511 impl<'a, P: Pattern<'a>> FusedIterator for $forward_iterator<'a, P> {}
513 #[stable(feature = "fused", since = "1.26.0")]
514 impl<'a, P> FusedIterator for $reverse_iterator<'a, P>
516 P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
519 generate_pattern_iterators!($($t)* with $(#[$common_stability_attribute])*,
521 $reverse_iterator, $iterty);
524 double ended; with $(#[$common_stability_attribute:meta])*,
525 $forward_iterator:ident,
526 $reverse_iterator:ident, $iterty:ty
528 $(#[$common_stability_attribute])*
529 impl<'a, P> DoubleEndedIterator for $forward_iterator<'a, P>
531 P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
534 fn next_back(&mut self) -> Option<$iterty> {
539 $(#[$common_stability_attribute])*
540 impl<'a, P> DoubleEndedIterator for $reverse_iterator<'a, P>
542 P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
545 fn next_back(&mut self) -> Option<$iterty> {
551 single ended; with $(#[$common_stability_attribute:meta])*,
552 $forward_iterator:ident,
553 $reverse_iterator:ident, $iterty:ty
557 derive_pattern_clone! {
559 with |s| SplitInternal { matcher: s.matcher.clone(), ..*s }
562 pub(super) struct SplitInternal<'a, P: Pattern<'a>> {
563 pub(super) start: usize,
564 pub(super) end: usize,
565 pub(super) matcher: P::Searcher,
566 pub(super) allow_trailing_empty: bool,
567 pub(super) finished: bool,
570 impl<'a, P> fmt::Debug for SplitInternal<'a, P>
572 P: Pattern<'a, Searcher: fmt::Debug>,
574 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
575 f.debug_struct("SplitInternal")
576 .field("start", &self.start)
577 .field("end", &self.end)
578 .field("matcher", &self.matcher)
579 .field("allow_trailing_empty", &self.allow_trailing_empty)
580 .field("finished", &self.finished)
585 impl<'a, P: Pattern<'a>> SplitInternal<'a, P> {
587 fn get_end(&mut self) -> Option<&'a str> {
589 self.finished = true;
591 if self.allow_trailing_empty || self.end - self.start > 0 {
592 // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
593 let string = unsafe { self.matcher.haystack().get_unchecked(self.start..self.end) };
602 fn next(&mut self) -> Option<&'a str> {
607 let haystack = self.matcher.haystack();
608 match self.matcher.next_match() {
609 // SAFETY: `Searcher` guarantees that `a` and `b` lie on unicode boundaries.
610 Some((a, b)) => unsafe {
611 let elt = haystack.get_unchecked(self.start..a);
615 None => self.get_end(),
620 fn next_inclusive(&mut self) -> Option<&'a str> {
625 let haystack = self.matcher.haystack();
626 match self.matcher.next_match() {
627 // SAFETY: `Searcher` guarantees that `b` lies on unicode boundary,
628 // and self.start is either the start of the original string,
629 // or `b` was assigned to it, so it also lies on unicode boundary.
630 Some((_, b)) => unsafe {
631 let elt = haystack.get_unchecked(self.start..b);
635 None => self.get_end(),
640 fn next_back(&mut self) -> Option<&'a str>
642 P::Searcher: ReverseSearcher<'a>,
648 if !self.allow_trailing_empty {
649 self.allow_trailing_empty = true;
650 match self.next_back() {
651 Some(elt) if !elt.is_empty() => return Some(elt),
660 let haystack = self.matcher.haystack();
661 match self.matcher.next_match_back() {
662 // SAFETY: `Searcher` guarantees that `a` and `b` lie on unicode boundaries.
663 Some((a, b)) => unsafe {
664 let elt = haystack.get_unchecked(b..self.end);
668 // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
670 self.finished = true;
671 Some(haystack.get_unchecked(self.start..self.end))
677 fn next_back_inclusive(&mut self) -> Option<&'a str>
679 P::Searcher: ReverseSearcher<'a>,
685 if !self.allow_trailing_empty {
686 self.allow_trailing_empty = true;
687 match self.next_back_inclusive() {
688 Some(elt) if !elt.is_empty() => return Some(elt),
697 let haystack = self.matcher.haystack();
698 match self.matcher.next_match_back() {
699 // SAFETY: `Searcher` guarantees that `b` lies on unicode boundary,
700 // and self.end is either the end of the original string,
701 // or `b` was assigned to it, so it also lies on unicode boundary.
702 Some((_, b)) => unsafe {
703 let elt = haystack.get_unchecked(b..self.end);
707 // SAFETY: self.start is either the start of the original string,
708 // or start of a substring that represents the part of the string that hasn't
709 // iterated yet. Either way, it is guaranteed to lie on unicode boundary.
710 // self.end is either the end of the original string,
711 // or `b` was assigned to it, so it also lies on unicode boundary.
713 self.finished = true;
714 Some(haystack.get_unchecked(self.start..self.end))
720 fn as_str(&self) -> &'a str {
721 // `Self::get_end` doesn't change `self.start`
726 // SAFETY: `self.start` and `self.end` always lie on unicode boundaries.
727 unsafe { self.matcher.haystack().get_unchecked(self.start..self.end) }
731 generate_pattern_iterators! {
733 /// Created with the method [`split`].
735 /// [`split`]: str::split
738 /// Created with the method [`rsplit`].
740 /// [`rsplit`]: str::rsplit
743 #[stable(feature = "rust1", since = "1.0.0")]
745 SplitInternal yielding (&'a str);
746 delegate double ended;
749 impl<'a, P: Pattern<'a>> Split<'a, P> {
750 /// Returns remainder of the split string
755 /// #![feature(str_split_as_str)]
756 /// let mut split = "Mary had a little lamb".split(' ');
757 /// assert_eq!(split.as_str(), "Mary had a little lamb");
759 /// assert_eq!(split.as_str(), "had a little lamb");
760 /// split.by_ref().for_each(drop);
761 /// assert_eq!(split.as_str(), "");
764 #[unstable(feature = "str_split_as_str", issue = "77998")]
765 pub fn as_str(&self) -> &'a str {
770 impl<'a, P: Pattern<'a>> RSplit<'a, P> {
771 /// Returns remainder of the split string
776 /// #![feature(str_split_as_str)]
777 /// let mut split = "Mary had a little lamb".rsplit(' ');
778 /// assert_eq!(split.as_str(), "Mary had a little lamb");
780 /// assert_eq!(split.as_str(), "Mary had a little");
781 /// split.by_ref().for_each(drop);
782 /// assert_eq!(split.as_str(), "");
785 #[unstable(feature = "str_split_as_str", issue = "77998")]
786 pub fn as_str(&self) -> &'a str {
791 generate_pattern_iterators! {
793 /// Created with the method [`split_terminator`].
795 /// [`split_terminator`]: str::split_terminator
796 struct SplitTerminator;
798 /// Created with the method [`rsplit_terminator`].
800 /// [`rsplit_terminator`]: str::rsplit_terminator
801 struct RSplitTerminator;
803 #[stable(feature = "rust1", since = "1.0.0")]
805 SplitInternal yielding (&'a str);
806 delegate double ended;
809 impl<'a, P: Pattern<'a>> SplitTerminator<'a, P> {
810 /// Returns remainder of the split string
815 /// #![feature(str_split_as_str)]
816 /// let mut split = "A..B..".split_terminator('.');
817 /// assert_eq!(split.as_str(), "A..B..");
819 /// assert_eq!(split.as_str(), ".B..");
820 /// split.by_ref().for_each(drop);
821 /// assert_eq!(split.as_str(), "");
824 #[unstable(feature = "str_split_as_str", issue = "77998")]
825 pub fn as_str(&self) -> &'a str {
830 impl<'a, P: Pattern<'a>> RSplitTerminator<'a, P> {
831 /// Returns remainder of the split string
836 /// #![feature(str_split_as_str)]
837 /// let mut split = "A..B..".rsplit_terminator('.');
838 /// assert_eq!(split.as_str(), "A..B..");
840 /// assert_eq!(split.as_str(), "A..B");
841 /// split.by_ref().for_each(drop);
842 /// assert_eq!(split.as_str(), "");
845 #[unstable(feature = "str_split_as_str", issue = "77998")]
846 pub fn as_str(&self) -> &'a str {
851 derive_pattern_clone! {
853 with |s| SplitNInternal { iter: s.iter.clone(), ..*s }
856 pub(super) struct SplitNInternal<'a, P: Pattern<'a>> {
857 pub(super) iter: SplitInternal<'a, P>,
858 /// The number of splits remaining
859 pub(super) count: usize,
862 impl<'a, P> fmt::Debug for SplitNInternal<'a, P>
864 P: Pattern<'a, Searcher: fmt::Debug>,
866 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
867 f.debug_struct("SplitNInternal")
868 .field("iter", &self.iter)
869 .field("count", &self.count)
874 impl<'a, P: Pattern<'a>> SplitNInternal<'a, P> {
876 fn next(&mut self) -> Option<&'a str> {
891 fn next_back(&mut self) -> Option<&'a str>
893 P::Searcher: ReverseSearcher<'a>,
903 self.iter.next_back()
909 fn as_str(&self) -> &'a str {
914 generate_pattern_iterators! {
916 /// Created with the method [`splitn`].
918 /// [`splitn`]: str::splitn
921 /// Created with the method [`rsplitn`].
923 /// [`rsplitn`]: str::rsplitn
926 #[stable(feature = "rust1", since = "1.0.0")]
928 SplitNInternal yielding (&'a str);
929 delegate single ended;
932 impl<'a, P: Pattern<'a>> SplitN<'a, P> {
933 /// Returns remainder of the split string
938 /// #![feature(str_split_as_str)]
939 /// let mut split = "Mary had a little lamb".splitn(3, ' ');
940 /// assert_eq!(split.as_str(), "Mary had a little lamb");
942 /// assert_eq!(split.as_str(), "had a little lamb");
943 /// split.by_ref().for_each(drop);
944 /// assert_eq!(split.as_str(), "");
947 #[unstable(feature = "str_split_as_str", issue = "77998")]
948 pub fn as_str(&self) -> &'a str {
953 impl<'a, P: Pattern<'a>> RSplitN<'a, P> {
954 /// Returns remainder of the split string
959 /// #![feature(str_split_as_str)]
960 /// let mut split = "Mary had a little lamb".rsplitn(3, ' ');
961 /// assert_eq!(split.as_str(), "Mary had a little lamb");
963 /// assert_eq!(split.as_str(), "Mary had a little");
964 /// split.by_ref().for_each(drop);
965 /// assert_eq!(split.as_str(), "");
968 #[unstable(feature = "str_split_as_str", issue = "77998")]
969 pub fn as_str(&self) -> &'a str {
974 derive_pattern_clone! {
975 clone MatchIndicesInternal
976 with |s| MatchIndicesInternal(s.0.clone())
979 pub(super) struct MatchIndicesInternal<'a, P: Pattern<'a>>(pub(super) P::Searcher);
981 impl<'a, P> fmt::Debug for MatchIndicesInternal<'a, P>
983 P: Pattern<'a, Searcher: fmt::Debug>,
985 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
986 f.debug_tuple("MatchIndicesInternal").field(&self.0).finish()
990 impl<'a, P: Pattern<'a>> MatchIndicesInternal<'a, P> {
992 fn next(&mut self) -> Option<(usize, &'a str)> {
995 // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
996 .map(|(start, end)| unsafe { (start, self.0.haystack().get_unchecked(start..end)) })
1000 fn next_back(&mut self) -> Option<(usize, &'a str)>
1002 P::Searcher: ReverseSearcher<'a>,
1006 // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
1007 .map(|(start, end)| unsafe { (start, self.0.haystack().get_unchecked(start..end)) })
1011 generate_pattern_iterators! {
1013 /// Created with the method [`match_indices`].
1015 /// [`match_indices`]: str::match_indices
1016 struct MatchIndices;
1018 /// Created with the method [`rmatch_indices`].
1020 /// [`rmatch_indices`]: str::rmatch_indices
1021 struct RMatchIndices;
1023 #[stable(feature = "str_match_indices", since = "1.5.0")]
1025 MatchIndicesInternal yielding ((usize, &'a str));
1026 delegate double ended;
1029 derive_pattern_clone! {
1030 clone MatchesInternal
1031 with |s| MatchesInternal(s.0.clone())
1034 pub(super) struct MatchesInternal<'a, P: Pattern<'a>>(pub(super) P::Searcher);
1036 impl<'a, P> fmt::Debug for MatchesInternal<'a, P>
1038 P: Pattern<'a, Searcher: fmt::Debug>,
1040 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1041 f.debug_tuple("MatchesInternal").field(&self.0).finish()
1045 impl<'a, P: Pattern<'a>> MatchesInternal<'a, P> {
1047 fn next(&mut self) -> Option<&'a str> {
1048 // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
1049 self.0.next_match().map(|(a, b)| unsafe {
1050 // Indices are known to be on utf8 boundaries
1051 self.0.haystack().get_unchecked(a..b)
1056 fn next_back(&mut self) -> Option<&'a str>
1058 P::Searcher: ReverseSearcher<'a>,
1060 // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
1061 self.0.next_match_back().map(|(a, b)| unsafe {
1062 // Indices are known to be on utf8 boundaries
1063 self.0.haystack().get_unchecked(a..b)
1068 generate_pattern_iterators! {
1070 /// Created with the method [`matches`].
1072 /// [`matches`]: str::matches
1075 /// Created with the method [`rmatches`].
1077 /// [`rmatches`]: str::rmatches
1080 #[stable(feature = "str_matches", since = "1.2.0")]
1082 MatchesInternal yielding (&'a str);
1083 delegate double ended;
1086 /// An iterator over the lines of a string, as string slices.
1088 /// This struct is created with the [`lines`] method on [`str`].
1089 /// See its documentation for more.
1091 /// [`lines`]: str::lines
1092 #[stable(feature = "rust1", since = "1.0.0")]
1093 #[must_use = "iterators are lazy and do nothing unless consumed"]
1094 #[derive(Clone, Debug)]
1095 pub struct Lines<'a>(pub(super) Map<SplitTerminator<'a, char>, LinesAnyMap>);
1097 #[stable(feature = "rust1", since = "1.0.0")]
1098 impl<'a> Iterator for Lines<'a> {
1099 type Item = &'a str;
1102 fn next(&mut self) -> Option<&'a str> {
1107 fn size_hint(&self) -> (usize, Option<usize>) {
1112 fn last(mut self) -> Option<&'a str> {
1117 #[stable(feature = "rust1", since = "1.0.0")]
1118 impl<'a> DoubleEndedIterator for Lines<'a> {
1120 fn next_back(&mut self) -> Option<&'a str> {
1125 #[stable(feature = "fused", since = "1.26.0")]
1126 impl FusedIterator for Lines<'_> {}
1128 /// Created with the method [`lines_any`].
1130 /// [`lines_any`]: str::lines_any
1131 #[stable(feature = "rust1", since = "1.0.0")]
1132 #[deprecated(since = "1.4.0", note = "use lines()/Lines instead now")]
1133 #[must_use = "iterators are lazy and do nothing unless consumed"]
1134 #[derive(Clone, Debug)]
1135 #[allow(deprecated)]
1136 pub struct LinesAny<'a>(pub(super) Lines<'a>);
1138 #[stable(feature = "rust1", since = "1.0.0")]
1139 #[allow(deprecated)]
1140 impl<'a> Iterator for LinesAny<'a> {
1141 type Item = &'a str;
1144 fn next(&mut self) -> Option<&'a str> {
1149 fn size_hint(&self) -> (usize, Option<usize>) {
1154 #[stable(feature = "rust1", since = "1.0.0")]
1155 #[allow(deprecated)]
1156 impl<'a> DoubleEndedIterator for LinesAny<'a> {
1158 fn next_back(&mut self) -> Option<&'a str> {
1163 #[stable(feature = "fused", since = "1.26.0")]
1164 #[allow(deprecated)]
1165 impl FusedIterator for LinesAny<'_> {}
1167 /// An iterator over the non-whitespace substrings of a string,
1168 /// separated by any amount of whitespace.
1170 /// This struct is created by the [`split_whitespace`] method on [`str`].
1171 /// See its documentation for more.
1173 /// [`split_whitespace`]: str::split_whitespace
1174 #[stable(feature = "split_whitespace", since = "1.1.0")]
1175 #[derive(Clone, Debug)]
1176 pub struct SplitWhitespace<'a> {
1177 pub(super) inner: Filter<Split<'a, IsWhitespace>, IsNotEmpty>,
1180 /// An iterator over the non-ASCII-whitespace substrings of a string,
1181 /// separated by any amount of ASCII whitespace.
1183 /// This struct is created by the [`split_ascii_whitespace`] method on [`str`].
1184 /// See its documentation for more.
1186 /// [`split_ascii_whitespace`]: str::split_ascii_whitespace
1187 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
1188 #[derive(Clone, Debug)]
1189 pub struct SplitAsciiWhitespace<'a> {
1191 Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty>, UnsafeBytesToStr>,
1194 /// An iterator over the substrings of a string,
1195 /// terminated by a substring matching to a predicate function
1196 /// Unlike `Split`, it contains the matched part as a terminator
1197 /// of the subslice.
1199 /// This struct is created by the [`split_inclusive`] method on [`str`].
1200 /// See its documentation for more.
1202 /// [`split_inclusive`]: str::split_inclusive
1203 #[stable(feature = "split_inclusive", since = "1.51.0")]
1204 pub struct SplitInclusive<'a, P: Pattern<'a>>(pub(super) SplitInternal<'a, P>);
1206 #[stable(feature = "split_whitespace", since = "1.1.0")]
1207 impl<'a> Iterator for SplitWhitespace<'a> {
1208 type Item = &'a str;
1211 fn next(&mut self) -> Option<&'a str> {
1216 fn size_hint(&self) -> (usize, Option<usize>) {
1217 self.inner.size_hint()
1221 fn last(mut self) -> Option<&'a str> {
1226 #[stable(feature = "split_whitespace", since = "1.1.0")]
1227 impl<'a> DoubleEndedIterator for SplitWhitespace<'a> {
1229 fn next_back(&mut self) -> Option<&'a str> {
1230 self.inner.next_back()
1234 #[stable(feature = "fused", since = "1.26.0")]
1235 impl FusedIterator for SplitWhitespace<'_> {}
1237 impl<'a> SplitWhitespace<'a> {
1238 /// Returns remainder of the split string
1243 /// #![feature(str_split_whitespace_as_str)]
1245 /// let mut split = "Mary had a little lamb".split_whitespace();
1246 /// assert_eq!(split.as_str(), "Mary had a little lamb");
1249 /// assert_eq!(split.as_str(), "had a little lamb");
1251 /// split.by_ref().for_each(drop);
1252 /// assert_eq!(split.as_str(), "");
1256 #[unstable(feature = "str_split_whitespace_as_str", issue = "77998")]
1257 pub fn as_str(&self) -> &'a str {
1258 self.inner.iter.as_str()
1262 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
1263 impl<'a> Iterator for SplitAsciiWhitespace<'a> {
1264 type Item = &'a str;
1267 fn next(&mut self) -> Option<&'a str> {
1272 fn size_hint(&self) -> (usize, Option<usize>) {
1273 self.inner.size_hint()
1277 fn last(mut self) -> Option<&'a str> {
1282 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
1283 impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a> {
1285 fn next_back(&mut self) -> Option<&'a str> {
1286 self.inner.next_back()
1290 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
1291 impl FusedIterator for SplitAsciiWhitespace<'_> {}
1293 impl<'a> SplitAsciiWhitespace<'a> {
1294 /// Returns remainder of the split string
1299 /// #![feature(str_split_whitespace_as_str)]
1301 /// let mut split = "Mary had a little lamb".split_ascii_whitespace();
1302 /// assert_eq!(split.as_str(), "Mary had a little lamb");
1305 /// assert_eq!(split.as_str(), "had a little lamb");
1307 /// split.by_ref().for_each(drop);
1308 /// assert_eq!(split.as_str(), "");
1312 #[unstable(feature = "str_split_whitespace_as_str", issue = "77998")]
1313 pub fn as_str(&self) -> &'a str {
1314 if self.inner.iter.iter.finished {
1318 // SAFETY: Slice is created from str.
1319 unsafe { crate::str::from_utf8_unchecked(&self.inner.iter.iter.v) }
1323 #[stable(feature = "split_inclusive", since = "1.51.0")]
1324 impl<'a, P: Pattern<'a>> Iterator for SplitInclusive<'a, P> {
1325 type Item = &'a str;
1328 fn next(&mut self) -> Option<&'a str> {
1329 self.0.next_inclusive()
1333 #[stable(feature = "split_inclusive", since = "1.51.0")]
1334 impl<'a, P: Pattern<'a, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a, P> {
1335 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1336 f.debug_struct("SplitInclusive").field("0", &self.0).finish()
1340 // FIXME(#26925) Remove in favor of `#[derive(Clone)]`
1341 #[stable(feature = "split_inclusive", since = "1.51.0")]
1342 impl<'a, P: Pattern<'a, Searcher: Clone>> Clone for SplitInclusive<'a, P> {
1343 fn clone(&self) -> Self {
1344 SplitInclusive(self.0.clone())
1348 #[stable(feature = "split_inclusive", since = "1.51.0")]
1349 impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
1350 for SplitInclusive<'a, P>
1353 fn next_back(&mut self) -> Option<&'a str> {
1354 self.0.next_back_inclusive()
1358 #[stable(feature = "split_inclusive", since = "1.51.0")]
1359 impl<'a, P: Pattern<'a>> FusedIterator for SplitInclusive<'a, P> {}
1361 impl<'a, P: Pattern<'a>> SplitInclusive<'a, P> {
1362 /// Returns remainder of the split string
1367 /// #![feature(str_split_inclusive_as_str)]
1368 /// let mut split = "Mary had a little lamb".split_inclusive(' ');
1369 /// assert_eq!(split.as_str(), "Mary had a little lamb");
1371 /// assert_eq!(split.as_str(), "had a little lamb");
1372 /// split.by_ref().for_each(drop);
1373 /// assert_eq!(split.as_str(), "");
1376 #[unstable(feature = "str_split_inclusive_as_str", issue = "77998")]
1377 pub fn as_str(&self) -> &'a str {
1382 /// An iterator of [`u16`] over the string encoded as UTF-16.
1384 /// This struct is created by the [`encode_utf16`] method on [`str`].
1385 /// See its documentation for more.
1387 /// [`encode_utf16`]: str::encode_utf16
1389 #[stable(feature = "encode_utf16", since = "1.8.0")]
1390 pub struct EncodeUtf16<'a> {
1391 pub(super) chars: Chars<'a>,
1392 pub(super) extra: u16,
1395 #[stable(feature = "collection_debug", since = "1.17.0")]
1396 impl fmt::Debug for EncodeUtf16<'_> {
1397 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1398 f.debug_struct("EncodeUtf16").finish_non_exhaustive()
1402 #[stable(feature = "encode_utf16", since = "1.8.0")]
1403 impl<'a> Iterator for EncodeUtf16<'a> {
1407 fn next(&mut self) -> Option<u16> {
1408 if self.extra != 0 {
1409 let tmp = self.extra;
1414 let mut buf = [0; 2];
1415 self.chars.next().map(|ch| {
1416 let n = ch.encode_utf16(&mut buf).len();
1418 self.extra = buf[1];
1425 fn size_hint(&self) -> (usize, Option<usize>) {
1426 let (low, high) = self.chars.size_hint();
1427 // every char gets either one u16 or two u16,
1428 // so this iterator is between 1 or 2 times as
1429 // long as the underlying iterator.
1430 (low, high.and_then(|n| n.checked_mul(2)))
1434 #[stable(feature = "fused", since = "1.26.0")]
1435 impl FusedIterator for EncodeUtf16<'_> {}
1437 /// The return type of [`str::escape_debug`].
1438 #[stable(feature = "str_escape", since = "1.34.0")]
1439 #[derive(Clone, Debug)]
1440 pub struct EscapeDebug<'a> {
1441 pub(super) inner: Chain<
1442 Flatten<option::IntoIter<char::EscapeDebug>>,
1443 FlatMap<Chars<'a>, char::EscapeDebug, CharEscapeDebugContinue>,
1447 /// The return type of [`str::escape_default`].
1448 #[stable(feature = "str_escape", since = "1.34.0")]
1449 #[derive(Clone, Debug)]
1450 pub struct EscapeDefault<'a> {
1451 pub(super) inner: FlatMap<Chars<'a>, char::EscapeDefault, CharEscapeDefault>,
1454 /// The return type of [`str::escape_unicode`].
1455 #[stable(feature = "str_escape", since = "1.34.0")]
1456 #[derive(Clone, Debug)]
1457 pub struct EscapeUnicode<'a> {
1458 pub(super) inner: FlatMap<Chars<'a>, char::EscapeUnicode, CharEscapeUnicode>,
1461 macro_rules! escape_types_impls {
1462 ($( $Name: ident ),+) => {$(
1463 #[stable(feature = "str_escape", since = "1.34.0")]
1464 impl<'a> fmt::Display for $Name<'a> {
1465 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1466 self.clone().try_for_each(|c| f.write_char(c))
1470 #[stable(feature = "str_escape", since = "1.34.0")]
1471 impl<'a> Iterator for $Name<'a> {
1475 fn next(&mut self) -> Option<char> { self.inner.next() }
1478 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
1481 fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
1482 Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Output = Acc>
1484 self.inner.try_fold(init, fold)
1488 fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
1489 where Fold: FnMut(Acc, Self::Item) -> Acc,
1491 self.inner.fold(init, fold)
1495 #[stable(feature = "str_escape", since = "1.34.0")]
1496 impl<'a> FusedIterator for $Name<'a> {}
1500 escape_types_impls!(EscapeDebug, EscapeDefault, EscapeUnicode);