mathlex 0.2.0

Mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic AST
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

public func parseText<GenericToRustStr: ToRustStr>(_ input: GenericToRustStr) throws -> Expression {
    return input.toRustStr({ inputAsRustStr in
        try { let val = __swift_bridge__$parse_text(inputAsRustStr); if val.is_ok { return Expression(ptr: val.ok_or_err!) } else { throw RustString(ptr: val.ok_or_err!) } }()
    })
}
public func parseLatex<GenericToRustStr: ToRustStr>(_ input: GenericToRustStr) throws -> Expression {
    return input.toRustStr({ inputAsRustStr in
        try { let val = __swift_bridge__$parse_latex_ffi(inputAsRustStr); if val.is_ok { return Expression(ptr: val.ok_or_err!) } else { throw RustString(ptr: val.ok_or_err!) } }()
    })
}
public func toString(_ expr: ExpressionRef) -> RustString {
    RustString(ptr: __swift_bridge__$expression_to_string(expr.ptr))
}
public func toLatex(_ expr: ExpressionRef) -> RustString {
    RustString(ptr: __swift_bridge__$expression_to_latex(expr.ptr))
}
public func findVariables(_ expr: ExpressionRef) -> RustVec<RustString> {
    RustVec(ptr: __swift_bridge__$expression_find_variables(expr.ptr))
}
public func findFunctions(_ expr: ExpressionRef) -> RustVec<RustString> {
    RustVec(ptr: __swift_bridge__$expression_find_functions(expr.ptr))
}
public func depth(_ expr: ExpressionRef) -> UInt {
    __swift_bridge__$expression_depth(expr.ptr)
}
public func nodeCount(_ expr: ExpressionRef) -> UInt {
    __swift_bridge__$expression_node_count(expr.ptr)
}

public class Expression: ExpressionRefMut {
    var isOwned: Bool = true

    public override init(ptr: UnsafeMutableRawPointer) {
        super.init(ptr: ptr)
    }

    deinit {
        if isOwned {
            __swift_bridge__$Expression$_free(ptr)
        }
    }
}
public class ExpressionRefMut: ExpressionRef {
    public override init(ptr: UnsafeMutableRawPointer) {
        super.init(ptr: ptr)
    }
}
public class ExpressionRef {
    var ptr: UnsafeMutableRawPointer

    public init(ptr: UnsafeMutableRawPointer) {
        self.ptr = ptr
    }
}
extension Expression: Vectorizable {
    public static func vecOfSelfNew() -> UnsafeMutableRawPointer {
        __swift_bridge__$Vec_Expression$new()
    }

    public static func vecOfSelfFree(vecPtr: UnsafeMutableRawPointer) {
        __swift_bridge__$Vec_Expression$drop(vecPtr)
    }

    public static func vecOfSelfPush(vecPtr: UnsafeMutableRawPointer, value: Expression) {
        __swift_bridge__$Vec_Expression$push(vecPtr, {value.isOwned = false; return value.ptr;}())
    }

    public static func vecOfSelfPop(vecPtr: UnsafeMutableRawPointer) -> Optional<Self> {
        let pointer = __swift_bridge__$Vec_Expression$pop(vecPtr)
        if pointer == nil {
            return nil
        } else {
            return (Expression(ptr: pointer!) as! Self)
        }
    }

    public static func vecOfSelfGet(vecPtr: UnsafeMutableRawPointer, index: UInt) -> Optional<ExpressionRef> {
        let pointer = __swift_bridge__$Vec_Expression$get(vecPtr, index)
        if pointer == nil {
            return nil
        } else {
            return ExpressionRef(ptr: pointer!)
        }
    }

    public static func vecOfSelfGetMut(vecPtr: UnsafeMutableRawPointer, index: UInt) -> Optional<ExpressionRefMut> {
        let pointer = __swift_bridge__$Vec_Expression$get_mut(vecPtr, index)
        if pointer == nil {
            return nil
        } else {
            return ExpressionRefMut(ptr: pointer!)
        }
    }

    public static func vecOfSelfAsPtr(vecPtr: UnsafeMutableRawPointer) -> UnsafePointer<ExpressionRef> {
        UnsafePointer<ExpressionRef>(OpaquePointer(__swift_bridge__$Vec_Expression$as_ptr(vecPtr)))
    }

    public static func vecOfSelfLen(vecPtr: UnsafeMutableRawPointer) -> UInt {
        __swift_bridge__$Vec_Expression$len(vecPtr)
    }
}