mileage 0.1.1

deprecated char collections
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

use {
    crate::{set::CharSet, CharRange},
    core::{iter, slice::Iter as SliceIter},
};

/// An iterator over ranges of `char`.
///
/// Constructed via `CharSet::ranges`. See `CharSet` for more information.
///
/// Constructed via `CharMapRef::ranges`. See `CharMapRef` for more information.
#[derive(Clone, Debug)]
pub struct RangeIter<'a> {
    pub(crate) raw: SliceIter<'a, CharRange>,
}

impl<'a> IntoIterator for &'a CharSet {
    type Item = CharRange;
    type IntoIter = RangeIter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.ranges()
    }
}

impl CharSet {
    /// Iterate the compact ranges of this set.
    pub fn ranges(&self) -> RangeIter<'_> {
        RangeIter {
            raw: self.ranges.iter(),
        }
    }

    /// Iterate the codepoints of this set.
    pub fn chars(&self) -> impl Iterator<Item = char> + '_ {
        self.ranges().flat_map(IntoIterator::into_iter)
    }
}

// forward slice iterators

impl ExactSizeIterator for RangeIter<'_> {
    #[inline]
    fn len(&self) -> usize {
        self.raw.len()
    }
}

impl Iterator for RangeIter<'_> {
    type Item = CharRange;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.raw.next().copied()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.raw.size_hint()
    }

    #[inline]
    fn count(self) -> usize {
        self.raw.count()
    }

    #[inline]
    fn nth(&mut self, n: usize) -> Option<Self::Item> {
        self.raw.nth(n).copied()
    }

    #[inline]
    fn fold<Acc, Fold>(self, init: Acc, mut f: Fold) -> Acc
    where
        Fold: FnMut(Acc, Self::Item) -> Acc,
    {
        self.raw.fold(init, |acc, &it| f(acc, it))
    }

    #[inline]
    fn position<P>(&mut self, mut predicate: P) -> Option<usize>
    where
        P: FnMut(Self::Item) -> bool,
    {
        self.raw.position(|&it| predicate(it))
    }

    #[inline]
    fn rposition<P>(&mut self, mut predicate: P) -> Option<usize>
    where
        P: FnMut(Self::Item) -> bool,
    {
        self.raw.rposition(|&it| predicate(it))
    }
}

impl DoubleEndedIterator for RangeIter<'_> {
    #[inline]
    fn next_back(&mut self) -> Option<Self::Item> {
        self.raw.next_back().copied()
    }

    #[inline]
    fn rfold<Acc, Fold>(self, init: Acc, mut f: Fold) -> Acc
    where
        Fold: FnMut(Acc, Self::Item) -> Acc,
    {
        self.raw.rfold(init, |acc, &it| f(acc, it))
    }
}

impl iter::FusedIterator for RangeIter<'_> {}