use alloc::string::String;
use alloc::vec::Vec;
const THE_FIRST_STAND_IN: u32 = 0xE000;
const THE_FIRST_SURROGATE: u32 = 0xD800;
const THE_LAST_SURROGATE: u32 = 0xDFFF;
fn the_stand_in_of(unit: u16) -> char {
let code = THE_FIRST_STAND_IN + (unit as u32 - THE_FIRST_SURROGATE);
char::from_u32(code).unwrap_or(char::REPLACEMENT_CHARACTER)
}
pub(crate) fn the_surrogate_of_a_character(character: char) -> Option<u16> {
let code = character as u32;
if !(THE_FIRST_STAND_IN..THE_FIRST_STAND_IN + 0x800).contains(&code) {
return None;
}
Some((code - THE_FIRST_STAND_IN) as u16 + THE_FIRST_SURROGATE as u16)
}
pub(crate) fn the_code_units_of(text: &str) -> Vec<u16> {
let mut units = Vec::with_capacity(text.len());
for character in text.chars() {
if let Some(unit) = the_surrogate_of_a_character(character) {
units.push(unit);
continue;
}
let code = character as u32;
if code > 0xFFFF {
let code = code - 0x10000;
units.push(0xD800 + (code >> 10) as u16);
units.push(0xDC00 + (code & 0x3FF) as u16);
} else {
units.push(code as u16);
}
}
units
}
pub(crate) fn the_number_of_the_code_units(text: &str) -> usize {
text.chars()
.map(|character| {
if the_surrogate_of_a_character(character).is_some() || (character as u32) <= 0xFFFF {
1
} else {
2
}
})
.sum()
}
pub(crate) fn the_text_of(units: &[u16]) -> String {
let mut text = String::with_capacity(units.len());
let mut at = 0;
while at < units.len() {
let unit = units[at];
if (0xD800..=0xDBFF).contains(&unit)
&& units
.get(at + 1)
.map(|next| (0xDC00..=0xDFFF).contains(next))
.unwrap_or(false)
{
let high = (unit - 0xD800) as u32;
let low = (units[at + 1] - 0xDC00) as u32;
let code = 0x10000 + (high << 10) + low;
text.push(char::from_u32(code).unwrap_or(char::REPLACEMENT_CHARACTER));
at += 2;
continue;
}
if (THE_FIRST_SURROGATE..=THE_LAST_SURROGATE).contains(&(unit as u32)) {
text.push(the_stand_in_of(unit));
} else {
text.push(char::from_u32(unit as u32).unwrap_or(char::REPLACEMENT_CHARACTER));
}
at += 1;
}
text
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_lone_surrogate_is_one_unit_of_its_own() {
let text = the_text_of(&[0xD83D]);
assert_eq!(the_number_of_the_code_units(&text), 1);
assert_eq!(the_code_units_of(&text), vec![0xD83D]);
}
#[test]
fn a_pair_is_two_units_and_one_character() {
let text = the_text_of(&[0xD83D, 0xDE00]);
assert_eq!(the_number_of_the_code_units(&text), 2);
assert_eq!(the_code_units_of(&text), vec![0xD83D, 0xDE00]);
assert_eq!(text.chars().count(), 1);
}
#[test]
fn the_units_of_a_text_come_back_the_same() {
for text in ["", "hello", "a😀b", "héllo"] {
let units = the_code_units_of(text);
assert_eq!(the_text_of(&units), text);
assert_eq!(the_number_of_the_code_units(text), units.len());
}
}
}