meco-core 0.4.2

Mongolian Encoding Converter — pure-by-default Rust library and CLI, ported from Java meco.
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

//! Rule dispatch — the Rust replacement for Java's `@Rule/@From/@To` annotation registry and the
//! Spring `RuleHolder`s. Compile-time exhaustive `match` over `CodeType`; rules are zero-sized
//! statics (they hold no data — the big tables are separate statics), so no `LazyLock` is needed.
//!
//! Letter rules (Delehi/MenkLetter) arrive in Step 6. Until then letter dispatch returns
//! `MissTranslateRule` (the router currently reports letter encodings as Unsupported anyway).

use crate::code_type::CodeType;
use crate::error::MecoError;
use crate::letter::delehi::{DelehiFrom, DelehiTo};
use crate::letter::menk::{MenkLetterFrom, MenkLetterTo};
use crate::letter::rule::{LetterTranslateRuleFrom, LetterTranslateRuleTo};
use crate::shape::menk_from::MenkShapeFrom;
use crate::shape::menk_to::MenkShapeTo;
use crate::shape::rule::ShapeTranslateRule;
use crate::shape::z52_from::Z52From;
use crate::shape::z52_to::Z52To;

static Z52_FROM: Z52From = Z52From;
static Z52_TO: Z52To = Z52To;
static MENK_SHAPE_FROM: MenkShapeFrom = MenkShapeFrom;
static MENK_SHAPE_TO: MenkShapeTo = MenkShapeTo;
static DELEHI_FROM: DelehiFrom = DelehiFrom;
static DELEHI_TO: DelehiTo = DelehiTo;
static MENK_LETTER_FROM: MenkLetterFrom = MenkLetterFrom;
static MENK_LETTER_TO: MenkLetterTo = MenkLetterTo;

pub(crate) fn shape_from_rule(ct: CodeType) -> Result<&'static dyn ShapeTranslateRule, MecoError> {
    match ct {
        CodeType::Z52 => Ok(&Z52_FROM),
        CodeType::MenkShape => Ok(&MENK_SHAPE_FROM),
        _ => Err(MecoError::MissTranslateRule(ct)),
    }
}

pub(crate) fn shape_to_rule(ct: CodeType) -> Result<&'static dyn ShapeTranslateRule, MecoError> {
    match ct {
        CodeType::Z52 => Ok(&Z52_TO),
        CodeType::MenkShape => Ok(&MENK_SHAPE_TO),
        _ => Err(MecoError::MissTranslateRule(ct)),
    }
}

pub(crate) fn letter_from_rule(
    ct: CodeType,
) -> Result<&'static dyn LetterTranslateRuleFrom, MecoError> {
    match ct {
        CodeType::Delehi => Ok(&DELEHI_FROM),
        CodeType::MenkLetter => Ok(&MENK_LETTER_FROM),
        // Oyun/Utn57 are handled (Unsupported) in the router before dispatch.
        _ => Err(MecoError::MissTranslateRule(ct)),
    }
}

pub(crate) fn letter_to_rule(ct: CodeType) -> Result<&'static dyn LetterTranslateRuleTo, MecoError> {
    match ct {
        CodeType::Delehi => Ok(&DELEHI_TO),
        CodeType::MenkLetter => Ok(&MENK_LETTER_TO),
        _ => Err(MecoError::MissTranslateRule(ct)),
    }
}