rbop 0.2.0

Rust framework for writing mathematical expression editors
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

use alloc::{fmt, vec, vec::Vec};

use crate::node::unstructured::Serializable;

pub trait Error : alloc::fmt::Display + alloc::fmt::Debug {}

#[derive(PartialEq, Eq, Debug, Clone)]
pub enum NodeError {
    UnexpectedTokensAtEnd,
    PowerMissingBase,
    ExpectedUnit,
    CannotUpgradeToken,
    Overflow,
}

impl fmt::Display for NodeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
            NodeError::UnexpectedTokensAtEnd => "syntax error",
            NodeError::PowerMissingBase => "no base given for power",
            NodeError::ExpectedUnit => "syntax error",
            NodeError::CannotUpgradeToken => "internal syntax error",
            NodeError::Overflow => "numeric overflow",
        })
    }
}
impl Error for NodeError {}

impl Serializable for NodeError {
    fn serialize(&self) -> Vec<u8> {
        vec![match self {
            NodeError::UnexpectedTokensAtEnd => 1,
            NodeError::PowerMissingBase => 2,
            NodeError::ExpectedUnit => 3,
            NodeError::CannotUpgradeToken => 4,
            NodeError::Overflow => 5,
        }]
    }

    fn deserialize(bytes: &mut dyn Iterator<Item = u8>) -> Option<Self> {
        Some(match bytes.next()? {
            1 => NodeError::UnexpectedTokensAtEnd,
            2 => NodeError::PowerMissingBase,
            3 => NodeError::ExpectedUnit,
            4 => NodeError::CannotUpgradeToken,
            5 => NodeError::Overflow,

            _ => return None,
        })
    }
}


#[derive(PartialEq, Eq, Debug, Clone)]
pub enum MathsError {
    DivisionByZero,
    InvalidSqrt,
    MissingVariable,
    Overflow,
    Imaginary,
}

impl fmt::Display for MathsError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
            MathsError::DivisionByZero => "division by zero",
            MathsError::InvalidSqrt => "invalid square root",
            MathsError::MissingVariable => "cannot evaluate variable",
            MathsError::Overflow => "numeric overflow",
            MathsError::Imaginary => "imaginary",
        })
    }
}
impl Error for MathsError {}

impl Serializable for MathsError {
    fn serialize(&self) -> Vec<u8> {
        vec![match self {
            MathsError::DivisionByZero => 1,
            MathsError::InvalidSqrt => 2,
            MathsError::MissingVariable => 3,
            MathsError::Overflow => 4,
            MathsError::Imaginary => 5,
        }]
    }

    fn deserialize(bytes: &mut dyn Iterator<Item = u8>) -> Option<Self> {
        Some(match bytes.next()? {
            1 => MathsError::DivisionByZero,
            2 => MathsError::InvalidSqrt,
            3 => MathsError::MissingVariable,
            4 => MathsError::Overflow,
            5 => MathsError::Imaginary,

            _ => return None,
        })
    }
}