osb 0.3.0

A fast, fully-fledged, scalable and secure implementation of the .osb storyboard file format
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::fmt;
use std::ops::{Add, Neg, Sub};

#[derive(Debug, Copy, Clone, PartialEq)]
pub enum Number {
    Int(i32),
    Float(f32),
}

impl Number {
    /// Returns the f32 value of a `Number` regardless of if it's an int of a float
    ///
    /// Example:
    /// ```
    /// use osb::utils::Number;
    ///
    /// let integer = Number::Int(42);
    /// let float = Number::Float(0.42);
    /// assert_eq!(integer.as_f32(), 42.);
    /// assert_eq!(float.as_f32(), 0.42);
    /// ```
    pub fn as_f32(&self) -> f32 {
        match *self {
            Number::Int(val) => val as f32,
            Number::Float(val) => val,
        }
    }
}

impl Into<Number> for i32 {
    fn into(self) -> Number {
        Number::Int(self)
    }
}

impl Into<Number> for f32 {
    fn into(self) -> Number {
        Number::Float(self)
    }
}

impl fmt::Display for Number {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Number::Int(val) => write!(f, "{}", val),
            Number::Float(val) => write!(f, "{}", val),
        }
    }
}

impl Add for Number {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        match (self, other) {
            (Number::Int(i), Number::Int(j)) => Number::Int(i + j),
            (Number::Float(i), Number::Int(j)) => Number::Float(i + j as f32),
            (Number::Int(i), Number::Float(j)) => Number::Float(i as f32 + j),
            (Number::Float(i), Number::Float(j)) => Number::Float(i + j),
        }
    }
}

impl Sub for Number {
    type Output = Self;

    fn sub(self, other: Self) -> Self {
        match (self, other) {
            (Number::Int(i), Number::Int(j)) => Number::Int(i - j),
            (Number::Float(i), Number::Int(j)) => Number::Float(i - j as f32),
            (Number::Int(i), Number::Float(j)) => Number::Float(i as f32 - j),
            (Number::Float(i), Number::Float(j)) => Number::Float(i - j),
        }
    }
}

impl Neg for Number {
    type Output = Self;

    fn neg(self) -> Self {
        match self {
            Number::Int(val) => Number::Int(-val),
            Number::Float(val) => Number::Float(-val),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::utils::Number;

    #[test]
    fn add() {
        let i1 = Number::Int(1);
        let i2 = Number::Int(2);
        let f1 = Number::Float(0.5);
        let f2 = Number::Float(1.5);

        assert_eq!(i1 + i2, Number::Int(3));
        assert_eq!(f1 + i2, Number::Float(2.5));
        assert_eq!(i2 + f2, Number::Float(3.5));
        assert_eq!(f1 + f2, Number::Float(2.));
    }

    #[test]
    fn sub() {
        let i1 = Number::Int(1);
        let i2 = Number::Int(2);
        let f1 = Number::Float(0.5);
        let f2 = Number::Float(1.5);

        assert_eq!(i2 - i1, Number::Int(1));
        assert_eq!(i2 - f1, Number::Float(1.5));
        assert_eq!(i2 - f2, Number::Float(0.5));
        assert_eq!(f2 - f1, Number::Float(1.));
    }

    #[test]
    fn neg() {
        let i1 = Number::Int(1);
        let f1 = Number::Float(0.5);

        assert_eq!(-i1, Number::Int(-1));
        assert_eq!(-f1, Number::Float(-0.5));
    }
}