ratex-parser 0.1.5

LaTeX parser for RaTeX
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

//! Parser buffer (mirrors KaTeX mhchem `buffer` object).

#[derive(Clone, Default, Debug)]
pub struct Buffer {
    pub parenthesis_level: i32,
    pub begins_with_bond: bool,
    pub sb: bool,
    pub a: Option<String>,
    pub b: Option<String>,
    pub p: Option<String>,
    pub o: Option<String>,
    pub q: Option<String>,
    pub d: Option<String>,
    pub d_type: Option<String>,
    pub r: Option<String>,
    pub rdt: Option<String>,
    pub rd: Option<String>,
    pub rqt: Option<String>,
    pub rq: Option<String>,
    pub text_: Option<String>,
    pub rm: Option<String>,
}

impl Buffer {
    pub fn new() -> Self {
        Self {
            parenthesis_level: 0,
            begins_with_bond: false,
            ..Default::default()
        }
    }

    /// Clear all fields except `parenthesis_level` and `begins_with_bond`.
    /// Clears inner [`String`] content to preserve capacity for reuse.
    pub fn clear_soft(&mut self) {
        self.sb = false;
        clear_opt_string(&mut self.a);
        clear_opt_string(&mut self.b);
        clear_opt_string(&mut self.p);
        clear_opt_string(&mut self.o);
        clear_opt_string(&mut self.q);
        clear_opt_string(&mut self.d);
        clear_opt_string(&mut self.d_type);
        clear_opt_string(&mut self.r);
        clear_opt_string(&mut self.rdt);
        clear_opt_string(&mut self.rd);
        clear_opt_string(&mut self.rqt);
        clear_opt_string(&mut self.rq);
        clear_opt_string(&mut self.text_);
        clear_opt_string(&mut self.rm);
    }

    /// Returns `true` if the slot is `None` or contains an empty string.
    pub fn is_slot_empty(slot: &Option<String>) -> bool {
        slot.as_ref().is_none_or(|s| s.is_empty())
    }

    /// Assigns `v` to the slot, reusing existing [`String`] capacity when possible.
    pub fn set_slot(slot: &mut Option<String>, v: String) {
        match slot {
            Some(s) => {
                s.clear();
                s.push_str(&v);
            }
            None => *slot = Some(v),
        }
    }

    pub fn clear_all(&mut self) {
        *self = Self::new();
    }
}

/// Clear the inner [`String`] if present, preserving its allocation for reuse.
fn clear_opt_string(slot: &mut Option<String>) {
    if let Some(s) = slot {
        s.clear();
    }
}