use crate::choseong::Choseong;
use crate::jongseong::Jongseong;
use crate::jungseong::Jungseong;
use crate::nfc::NFC;
use crate::nfd::NFD;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct HangulLetter {
value_chars: [char; 3],
unicode_codes: [u32; 3],
len: u8,
nfc: Option<char>,
pub choseong: Choseong,
pub jungseong: Jungseong,
pub jongseong: Option<Jongseong>,
}
impl HangulLetter {
pub fn parse(string: &str) -> Option<Self> {
if NFC::is_nfc_hangul(string) {
let ch = string.chars().next().unwrap();
let unicode = ch as u32;
let NFD(cho, jung, jong) = NFD::normalize(unicode).unwrap();
let mut value_chars = ['\0'; 3];
let mut unicode_codes = [0u32; 3];
value_chars[0] = ch;
unicode_codes[0] = unicode;
return Some(Self {
value_chars,
unicode_codes,
len: 1,
nfc: Some(ch),
choseong: Choseong::new(cho),
jungseong: Jungseong::new(jung),
jongseong: jong.map(Jongseong::new),
});
}
if NFD::is_nfd_hangul(string) {
let mut value_chars = ['\0'; 3];
let mut unicode_codes = [0u32; 3];
let mut len: u8 = 0;
for ch in string.chars() {
let index = len as usize;
value_chars[index] = ch;
unicode_codes[index] = ch as u32;
len += 1;
}
let choseong = Choseong::new(value_chars[0] as u32);
let jungseong = Jungseong::new(value_chars[1] as u32);
let jongseong = if len == 3 {
Some(Jongseong::new(value_chars[2] as u32))
} else {
None
};
return Some(Self {
value_chars,
unicode_codes,
len,
nfc: None,
choseong,
jungseong,
jongseong,
});
}
return None;
}
pub fn parse_from_char(nfc_char: char) -> Option<Self> {
if NFC::is_nfc_hangul_char(nfc_char) {
let unicode = nfc_char as u32;
let NFD(cho, jung, jong) = NFD::normalize(unicode).unwrap();
let mut value_chars = ['\0'; 3];
let mut unicode_codes = [0u32; 3];
value_chars[0] = nfc_char;
unicode_codes[0] = unicode;
return Some(Self {
value_chars,
unicode_codes,
len: 1,
nfc: Some(nfc_char),
choseong: Choseong::new(cho),
jungseong: Jungseong::new(jung),
jongseong: jong.map(Jongseong::new),
});
}
None
}
pub fn value_chars(&self) -> &[char] {
&self.value_chars[..self.len as usize]
}
pub fn unicode_codes(&self) -> &[u32] {
&self.unicode_codes[..self.len as usize]
}
pub fn value_nfc(&self) -> Option<char> {
self.nfc
}
pub fn value_string(&self) -> String {
self.value_chars().iter().collect()
}
pub fn append_disassembled(&self, output: &mut String) {
for ch in self.disassembled_chars() {
output.push(ch);
}
}
pub fn push_disassembled_chars(&self, output: &mut Vec<char>) {
output.push(self.choseong.compatibility_value);
output.push(self.jungseong.compatibility_value);
if let Some(ref jong) = self.jongseong {
output.extend(jong.decompose_complex_jongseong());
}
}
pub fn disassembled_chars(&self) -> Vec<char> {
let mut chars = Vec::with_capacity(4);
self.push_disassembled_chars(&mut chars);
chars
}
pub fn disassemble(&self) -> String {
let mut result = String::with_capacity(4);
self.append_disassembled(&mut result);
result
}
pub fn has_batchim(&self) -> bool {
self.jongseong.is_some()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_nfc_hangul() {
let hangul = HangulLetter::parse("가").unwrap();
assert_eq!(hangul.value_string(), "가");
assert_eq!(hangul.unicode_codes(), &[0xAC00]);
assert_eq!(hangul.choseong.compatibility_value, 'ㄱ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert!(hangul.jongseong.is_none());
let hangul = HangulLetter::parse("한").unwrap();
assert_eq!(hangul.value_string(), "한");
assert_eq!(hangul.unicode_codes(), &[0xD55C]);
assert_eq!(hangul.choseong.compatibility_value, 'ㅎ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert_eq!(hangul.jongseong.unwrap().compatibility_value, 'ㄴ');
let hangul = HangulLetter::parse("쌍").unwrap();
assert_eq!(hangul.value_string(), "쌍");
assert_eq!(hangul.choseong.compatibility_value, 'ㅆ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert_eq!(hangul.jongseong.unwrap().compatibility_value, 'ㅇ');
let hangul = HangulLetter::parse("귀").unwrap();
assert_eq!(hangul.value_string(), "귀");
assert_eq!(hangul.choseong.compatibility_value, 'ㄱ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅟ');
assert!(hangul.jongseong.is_none());
let hangul = HangulLetter::parse("값").unwrap();
assert_eq!(hangul.value_string(), "값");
assert_eq!(hangul.choseong.compatibility_value, 'ㄱ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert_eq!(hangul.jongseong.unwrap().compatibility_value, 'ㅄ');
}
#[test]
fn test_parse_nfd_hangul() {
let nfd_ga = "\u{1100}\u{1161}";
let hangul = HangulLetter::parse(nfd_ga).unwrap();
assert_eq!(hangul.value_string(), nfd_ga);
assert_eq!(hangul.unicode_codes(), &[0x1100, 0x1161]);
assert_eq!(hangul.choseong.compatibility_value, 'ㄱ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert!(hangul.jongseong.is_none());
let nfd_han = "\u{1112}\u{1161}\u{11AB}";
let hangul = HangulLetter::parse(nfd_han).unwrap();
assert_eq!(hangul.value_string(), nfd_han);
assert_eq!(hangul.unicode_codes(), &[0x1112, 0x1161, 0x11AB]);
assert_eq!(hangul.choseong.compatibility_value, 'ㅎ');
assert_eq!(hangul.jungseong.compatibility_value, 'ㅏ');
assert_eq!(hangul.jongseong.unwrap().compatibility_value, 'ㄴ');
}
#[test]
fn test_parse_from_char() {
let hangul = HangulLetter::parse_from_char('한').unwrap();
assert_eq!(hangul.value_string(), "한");
assert_eq!(hangul.unicode_codes(), &[0xD55C]);
assert!(HangulLetter::parse_from_char('a').is_none());
assert!(HangulLetter::parse_from_char('ㄱ').is_none());
assert!(HangulLetter::parse_from_char('!').is_none());
}
#[test]
fn test_disassemble() {
let hangul = HangulLetter::parse("가").unwrap();
assert_eq!(hangul.disassemble(), "ㄱㅏ");
let hangul = HangulLetter::parse("한").unwrap();
assert_eq!(hangul.disassemble(), "ㅎㅏㄴ");
let hangul = HangulLetter::parse("의").unwrap();
assert_eq!(hangul.disassemble(), "ㅇㅢ");
let hangul = HangulLetter::parse("값").unwrap();
assert_eq!(hangul.disassemble(), "ㄱㅏㅂㅅ");
}
#[test]
fn test_value_nfc_and_lengths() {
let nfc = HangulLetter::parse("가").unwrap();
assert_eq!(nfc.value_nfc(), Some('가'));
assert_eq!(nfc.value_chars().len(), 1);
assert_eq!(nfc.unicode_codes().len(), 1);
let nfd = "\u{1100}\u{1161}";
let hangul = HangulLetter::parse(nfd).unwrap();
assert_eq!(hangul.value_nfc(), None);
assert_eq!(hangul.value_chars().len(), 2);
assert_eq!(hangul.unicode_codes().len(), 2);
let nfd_with_jong = "\u{1100}\u{1161}\u{11BC}";
let hangul = HangulLetter::parse(nfd_with_jong).unwrap();
assert_eq!(hangul.value_nfc(), None);
assert_eq!(hangul.value_chars().len(), 3);
assert_eq!(hangul.unicode_codes().len(), 3);
}
#[test]
fn test_append_disassembled() {
let mut output = String::from("X");
let hangul = HangulLetter::parse("가").unwrap();
hangul.append_disassembled(&mut output);
assert_eq!(output, "Xㄱㅏ");
let mut output = String::from("Y");
let hangul = HangulLetter::parse("값").unwrap();
hangul.append_disassembled(&mut output);
assert_eq!(output, "Yㄱㅏㅂㅅ");
assert_eq!(hangul.disassembled_chars(), vec!['ㄱ', 'ㅏ', 'ㅂ', 'ㅅ']);
}
#[test]
fn test_parse_from_char_with_batchim() {
let hangul = HangulLetter::parse_from_char('값').unwrap();
assert_eq!(hangul.value_string(), "값");
assert!(hangul.jongseong.is_some());
}
#[test]
fn test_has_batchim() {
assert!(HangulLetter::parse("한").unwrap().has_batchim());
assert!(HangulLetter::parse("값").unwrap().has_batchim());
assert!(!HangulLetter::parse("가").unwrap().has_batchim());
assert!(!HangulLetter::parse("뉘").unwrap().has_batchim());
}
#[test]
fn test_invalid_input() {
assert!(HangulLetter::parse("a").is_none());
assert!(HangulLetter::parse("ㄱ").is_none());
assert!(HangulLetter::parse("ㅏ").is_none());
assert!(HangulLetter::parse("ᄀᄀ").is_none());
assert!(HangulLetter::parse("ᅡᅡ").is_none());
assert!(HangulLetter::parse("ᄀᆫ").is_none());
assert!(HangulLetter::parse("").is_none());
assert!(HangulLetter::parse("!").is_none());
assert!(HangulLetter::parse("가나").is_none());
}
}