mathml-rs 0.1.2

MathML parser written in Rust.
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

use super::lambda::Lambda;
use super::math_node::{MathNode, MathNodeType, NodeIndex};
use super::op::Op;
use std::fmt;

#[derive(Default, Debug, Clone, Eq, PartialEq)]
pub struct Apply {
    pub children: Vec<NodeIndex>,
    pub operator: Option<NodeIndex>,
    pub operands: Vec<NodeIndex>,
    pub parent: Option<NodeIndex>,
}

impl Apply {
    pub fn index(&mut self, _tag_type: MathNodeType, location: NodeIndex) {
        if self.children.len() == 1 {
            self.operator = Some(location);
        } else {
            self.operands.push(location);
        }
    }

    pub fn get_op(&self, nodes: &[MathNode]) -> Result<Op, &'static str> {
        let operator_idx = self.operator.expect("No operator found!");
        if let MathNode::Op(opnode) = &nodes[operator_idx] {
            return Ok(opnode.op.clone().unwrap());
        }
        Err("Not a regular mathematical operator.")
    }

    pub fn get_lambda(&self, nodes: &[MathNode]) -> Result<Lambda, &'static str> {
        let operator_idx = self.operator.expect("No operator found!");
        if let MathNode::Lambda(lambda) = &nodes[operator_idx] {
            return Ok(lambda.clone());
        }
        Err("Not a lambda function.")
    }
}

impl fmt::Display for Apply {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Operator: {:?}, Operands: {:?}, Children: {:?}, Parent: {:?}",
            self.operator, self.operands, self.children, self.parent
        )
    }
}