use super::compose_tables as tables;
#[must_use]
pub fn ccc(c: char) -> u8 {
let v = c as u32;
let t = tables::CCC;
let mut lo = 0usize;
let mut hi = t.len();
while lo < hi {
let mid = (lo + hi) / 2;
let (first, last, k) = t[mid];
if v < first {
hi = mid;
} else if v > last {
lo = mid + 1;
} else {
return k;
}
}
0
}
mod hangul {
pub const L_BASE: u32 = 0x1100;
pub const V_BASE: u32 = 0x1161;
pub const T_BASE: u32 = 0x11A7;
pub const S_BASE: u32 = 0xAC00;
pub const L_COUNT: u32 = 19;
pub const V_COUNT: u32 = 21;
pub const T_COUNT: u32 = 28;
pub const S_COUNT: u32 = L_COUNT * V_COUNT * T_COUNT;
}
#[must_use]
pub fn compose_pair(a: char, b: char) -> Option<char> {
use hangul::{L_BASE, L_COUNT, S_BASE, S_COUNT, T_BASE, T_COUNT, V_BASE, V_COUNT};
let (x, y) = (a as u32, b as u32);
let l = x.wrapping_sub(L_BASE);
let v = y.wrapping_sub(V_BASE);
if l < L_COUNT && v < V_COUNT {
return char::from_u32(S_BASE + (l * V_COUNT + v) * T_COUNT);
}
let s = x.wrapping_sub(S_BASE);
let t = y.wrapping_sub(T_BASE);
if s < S_COUNT && s % T_COUNT == 0 && t > 0 && t < T_COUNT {
return char::from_u32(x + t);
}
let table = tables::PAIRS;
let mut lo = 0usize;
let mut hi = table.len();
while lo < hi {
let mid = (lo + hi) / 2;
let (pa, pb, pc) = table[mid];
match (pa, pb).cmp(&(x, y)) {
core::cmp::Ordering::Less => lo = mid + 1,
core::cmp::Ordering::Greater => hi = mid,
core::cmp::Ordering::Equal => return char::from_u32(pc),
}
}
None
}
fn reorder(s: &mut [(char, usize)]) {
for i in 1..s.len() {
let k = ccc(s[i].0);
if k == 0 {
continue;
}
let mut j = i;
while j > 0 {
let prev = ccc(s[j - 1].0);
if prev == 0 || prev <= k {
break;
}
s.swap(j - 1, j);
j -= 1;
}
}
}
#[must_use]
pub fn compose(text: &[char]) -> Vec<(char, usize)> {
let mut out: Vec<(char, usize)> = text.iter().copied().zip(0..).collect();
reorder(&mut out);
let mut result: Vec<(char, usize)> = Vec::with_capacity(out.len());
let mut starter: Option<usize> = None;
let mut blocker = 0u8;
for (c, at) in out {
let k = ccc(c);
if let Some(s) = starter {
let blocked = if k == 0 { blocker != 0 } else { blocker >= k };
if !blocked && let Some(joined) = compose_pair(result[s].0, c) {
result[s].0 = joined;
continue;
}
}
if k == 0 {
starter = Some(result.len());
blocker = 0;
} else {
blocker = blocker.max(k);
}
result.push((c, at));
}
result
}
#[must_use]
pub fn composed(text: &[char]) -> Vec<char> {
compose(text).into_iter().map(|(c, _)| c).collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn run(s: &str) -> Vec<char> {
composed(&s.chars().collect::<Vec<_>>())
}
#[test]
fn a_caption_with_a_decomposed_accent_is_one_glyph_per_letter() {
assert_eq!(run("Noe\u{0308}l"), "Noël".chars().collect::<Vec<_>>());
assert_eq!(
run("e\u{0301}te\u{0301}"),
"été".chars().collect::<Vec<_>>()
);
}
#[test]
fn a_pair_composes() {
assert_eq!(run("t\u{0308}"), vec!['\u{1E97}']);
assert_eq!(run("a\u{0301}"), vec!['\u{00E1}']);
assert_eq!(run("A\u{030A}\u{0301}"), vec!['\u{01FA}']);
}
#[test]
fn an_equal_class_blocks() {
assert_eq!(run("a\u{0301}\u{0308}"), vec!['\u{00E1}', '\u{0308}']);
}
#[test]
fn a_lower_class_does_not_block() {
assert_eq!(run("a\u{0308}\u{0327}"), vec!['\u{00E4}', '\u{0327}']);
assert_eq!(run("a\u{0327}\u{0308}"), vec!['\u{00E4}', '\u{0327}']);
}
#[test]
fn a_composed_mark_stops_blocking() {
assert_eq!(run("a\u{0308}\u{0304}"), vec!['\u{01DF}']);
assert_eq!(run("a\u{0301}\u{0308}"), vec!['\u{00E1}', '\u{0308}']);
}
#[test]
fn reordering_is_stable_within_a_class() {
let a: Vec<char> = "\u{0F74}\u{0F71}".chars().collect();
assert_eq!(compose(&a), vec![('\u{0F71}', 1), ('\u{0F74}', 0)]);
let b: Vec<char> = "\u{0F71}\u{0F71}".chars().collect();
assert_eq!(compose(&b), vec![('\u{0F71}', 0), ('\u{0F71}', 1)]);
}
#[test]
fn hangul_composes_arithmetically() {
assert_eq!(run("\u{1100}\u{1161}"), vec!['\u{AC00}']);
assert_eq!(run("\u{1100}\u{1161}\u{11A8}"), vec!['\u{AC01}']);
assert_eq!(run("\u{AC00}\u{11A8}"), vec!['\u{AC01}']);
assert_eq!(run("\u{AC01}\u{11A8}"), vec!['\u{AC01}', '\u{11A8}']);
}
#[test]
fn a_composition_exclusion_stays_apart() {
assert_eq!(run("\u{0915}\u{093C}"), vec!['\u{0915}', '\u{093C}']);
}
#[test]
fn nothing_is_decomposed() {
assert_eq!(run("\u{2126}"), vec!['\u{2126}']);
assert_eq!(run("\u{212B}"), vec!['\u{212B}']);
}
#[test]
fn the_source_index_follows_the_base() {
let text: Vec<char> = "xt\u{0308}y".chars().collect();
let got = compose(&text);
assert_eq!(got, vec![('x', 0), ('\u{1E97}', 1), ('y', 3)]);
}
#[test]
fn a_lone_mark_survives() {
assert_eq!(run("\u{0308}"), vec!['\u{0308}']);
assert_eq!(run(""), Vec::<char>::new());
}
#[test]
fn the_combining_class_table_reads() {
assert_eq!(ccc('a'), 0);
assert_eq!(ccc('\u{0308}'), 230);
assert_eq!(ccc('\u{0327}'), 202);
assert_eq!(ccc('\u{05B0}'), 10);
}
}