obadh_engine 0.8.1

A linguistically accurate Roman to Bengali transliteration engine
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

use super::super::tokenizer::{Token, TokenType};

#[derive(Clone, Copy, Default)]
pub(super) struct TokenNumberBoundary {
    can_contain_number: bool,
    ends_with_number: bool,
}

impl TokenNumberBoundary {
    #[inline]
    pub(super) const fn from_number_state(ends_with_number: bool) -> Self {
        Self {
            can_contain_number: true,
            ends_with_number,
        }
    }
}

#[inline]
pub(super) fn is_decimal_separator_at(
    text: &str,
    byte_index: usize,
    current_char_len: usize,
    current_word: Option<TokenNumberBoundary>,
    previous_boundary: TokenNumberBoundary,
) -> bool {
    if &text[byte_index..byte_index + current_char_len] != "." {
        return false;
    }

    let previous = current_word.unwrap_or(previous_boundary);

    previous.can_contain_number
        && previous.ends_with_number
        && next_token_starts_with_number(text, byte_index + current_char_len)
}

#[inline]
fn next_token_starts_with_number(text: &str, byte_index: usize) -> bool {
    text.get(byte_index..)
        .and_then(|suffix| suffix.chars().next())
        .is_some_and(|character| character.is_numeric())
}

#[inline]
pub(super) fn is_decimal_separator(tokens: &[Token], index: usize) -> bool {
    if tokens[index].content != "." || index == 0 || index + 1 >= tokens.len() {
        return false;
    }

    let previous = &tokens[index - 1];
    let next = &tokens[index + 1];

    if previous.token_type == TokenType::Number && next.token_type == TokenType::Number {
        return true;
    }

    token_can_contain_number(previous)
        && token_can_contain_number(next)
        && token_ends_with_number(previous)
        && token_starts_with_number(next)
}

#[inline]
fn token_can_contain_number(token: &Token) -> bool {
    matches!(token.token_type, TokenType::Word | TokenType::Number)
}

#[inline]
fn token_ends_with_number(token: &Token) -> bool {
    token
        .content
        .chars()
        .next_back()
        .is_some_and(|character| character.is_numeric())
}

#[inline]
fn token_starts_with_number(token: &Token) -> bool {
    token
        .content
        .chars()
        .next()
        .is_some_and(|character| character.is_numeric())
}