IndicScriptSwap 0.6.0

This is a tool to help transliterate between various indic scripts. It is not ready yet and has many issues. If you encounter any issues, please contact me (https://github.com/mssrprad/transliterate-ferris/tree/cli or pradyumna.malladi2003@gmail.com)
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 crate::read_mappings::Script;
use std::collections::HashMap;

#[derive(PartialEq, Debug)]
pub enum CharType {
    ConsonantsMain,
    CombiningSignsAyogavaha,
    VowelsMain,
    VowelSignsMain,
    VowelSignsVirama,
    Numerals,
    OthersSymbols,
    OthersAytham,
    Space,
    NewLine,
    CouldNotIdentify,
}

pub fn identify_type(
    c: &str,
    hash_map_consonants_main: &HashMap<&str, &str>,
    hash_map_vowels_main: &HashMap<&str, &str>,
    hash_map_vowelsigns_main: &HashMap<&str, &str>,
    hash_map_vowelsigns_virama: &HashMap<&str, &str>,
    hash_map_numerals: &HashMap<&str, &str>,
    hash_map_others_aytham: &HashMap<&str, &str>,
    hash_map_combining_signs_ayogavaha: &HashMap<&str, &str>,
    hash_map_others_symbols: &HashMap<&str, &str>,
) -> CharType {
    if hash_map_consonants_main.contains_key(&*c.to_string()) {
        return CharType::ConsonantsMain;
    } else if hash_map_combining_signs_ayogavaha.contains_key(&*c.to_string()) {
        return CharType::CombiningSignsAyogavaha;
    } else if hash_map_vowels_main.contains_key(&*c.to_string()) {
        return CharType::VowelsMain;
    } else if hash_map_vowelsigns_main.contains_key(&*c.to_string()) {
        return CharType::VowelSignsMain;
    } else if hash_map_vowelsigns_virama.contains_key(&*c.to_string()) {
        return CharType::VowelSignsVirama;
    } else if hash_map_numerals.contains_key(&*c.to_string()) {
        return CharType::Numerals;
    } else if hash_map_others_symbols.contains_key(&*c.to_string()) {
        return CharType::OthersSymbols;
    } else if hash_map_others_aytham.contains_key(&*c.to_string()) {
        return CharType::OthersAytham;
    } else if c == " " {
        return CharType::Space;
    } else if c == "\n" {
        return CharType::NewLine;
    } else {
        return CharType::CouldNotIdentify;
    }
}

pub fn make_hash_map<'a>(
    source: &'a Script,
    destination: &'a Script,
    t: usize,
) -> HashMap<&'a str, &'a str> {
    let mut hash_map: HashMap<&str, &str> = HashMap::new();
    let mut v = Vec::new();
    match t {
        0 => {
            v = vec![
                (&source.consonants.main, &destination.consonants.main),
                (&source.vowels.main, &destination.vowels.main),
                (&source.vowelsigns.main, &destination.vowelsigns.main),
                (&source.vowelsigns.virama, &destination.vowelsigns.virama),
                (&source.numerals, &destination.numerals),
                (&source.others.aytham, &destination.others.aytham),
                (&source.others.symbols, &destination.others.symbols),
                (
                    &source.combiningsigns.ayogavaha,
                    &destination.combiningsigns.ayogavaha,
                ),
            ];
        }
        1 => {
            v = vec![(&source.consonants.main, &destination.consonants.main)];
        }
        2 => {
            v = vec![(&source.vowels.main, &destination.vowels.main)];
        }
        3 => {
            v = vec![(&source.vowelsigns.main, &destination.vowelsigns.main)];
        }
        4 => {
            v = vec![(&source.vowelsigns.virama, &destination.vowelsigns.virama)];
        }
        5 => {
            v = vec![(&source.numerals, &destination.numerals)];
        }
        6 => {
            v = vec![(&source.others.aytham, &destination.others.aytham)];
        }
        7 => {
            v = vec![(
                &source.combiningsigns.ayogavaha,
                &destination.combiningsigns.ayogavaha,
            )];
        }
        8 => {
            v = vec![(&source.others.symbols, &destination.others.symbols)];
        }
        _ => {}
    }
    for (s, d) in v {
        hash_map.extend(
            s.iter()
                .zip(d.iter())
                .map(|(k, v)| (k.as_str(), v.as_str())),
        );
    }

    return hash_map;
}