lindera-ipadic 3.0.4

A Japanese morphological dictionary for IPADIC.
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

#[cfg(feature = "embed-ipadic")]
use std::env;

use lindera_dictionary::LinderaResult;
use lindera_dictionary::dictionary::Dictionary;
use lindera_dictionary::dictionary::character_definition::CharacterDefinition;
use lindera_dictionary::dictionary::connection_cost_matrix::ConnectionCostMatrix;
use lindera_dictionary::dictionary::metadata::Metadata;
use lindera_dictionary::dictionary::prefix_dictionary::PrefixDictionary;
use lindera_dictionary::dictionary::unknown_dictionary::UnknownDictionary;
use lindera_dictionary::loader::DictionaryLoader;

macro_rules! ipadic_data {
    ($name: ident, $path: literal, $filename: literal) => {
        #[cfg(feature = "embed-ipadic")]
        const $name: &'static [u8] = include_bytes!(concat!(env!("LINDERA_WORKDIR"), $path));
        #[cfg(not(feature = "embed-ipadic"))]
        const $name: &'static [u8] = &[];
    };
}

// Metadata-specific macro (skips compression/decompression processing)
macro_rules! ipadic_metadata {
    ($name: ident, $path: literal, $filename: literal) => {
        #[cfg(feature = "embed-ipadic")]
        const $name: &'static [u8] = include_bytes!(concat!(env!("LINDERA_WORKDIR"), $path));
        #[cfg(not(feature = "embed-ipadic"))]
        const $name: &'static [u8] = &[];
    };
}

ipadic_data!(
    CHAR_DEFINITION_DATA,
    "/lindera-ipadic/char_def.bin",
    "char_def.bin"
);
ipadic_data!(CONNECTION_DATA, "/lindera-ipadic/matrix.mtx", "matrix.mtx");
ipadic_data!(DA_DATA, "/lindera-ipadic/dict.da", "dict.da");
ipadic_data!(VALS_DATA, "/lindera-ipadic/dict.vals", "dict.vals");
ipadic_data!(UNKNOWN_DATA, "/lindera-ipadic/unk.bin", "unk.bin");
ipadic_data!(
    WORDS_IDX_DATA,
    "/lindera-ipadic/dict.wordsidx",
    "dict.wordsidx"
);
ipadic_data!(WORDS_DATA, "/lindera-ipadic/dict.words", "dict.words");
ipadic_metadata!(
    METADATA_DATA,
    "/lindera-ipadic/metadata.json",
    "metadata.json"
);

pub fn load() -> LinderaResult<Dictionary> {
    // Load metadata from embedded binary data
    let metadata = Metadata::load(METADATA_DATA)?;

    Ok(Dictionary {
        prefix_dictionary: PrefixDictionary::load(
            DA_DATA,
            VALS_DATA,
            WORDS_IDX_DATA,
            WORDS_DATA,
            true,
        ),
        connection_cost_matrix: ConnectionCostMatrix::load(CONNECTION_DATA),
        character_definition: CharacterDefinition::load(CHAR_DEFINITION_DATA)?,
        unknown_dictionary: UnknownDictionary::load(UNKNOWN_DATA)?,
        metadata,
    })
}

pub struct EmbeddedIPADICLoader;

impl Default for EmbeddedIPADICLoader {
    fn default() -> Self {
        Self::new()
    }
}

impl EmbeddedIPADICLoader {
    pub fn new() -> Self {
        Self
    }
}

impl DictionaryLoader for EmbeddedIPADICLoader {
    fn load(&self) -> LinderaResult<Dictionary> {
        load()
    }
}