litchi 0.0.1

High-performance parser for Microsoft Office, OpenDocument, and Apple iWork file formats with unified API
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

use super::node::MathNode;
use bumpalo::Bump;
use std::borrow::Cow;

/// Builder for constructing formula nodes efficiently
pub struct FormulaBuilder<'arena> {
    arena: &'arena Bump,
}

impl<'arena> FormulaBuilder<'arena> {
    /// Create a new builder with the given arena
    pub fn new(arena: &'arena Bump) -> Self {
        Self { arena }
    }

    /// Allocate a string in the arena
    pub fn alloc_str(&self, s: &str) -> &'arena str {
        self.arena.alloc_str(s)
    }

    /// Create a text node
    pub fn text(&self, text: impl Into<Cow<'arena, str>>) -> MathNode<'arena> {
        MathNode::Text(text.into())
    }

    /// Create a number node
    pub fn number(&self, num: impl Into<Cow<'arena, str>>) -> MathNode<'arena> {
        MathNode::Number(num.into())
    }

    /// Create a fraction node
    pub fn frac(
        &self,
        numerator: Vec<MathNode<'arena>>,
        denominator: Vec<MathNode<'arena>>,
    ) -> MathNode<'arena> {
        MathNode::Frac {
            numerator,
            denominator,
            line_thickness: None,
            frac_type: None,
        }
    }

    /// Create a square root node
    pub fn sqrt(&self, base: Vec<MathNode<'arena>>) -> MathNode<'arena> {
        MathNode::Root {
            base,
            index: None,
        }
    }

    /// Create an nth root node
    pub fn root(
        &self,
        base: Vec<MathNode<'arena>>,
        index: Vec<MathNode<'arena>>,
    ) -> MathNode<'arena> {
        MathNode::Root {
            base,
            index: Some(index),
        }
    }

    /// Create a power node
    pub fn power(
        &self,
        base: Vec<MathNode<'arena>>,
        exponent: Vec<MathNode<'arena>>,
    ) -> MathNode<'arena> {
        MathNode::Power {
            base,
            exponent,
        }
    }

    /// Create a subscript node
    pub fn sub(
        &self,
        base: Vec<MathNode<'arena>>,
        subscript: Vec<MathNode<'arena>>,
    ) -> MathNode<'arena> {
        MathNode::Sub {
            base,
            subscript,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::formula::ast::Formula;

    #[test]
    fn test_builder() {
        let formula = Formula::new();
        let builder = FormulaBuilder::new(formula.arena());
        
        let node = builder.text("x");
        match node {
            MathNode::Text(ref text) => assert_eq!(text, "x"),
            _ => panic!("Expected text node"),
        }
    }
}