roe 0.0.7

Unicode case conversion
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
130
131
132

// This file contains code extracted from std::char::CaseMappingIter.
use core::fmt::{Debug, Display, Formatter, Result, Write};

#[derive(Debug, Clone)]
pub enum CaseMappingIter {
    Three(char, char, char),
    Two(char, char),
    One(char),
    Zero,
}

impl CaseMappingIter {
    pub fn new(chars: [char; 3]) -> CaseMappingIter {
        match chars {
            [a, '\0', '\0'] => CaseMappingIter::One(a),
            [a, b, '\0'] => CaseMappingIter::Two(a, b),
            [a, b, c] => CaseMappingIter::Three(a, b, c),
        }
    }
}

impl Iterator for CaseMappingIter {
    type Item = char;
    fn next(&mut self) -> Option<char> {
        match *self {
            CaseMappingIter::Three(a, b, c) => {
                *self = CaseMappingIter::Two(b, c);
                Some(a)
            }
            CaseMappingIter::Two(b, c) => {
                *self = CaseMappingIter::One(c);
                Some(b)
            }
            CaseMappingIter::One(c) => {
                *self = CaseMappingIter::Zero;
                Some(c)
            }
            CaseMappingIter::Zero => None,
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let size = match self {
            CaseMappingIter::Three(..) => 3,
            CaseMappingIter::Two(..) => 2,
            CaseMappingIter::One(_) => 1,
            CaseMappingIter::Zero => 0,
        };
        (size, Some(size))
    }
}

impl DoubleEndedIterator for CaseMappingIter {
    fn next_back(&mut self) -> Option<char> {
        match *self {
            CaseMappingIter::Three(a, b, c) => {
                *self = CaseMappingIter::Two(a, b);
                Some(c)
            }
            CaseMappingIter::Two(b, c) => {
                *self = CaseMappingIter::One(b);
                Some(c)
            }
            CaseMappingIter::One(c) => {
                *self = CaseMappingIter::Zero;
                Some(c)
            }
            CaseMappingIter::Zero => None,
        }
    }
}

impl Display for CaseMappingIter {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match *self {
            CaseMappingIter::Three(a, b, c) => {
                f.write_char(a)?;
                f.write_char(b)?;
                f.write_char(c)
            }
            CaseMappingIter::Two(b, c) => {
                f.write_char(b)?;
                f.write_char(c)
            }
            CaseMappingIter::One(c) => f.write_char(c),
            CaseMappingIter::Zero => Ok(()),
        }
    }
}

#[cfg(test)]
mod tests {
    use alloc::{format, vec::Vec};

    use super::CaseMappingIter;

    #[test]
    fn test_case_mapping_iter() {
        fn test_iterator(iter: CaseMappingIter, expected: &[char], expected_rev: &[char]) {
            assert_eq!(iter.size_hint(), (expected.len(), Some(expected.len())));
            assert_eq!(iter.clone().collect::<Vec<_>>(), expected);
            assert_eq!(iter.rev().collect::<Vec<_>>(), expected_rev);
        }
        test_iterator(
            CaseMappingIter::new(['F', 'f', 'l']),
            &['F', 'f', 'l'],
            &['l', 'f', 'F'],
        );
        test_iterator(
            CaseMappingIter::new(['S', 's', '\0']),
            &['S', 's'],
            &['s', 'S'],
        );
        test_iterator(CaseMappingIter::new(['A', '\0', '\0']), &['A'], &['A']);
        test_iterator(CaseMappingIter::new(['\0', '\0', '\0']), &['\0'], &['\0']);
    }

    #[test]
    fn test_fmt() {
        let zero = CaseMappingIter::Zero;
        assert_eq!(format!("{zero}"), "");

        let one = CaseMappingIter::One('A');
        assert_eq!(format!("{one}"), "A");

        let two = CaseMappingIter::Two('S', 's');
        assert_eq!(format!("{two}"), "Ss");

        let three = CaseMappingIter::Three('F', 'f', 'l');
        assert_eq!(format!("{three}"), "Ffl");
    }
}