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

use super::{
    as_kanji::{AsKanjiRef, AsKanjiSegment},
    Kanji,
};
use tinyvec::TinyVec;

#[derive(Clone, PartialEq, Debug, Eq, Hash)]
#[cfg_attr(feature = "with_serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KanjiRef<'a> {
    lit: &'a str,
    readings: TinyVec<[&'a str; 1]>,
}

impl<'a> KanjiRef<'a> {
    #[inline]
    pub fn new(lit: &'a str, readings: &[&'a str]) -> Self {
        let r = readings.into();
        Self { lit, readings: r }
    }

    #[inline]
    pub(crate) fn new_raw(lit: &'a str, readings: TinyVec<[&'a str; 1]>) -> Self {
        Self { lit, readings }
    }

    /// Converts the Kanji reference to an owned [`Kanji`].
    pub fn to_owned(&self) -> Kanji {
        let readings: Vec<_> = self.readings.iter().map(|i| i.to_string()).collect();
        Kanji::new(self.lit.to_string(), &readings)
    }
}

impl<'a> AsKanjiSegment for KanjiRef<'a> {
    type StrType = &'a str;

    #[inline]
    fn literals(&self) -> &Self::StrType {
        &self.lit
    }

    #[inline]
    fn readings(&self) -> &[Self::StrType] {
        self.readings.as_slice()
    }
}

impl<'a> AsKanjiRef<'a> for KanjiRef<'a> {
    #[inline]
    fn as_kanji_ref(&self) -> KanjiRef<'a> {
        self.clone()
    }
}

impl<'a> AsKanjiRef<'a> for &KanjiRef<'a> {
    #[inline]
    fn as_kanji_ref(&self) -> KanjiRef<'a> {
        (*self).as_kanji_ref()
    }
}

impl<'a> PartialEq<Kanji> for KanjiRef<'a> {
    #[inline]
    fn eq(&self, other: &Kanji) -> bool {
        self.literals() == other.literals()
            && self
                .readings()
                .iter()
                .zip(other.readings().iter())
                .all(|i| i.0 == i.1)
    }
}

impl<'a> PartialEq<Kanji> for &'a KanjiRef<'a> {
    #[inline]
    fn eq(&self, other: &Kanji) -> bool {
        (*self).eq(other)
    }
}