roe 0.0.11

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use core::fmt;
use core::iter::FusedIterator;
use core::ops::Range;

use bstr::ByteSlice;

use crate::unicode::mapping::{Mode, lookup};
use crate::unicode::std_case_mapping_iter::CaseMappingIter;

#[derive(Clone)]
#[must_use = "Swapcase is a Iterator and must be used"]
pub struct Swapcase<'a> {
    slice: &'a [u8],
    next_bytes: [u8; 4],
    next_range: Range<usize>,
    swapcase: Option<CaseMappingIter>,
    mode: Mode,
}

impl fmt::Debug for Swapcase<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Swapcase")
            .field("slice", &self.slice.as_bstr())
            .field("next_bytes", &self.next_bytes)
            .field("next_range", &self.next_range)
            .field("swapcase", &self.swapcase)
            .field("mode", &self.mode)
            .finish()
    }
}

impl<'a> From<&'a [u8]> for Swapcase<'a> {
    fn from(slice: &'a [u8]) -> Self {
        Self::with_slice(slice)
    }
}

impl<'a> Swapcase<'a> {
    pub const fn with_slice(slice: &'a [u8]) -> Self {
        Self::with_mode(slice, Mode::Swap)
    }

    pub const fn with_mode(slice: &'a [u8], mode: Mode) -> Self {
        Self {
            slice,
            next_bytes: [0; 4],
            next_range: 0..0,
            swapcase: None,
            mode,
        }
    }

    fn buffered_len(&self) -> usize {
        let mapped = self
            .swapcase
            .clone()
            .map_or(0, |iter| iter.map(char::len_utf8).sum());
        self.next_range.len() + mapped
    }
}

impl Iterator for Swapcase<'_> {
    type Item = u8;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(idx) = self.next_range.next() {
            debug_assert!(self.next_bytes.get(idx).is_some());

            return Some(self.next_bytes[idx]);
        }

        if let Some(ch) = self.swapcase.as_mut().and_then(Iterator::next) {
            let enc = ch.encode_utf8(&mut self.next_bytes);

            self.next_range = 1..enc.len();
            debug_assert!(self.next_bytes.get(self.next_range.clone()).is_some());

            return Some(self.next_bytes[0]);
        }

        self.swapcase = None;

        // Buffered Unicode output must be drained before consuming a new byte.
        if let Some((&byte, remainder)) = self.slice.split_first() {
            if byte.is_ascii() && !(self.mode.is_turkic() && matches!(byte, b'I' | b'i')) {
                self.slice = remainder;
                return Some(super::ascii::swapcase_byte(byte));
            }
        }

        match bstr::decode_utf8(self.slice) {
            (_, 0) => None,
            (Some(ch), size) => {
                self.slice = &self.slice[size..];
                let mut swapcase = lookup(ch, self.mode);
                let ch = swapcase
                    .next()
                    .expect("case mapping yields at least one char");
                let enc = ch.encode_utf8(&mut self.next_bytes);

                self.next_range = 1..enc.len();
                debug_assert!(self.next_bytes.get(self.next_range.clone()).is_some());

                self.swapcase = Some(swapcase);
                Some(self.next_bytes[0])
            }
            (None, size) => {
                let (bytes, remainder) = self.slice.split_at(size);
                self.slice = remainder;

                // Invalid byte sequences are at most three bytes.
                debug_assert!(self.next_bytes.get(..bytes.len()).is_some());

                self.next_bytes[..bytes.len()].copy_from_slice(bytes);
                self.next_range = 1..bytes.len();
                Some(self.next_bytes[0])
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        const CASE_MAPPING_MAX_BYTES: usize = 3 * 4;
        let buffered = self.buffered_len();
        let len = self.slice.len();
        if self.slice.is_ascii() && !self.mode.is_turkic() {
            let len = buffered + len;
            (len, Some(len))
        } else {
            // A decoded character consumes at most four input bytes and yields
            // at least one output byte. Invalid UTF-8 is passed through. Input
            // byte length is not a lower bound: e.g. dotless i maps to ASCII I.
            let min = buffered.saturating_add(len.div_ceil(4));
            let max = len
                .checked_mul(CASE_MAPPING_MAX_BYTES)
                .and_then(|len| len.checked_add(buffered));
            (min, max)
        }
    }

    fn count(self) -> usize {
        if self.slice.is_ascii() && !self.mode.is_turkic() {
            self.buffered_len() + self.slice.len()
        } else {
            self.fold(0, |acc, _| acc + 1)
        }
    }
}

impl FusedIterator for Swapcase<'_> {}