munyo 0.8.0

A data language which aims to be the most efficient way to handwrite data.
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
117
118
119
120
121
122

pub(crate) struct State {
    indent_level: usize,
    default_stack: Vec<DefaultTypes>,
    leveled_default: Vec<Option<(String, String)>>,
    super_leveled_default: Vec<Option<(String, String)>>,
}

pub(crate) struct DefaultTypes {
    default_type: String,
    empty_line_type: String,
    indent_level: usize,
}

impl DefaultTypes {
    pub(crate) fn new(default_type: String, empty_line_type: String, indent_level: usize) -> Self {
        Self {
            default_type,
            empty_line_type,
            indent_level,
        }
    }
}

impl State {
    pub(crate) fn new() -> State {
        State {
            indent_level: 0,
            default_stack: vec![],
            leveled_default: vec![],
            super_leveled_default: vec![],
        }
    }
    pub(crate) fn indent_level(&self) -> usize {
        self.indent_level
    }

    pub(crate) fn set_indent(&mut self, indent_level: usize) -> Result<(), String> {
        if self.indent_level + 2 <= indent_level {
            Err("The indent is too deep.")?
        }
        self.indent_level = indent_level;
        self.set_stacks_indent_level(indent_level);
        if indent_level + 1 < self.leveled_default.len() {
            unsafe { self.leveled_default.set_len(indent_level + 1) }
        }
        Ok(())
    }

    fn set_stacks_indent_level(&mut self, level: usize) {
        while level < self.peek_indent().unwrap_or(0) {
            self.default_stack.pop();
        }
    }

    fn peek_indent(&self) -> Option<usize> {
        self.default_stack.last().map(|item| item.indent_level)
    }

    pub(crate) fn set_doubled_default_types(
        &mut self,
        indent_level: usize,
        default_type: String,
        empty_line_type: String,
    ) {
        if self.peek_indent() == Some(indent_level) {
            self.default_stack.pop();
        }

        self.default_stack.push(DefaultTypes::new(
            default_type,
            empty_line_type,
            indent_level,
        ))
    }

    pub(crate) fn set_single_default_types(
        &mut self,
        indent_level: usize,
        default_type: String,
        empty_line_type: String,
    ) {
        while self.leveled_default.len() <= indent_level {
            self.leveled_default.push(None);
        }

        self.leveled_default[indent_level] = Some((default_type, empty_line_type))
    }

    pub(crate) fn set_tripled_default_types(
        &mut self,
        indent_level: usize,
        default_type: String,
        empty_line_type: String,
    ) {
        while self.super_leveled_default.len() <= indent_level {
            self.super_leveled_default.push(None);
        }

        self.super_leveled_default[indent_level] = Some((default_type, empty_line_type));
    }

    pub(crate) fn default_types(&self) -> (&str, &str) {
		fn get(leveled_default : &Vec<Option<(String,String)>>, indent_level : usize) -> Option<(&str, &str)>{
			if let Some(Some((def, emp))) = leveled_default.get(indent_level){
				if def.len() != 0 || emp.len() != 0{
					return Some((def, emp));
				}
			}
			None
		}
        if let Some((def, emp)) = get(&self.leveled_default, self.indent_level) {
            return (def, emp);
        }
        if let Some((def, emp)) = get(&self.super_leveled_default, self.indent_level) {
            return (def, emp);
        }
        if let Some(last) = self.default_stack.last() {
            return (&last.default_type, &last.empty_line_type);
        }
        ("", "")
    }
}