jp_utils 0.1.7

Utils for working with Japanese text.
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

use crate::furi::segment::kanji::as_kanji::AsKanjiSegment;
use std::str::Chars;

/// Iterator over kanji literals and their readings.
pub struct LitReadingsIter<'a, K> {
    kanji: &'a K,
    lit_iter: Option<Chars<'a>>,
    pos: usize,
    detailed: bool,
}

impl<'a, K> LitReadingsIter<'a, K>
where
    K: AsKanjiSegment,
{
    /// Returns a new LitReadingsIter if the passed segment was a kanji segment.
    #[inline]
    pub(crate) fn new(kanji: &'a K) -> Self {
        let detailed = kanji.is_detailed();
        let lit_iter = detailed.then(|| kanji.literals().as_ref().chars());
        Self {
            kanji,
            lit_iter,
            pos: 0,
            detailed,
        }
    }
}

impl<'a, S> Iterator for LitReadingsIter<'a, S>
where
    S: AsKanjiSegment,
{
    type Item = (String, String);

    fn next(&mut self) -> Option<Self::Item> {
        // Handle non detailed kanji
        if !self.detailed {
            if self.pos > 0 {
                return None;
            }

            self.pos = 1;
            let kana = self.kanji.full_reading();
            let kanji = self.kanji.literals().as_ref().to_string();
            return Some((kanji, kana));
        }

        // Safety:
        // For detailed kanji we always set this iterator in the constructor.
        let lit = unsafe { self.lit_iter.as_mut().unwrap_unchecked() }.next()?;

        let reading = self.kanji.readings()[self.pos].as_ref().to_string();

        self.pos += 1;
        Some((lit.to_string(), reading))
    }
}

#[cfg(test)]
mod test {
    use crate::furi::segment::{AsSegment, SegmentRef};

    use super::*;
    use test_case::test_case;

    #[test_case("[音楽|おん|がく]", &[("音","おん"), ("楽","がく")])]
    #[test_case("[大学|だい|がく]", &[("大","だい"), ("学","がく")])]
    #[test_case("[大学|だいがく]", &[("大学","だいがく")])]
    fn test_lit_readings_iter(s: &str, exp: &[(&str, &str)]) {
        let seg = SegmentRef::from_str_checked(s).unwrap();
        assert!(seg.is_kanji());

        let mut iter = LitReadingsIter::new(seg.as_kanji().unwrap());
        for (e_lit, e_read) in exp {
            let (got_lit, got_read) = iter.next().unwrap();
            assert_eq!(*e_lit, got_lit);
            assert_eq!(*e_read, got_read);
        }

        assert_eq!(iter.next(), None);
    }
}