jpreprocess-core 0.13.2

Japanese text preprocessor for Text-to-Speech application (OpenJTalk rewrite in rust language).
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

use std::fmt::Display;

/// A struct to represent a line in a word dictionary file.
///
/// <div class="warning">
///
/// This struct is experimental and may change in the future.
///
/// </div>
#[derive(Clone, PartialEq, Debug)]
pub struct WordDetailsLine {
    pub pos: String,
    pub pos_group1: String,
    pub pos_group2: String,
    pub pos_group3: String,
    pub ctype: String,
    pub cform: String,
    pub orig: String,
    pub read: String,
    pub pron: String,
    pub acc_morasize: String,
    pub chain_rule: String,
    pub chain_flag: String,
}

impl Default for WordDetailsLine {
    fn default() -> Self {
        Self {
            pos: "名詞".to_string(),
            pos_group1: "*".to_string(),
            pos_group2: "*".to_string(),
            pos_group3: "*".to_string(),
            ctype: "*".to_string(),
            cform: "*".to_string(),
            orig: "*".to_string(),
            read: "*".to_string(),
            pron: "*".to_string(),
            acc_morasize: "*/*".to_string(),
            chain_rule: "*".to_string(),
            chain_flag: "*".to_string(),
        }
    }
}

impl WordDetailsLine {
    pub fn from_strs(details: &[&str]) -> Self {
        assert_eq!(details.len(), 12, "line must have exactly 12 columns");

        Self {
            pos: details[0].to_string(),
            pos_group1: details[1].to_string(),
            pos_group2: details[2].to_string(),
            pos_group3: details[3].to_string(),
            ctype: details[4].to_string(),
            cform: details[5].to_string(),
            orig: details[6].to_string(),
            read: details[7].to_string(),
            pron: details[8].to_string(),
            acc_morasize: details[9].to_string(),
            chain_rule: details[10].to_string(),
            chain_flag: details[11].to_string(),
        }
    }

    pub fn to_str_vec(&self, orig: String) -> [String; 12] {
        [
            self.pos.clone(),
            self.pos_group1.clone(),
            self.pos_group2.clone(),
            self.pos_group3.clone(),
            self.ctype.clone(),
            self.cform.clone(),
            orig,
            self.read.clone(),
            self.pron.clone(),
            self.acc_morasize.clone(),
            self.chain_rule.clone(),
            self.chain_flag.clone(),
        ]
    }
}

impl Display for WordDetailsLine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{},{},{},{},{},{},{},{},{},{},{},{}",
            self.pos,
            self.pos_group1,
            self.pos_group2,
            self.pos_group3,
            self.ctype,
            self.cform,
            self.orig,
            self.read,
            self.pron,
            self.acc_morasize,
            self.chain_rule,
            self.chain_flag
        )
    }
}

#[cfg(test)]
mod tests {
    use crate::word_details::WordDetails;

    use super::WordDetailsLine;

    #[test]
    fn default_same_with_details() {
        let default = WordDetails::default();
        let details = WordDetailsLine::default().try_into().unwrap();
        assert_eq!(default, details);
    }
}