tawasuyu/taffy

1use core::ops;
2
3#[derive(Copy, Clone, PartialEq, Debug)]
4#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
5#[cfg_attr(all(feature = "serde", feature = "serde_kebab_case"), serde(rename_all = "kebab-case"))]
6#[cfg_attr(all(feature = "serde", feature = "serde_camel_case"), serde(rename_all = "camelCase"))]
7pub enum Number {
8    Defined(f32),
9    Undefined,
10}
11
12pub trait ToNumber {
13    fn to_number(self) -> Number;
14}
15
16pub trait OrElse<T> {
17    fn or_else(self, other: T) -> T;
18}
19
20impl Default for Number {
21    fn default() -> Self {
22        Self::Undefined
23    }
24}
25
26impl OrElse<f32> for Number {
27    fn or_else(self, other: f32) -> f32 {
28        match self {
29            Number::Defined(val) => val,
30            Number::Undefined => other,
31        }
32    }
33}
34
35impl OrElse<Self> for Number {
36    fn or_else(self, other: Self) -> Self {
37        match self {
38            Number::Defined(_) => self,
39            Number::Undefined => other,
40        }
41    }
42}
43
44impl Number {
45    pub fn is_defined(self) -> bool {
46        match self {
47            Number::Defined(_) => true,
48            Number::Undefined => false,
49        }
50    }
51
52    pub fn is_undefined(self) -> bool {
53        match self {
54            Number::Defined(_) => false,
55            Number::Undefined => true,
56        }
57    }
58}
59
60pub trait MinMax<In, Out> {
61    fn maybe_min(self, rhs: In) -> Out;
62    fn maybe_max(self, rhs: In) -> Out;
63}
64
65impl MinMax<Self, Self> for Number {
66    fn maybe_min(self, rhs: Self) -> Self {
67        match self {
68            Number::Defined(val) => match rhs {
69                Number::Defined(other) => Number::Defined(val.min(other)),
70                Number::Undefined => self,
71            },
72            Number::Undefined => Number::Undefined,
73        }
74    }
75
76    fn maybe_max(self, rhs: Self) -> Self {
77        match self {
78            Number::Defined(val) => match rhs {
79                Number::Defined(other) => Number::Defined(val.max(other)),
80                Number::Undefined => self,
81            },
82            Number::Undefined => Number::Undefined,
83        }
84    }
85}
86
87impl MinMax<f32, Number> for Number {
88    fn maybe_min(self, rhs: f32) -> Number {
89        match self {
90            Number::Defined(val) => Number::Defined(val.min(rhs)),
91            Number::Undefined => Number::Undefined,
92        }
93    }
94
95    fn maybe_max(self, rhs: f32) -> Number {
96        match self {
97            Number::Defined(val) => Number::Defined(val.max(rhs)),
98            Number::Undefined => Number::Undefined,
99        }
100    }
101}
102
103impl MinMax<Number, f32> for f32 {
104    fn maybe_min(self, rhs: Number) -> f32 {
105        match rhs {
106            Number::Defined(val) => self.min(val),
107            Number::Undefined => self,
108        }
109    }
110
111    fn maybe_max(self, rhs: Number) -> f32 {
112        match rhs {
113            Number::Defined(val) => self.max(val),
114            Number::Undefined => self,
115        }
116    }
117}
118
119impl ToNumber for f32 {
120    fn to_number(self) -> Number {
121        Number::Defined(self)
122    }
123}
124
125impl ops::Add<f32> for Number {
126    type Output = Number;
127
128    fn add(self, rhs: f32) -> Self {
129        match self {
130            Number::Defined(val) => Number::Defined(val + rhs),
131            Number::Undefined => Number::Undefined,
132        }
133    }
134}
135
136impl ops::Add<Number> for Number {
137    type Output = Number;
138
139    fn add(self, rhs: Self) -> Self {
140        match self {
141            Number::Defined(val) => match rhs {
142                Number::Defined(other) => Number::Defined(val + other),
143                Number::Undefined => self,
144            },
145            Number::Undefined => Number::Undefined,
146        }
147    }
148}
149
150impl ops::Sub<f32> for Number {
151    type Output = Number;
152
153    fn sub(self, rhs: f32) -> Self {
154        match self {
155            Number::Defined(val) => Number::Defined(val - rhs),
156            Number::Undefined => Number::Undefined,
157        }
158    }
159}
160
161impl ops::Sub<Number> for Number {
162    type Output = Number;
163
164    fn sub(self, rhs: Self) -> Self {
165        match self {
166            Number::Defined(val) => match rhs {
167                Number::Defined(other) => Number::Defined(val - other),
168                Number::Undefined => self,
169            },
170            Number::Undefined => Number::Undefined,
171        }
172    }
173}
174
175impl ops::Mul<f32> for Number {
176    type Output = Number;
177
178    fn mul(self, rhs: f32) -> Self {
179        match self {
180            Number::Defined(val) => Number::Defined(val * rhs),
181            Number::Undefined => Number::Undefined,
182        }
183    }
184}
185
186impl ops::Mul<Number> for Number {
187    type Output = Number;
188
189    fn mul(self, rhs: Self) -> Self {
190        match self {
191            Number::Defined(val) => match rhs {
192                Number::Defined(other) => Number::Defined(val * other),
193                Number::Undefined => self,
194            },
195            Number::Undefined => Number::Undefined,
196        }
197    }
198}
199
200impl ops::Div<f32> for Number {
201    type Output = Number;
202
203    fn div(self, rhs: f32) -> Self {
204        match self {
205            Number::Defined(val) => Number::Defined(val / rhs),
206            Number::Undefined => Number::Undefined,
207        }
208    }
209}
210
211impl ops::Div<Number> for Number {
212    type Output = Number;
213
214    fn div(self, rhs: Self) -> Self {
215        match self {
216            Number::Defined(val) => match rhs {
217                Number::Defined(other) => Number::Defined(val / other),
218                Number::Undefined => self,
219            },
220            Number::Undefined => Number::Undefined,
221        }
222    }
223}