1use core::ops::{Div, DivAssign};
4
5use crate::{Error, OptionOperations};
6
7common_option_op!(
8 Div,
9 div,
10 division,
11 "
12# Panics
13
14Most implementations will panic if `rhs` is zero.
15",
16);
17
18impl_for_ints!(OptionOverflowingDiv, {
19 type Output = Self;
20 fn opt_overflowing_div(self, rhs: Self) -> Option<(Self::Output, bool)> {
21 Some(self.overflowing_div(rhs))
22 }
23});
24
25impl_for_ints!(OptionWrappingDiv, {
26 type Output = Self;
27 fn opt_wrapping_div(self, rhs: Self) -> Option<Self::Output> {
28 Some(self.wrapping_div(rhs))
29 }
30});
31
32option_op_checked!(
33 Div,
34 div,
35 division,
36 "- Returns `Err(Error::DivisionByZero)` if `rhs` is zero.",
37);
38
39impl_for_ints!(OptionCheckedDiv, {
40 type Output = Self;
41 fn opt_checked_div(self, rhs: Self) -> Result<Option<Self::Output>, Error> {
42 if rhs == 0 {
43 return Err(Error::DivisionByZero);
44 }
45 self.checked_div(rhs).ok_or(Error::Overflow).map(Some)
46 }
47});
48
49impl OptionCheckedDiv<u32> for core::time::Duration {
50 type Output = Self;
51 fn opt_checked_div(self, rhs: u32) -> Result<Option<Self::Output>, Error> {
52 if rhs == 0 {
53 return Err(Error::DivisionByZero);
54 }
55 self.checked_div(rhs).ok_or(Error::Overflow).map(Some)
56 }
57}
58
59#[cfg(test)]
60mod test {
61 use super::*;
62 use crate::OptionOperations;
63 use core::ops::{Div, DivAssign};
64
65 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
66 struct MyInt(i64);
67
68 impl OptionOperations for MyInt {}
69
70 impl Div<MyInt> for MyInt {
71 type Output = MyInt;
72
73 fn div(self, rhs: MyInt) -> MyInt {
74 MyInt(self.0.div(rhs.0))
75 }
76 }
77
78 impl Div<i64> for MyInt {
79 type Output = MyInt;
80
81 fn div(self, rhs: i64) -> MyInt {
82 MyInt(self.0.div(rhs))
83 }
84 }
85
86 impl DivAssign<MyInt> for MyInt {
87 fn div_assign(&mut self, rhs: MyInt) {
88 self.0.div_assign(rhs.0)
89 }
90 }
91
92 impl DivAssign<i64> for MyInt {
93 fn div_assign(&mut self, rhs: i64) {
94 self.0.div_assign(rhs)
95 }
96 }
97
98 impl OptionCheckedDiv for MyInt {
99 type Output = MyInt;
100 fn opt_checked_div(self, rhs: MyInt) -> Result<Option<Self::Output>, Error> {
101 self.0.opt_checked_div(rhs.0).map(|ok| ok.map(MyInt))
102 }
103 }
104
105 impl OptionCheckedDiv<i64> for MyInt {
106 type Output = MyInt;
107 fn opt_checked_div(self, rhs: i64) -> Result<Option<Self::Output>, Error> {
108 self.0.opt_checked_div(rhs).map(|ok| ok.map(MyInt))
109 }
110 }
111
112 impl OptionOverflowingDiv for MyInt {
113 type Output = MyInt;
114 fn opt_overflowing_div(self, rhs: MyInt) -> Option<(Self::Output, bool)> {
115 self.0
116 .opt_overflowing_div(rhs.0)
117 .map(|(val, flag)| (MyInt(val), flag))
118 }
119 }
120
121 impl OptionOverflowingDiv<i64> for MyInt {
122 type Output = MyInt;
123 fn opt_overflowing_div(self, rhs: i64) -> Option<(Self::Output, bool)> {
124 self.0
125 .opt_overflowing_div(rhs)
126 .map(|(val, flag)| (MyInt(val), flag))
127 }
128 }
129
130 impl OptionWrappingDiv for MyInt {
131 type Output = MyInt;
132 fn opt_wrapping_div(self, rhs: MyInt) -> Option<Self::Output> {
133 self.0.opt_wrapping_div(rhs.0).map(MyInt)
134 }
135 }
136
137 impl OptionWrappingDiv<i64> for MyInt {
138 type Output = MyInt;
139 fn opt_wrapping_div(self, rhs: i64) -> Option<Self::Output> {
140 self.0.opt_wrapping_div(rhs).map(MyInt)
141 }
142 }
143
144 const MY_MINUS_1: MyInt = MyInt(-1);
145 const MY_0: MyInt = MyInt(0);
146 const MY_1: MyInt = MyInt(1);
147 const MY_2: MyInt = MyInt(2);
148 const MY_5: MyInt = MyInt(5);
149 const MY_10: MyInt = MyInt(10);
150 const MY_MIN: MyInt = MyInt(i64::MIN);
151 const MY_HALF_MAX: MyInt = MyInt(i64::MAX / 2);
152 const MY_MAX: MyInt = MyInt(i64::MAX);
153 const SOME_MINUS_1: Option<MyInt> = Some(MY_MINUS_1);
154 const SOME_0: Option<MyInt> = Some(MY_0);
155 const SOME_1: Option<MyInt> = Some(MY_1);
156 const SOME_2: Option<MyInt> = Some(MY_2);
157 const SOME_5: Option<MyInt> = Some(MY_5);
158 const SOME_10: Option<MyInt> = Some(MY_10);
159 const SOME_MIN: Option<MyInt> = Some(MY_MIN);
160 const SOME_HALF_MAX: Option<MyInt> = Some(MY_HALF_MAX);
161 const SOME_MAX: Option<MyInt> = Some(MY_MAX);
162 const NONE: Option<MyInt> = None;
163
164 #[test]
165 fn div_my() {
166 assert_eq!(MY_5.opt_div(MY_1), SOME_5);
167 assert_eq!(SOME_10.opt_div(MY_2), SOME_5);
168 assert_eq!(MY_0.opt_div(SOME_1), SOME_0);
169 assert_eq!(MY_MAX.opt_div(&SOME_2), SOME_HALF_MAX);
170 assert_eq!(MY_1.opt_div(NONE), NONE);
171 assert_eq!(NONE.opt_div(MY_1), NONE);
172 }
173
174 #[test]
175 #[should_panic]
176 fn div_by_zero_my() {
177 let _ = SOME_10.opt_div(SOME_0);
178 }
179
180 #[test]
181 fn div_i64() {
182 assert_eq!(MY_5.opt_div(5), SOME_1);
183 assert_eq!(SOME_10.opt_div(MY_2), SOME_5);
184 assert_eq!(MY_0.opt_div(Some(1)), SOME_0);
185 assert_eq!(MY_MAX.opt_div(Some(2)), SOME_HALF_MAX);
186 assert_eq!(MY_1.opt_div(Option::<i64>::None), NONE);
187 assert_eq!(Option::<MyInt>::None.opt_div(MY_1), NONE);
188 }
189
190 #[test]
191 #[should_panic]
192 fn div_by_zero_i64() {
193 let _ = SOME_10.opt_div(Some(0));
194 }
195
196 #[test]
197 fn div_assign_my() {
198 let mut my = MY_5;
199 my.opt_div_assign(MY_1);
200 assert_eq!(my, MY_5);
201
202 let mut some = SOME_10;
203 some.opt_div_assign(MY_5);
204 assert_eq!(some, SOME_2);
205
206 let mut my = MY_0;
207 my.opt_div_assign(SOME_1);
208 assert_eq!(my, MY_0);
209
210 let mut my = MY_MAX;
211 my.opt_div_assign(&SOME_2);
212 assert_eq!(my, MY_HALF_MAX);
213
214 let mut my = MY_1;
215 my.opt_div_assign(NONE);
216 assert_eq!(my, MY_1);
217
218 let mut some = SOME_2;
219 some.opt_div_assign(SOME_1);
220 assert_eq!(some, SOME_2);
221
222 let mut some = SOME_10;
223 some.opt_div_assign(&SOME_2);
224 assert_eq!(some, SOME_5);
225
226 let mut some = SOME_1;
227 some.opt_div_assign(NONE);
228 assert_eq!(some, SOME_1);
229
230 let mut none = NONE;
231 none.opt_div_assign(SOME_1);
232 assert_eq!(none, NONE);
233
234 let mut none = NONE;
235 none.opt_div_assign(NONE);
236 assert_eq!(none, NONE);
237 }
238
239 #[test]
240 #[should_panic]
241 fn div_assign_by_zero_my() {
242 let mut some = SOME_10;
243 some.opt_div_assign(SOME_0);
244 }
245
246 #[test]
247 fn div_assign_i64() {
248 let mut my = MY_5;
249 my.opt_div_assign(1);
250 assert_eq!(my, MY_5);
251
252 let mut some = SOME_10;
253 some.opt_div_assign(5);
254 assert_eq!(some, SOME_2);
255
256 let mut my = MY_0;
257 my.opt_div_assign(1);
258 assert_eq!(my, MY_0);
259
260 let mut my = MY_MAX;
261 my.opt_div_assign(2);
262 assert_eq!(my, MY_HALF_MAX);
263
264 let mut my = MY_1;
265 my.opt_div_assign(Option::<i64>::None);
266 assert_eq!(my, MY_1);
267
268 let mut some = SOME_2;
269 some.opt_div_assign(1);
270 assert_eq!(some, SOME_2);
271
272 let mut some = SOME_1;
273 some.opt_div_assign(Option::<i64>::None);
274 assert_eq!(some, SOME_1);
275
276 let mut none = NONE;
277 none.opt_div_assign(1);
278 assert_eq!(none, NONE);
279
280 let mut none = NONE;
281 none.opt_div_assign(Option::<i64>::None);
282 assert_eq!(none, NONE);
283 }
284
285 #[test]
286 #[should_panic]
287 fn div_assign_by_zero_i64() {
288 let mut some = SOME_10;
289 some.opt_div_assign(Some(0));
290 }
291
292 #[test]
293 fn checked_div() {
294 assert_eq!(MY_2.opt_checked_div(MY_1), Ok(SOME_2));
295 assert_eq!(MY_10.opt_checked_div(SOME_5), Ok(SOME_2));
296 assert_eq!(MY_0.opt_checked_div(&SOME_1), Ok(SOME_0));
297 assert_eq!(MY_MAX.opt_checked_div(MY_2), Ok(SOME_HALF_MAX));
298 assert_eq!(MY_MAX.opt_checked_div(MY_0), Err(Error::DivisionByZero));
299 assert_eq!(MY_MIN.opt_checked_div(MY_MINUS_1), Err(Error::Overflow));
300
301 assert_eq!(SOME_2.opt_checked_div(MY_1), Ok(SOME_2));
302 assert_eq!(SOME_10.opt_checked_div(SOME_2), Ok(SOME_5));
303 assert_eq!(SOME_0.opt_checked_div(&SOME_1), Ok(SOME_0));
304
305 assert_eq!(SOME_MAX.opt_checked_div(MY_2), Ok(SOME_HALF_MAX));
306 assert_eq!(SOME_MAX.opt_checked_div(MY_0), Err(Error::DivisionByZero));
307 assert_eq!(SOME_MIN.opt_checked_div(MY_MINUS_1), Err(Error::Overflow));
308 assert_eq!(SOME_MAX.opt_checked_div(0), Err(Error::DivisionByZero));
309 assert_eq!(SOME_MIN.opt_checked_div(-1), Err(Error::Overflow));
310 assert_eq!(
311 SOME_MAX.opt_checked_div(Some(0)),
312 Err(Error::DivisionByZero)
313 );
314 assert_eq!(SOME_MIN.opt_checked_div(Some(-1)), Err(Error::Overflow));
315 assert_eq!(SOME_MAX.opt_checked_div(SOME_0), Err(Error::DivisionByZero));
316 assert_eq!(SOME_MIN.opt_checked_div(SOME_MINUS_1), Err(Error::Overflow));
317 assert_eq!(MY_MIN.opt_checked_div(NONE), Ok(None));
318 assert_eq!(NONE.opt_checked_div(SOME_MIN), Ok(None));
319 }
320
321 #[test]
322 fn overflowing_div() {
323 assert_eq!(MY_2.opt_overflowing_div(MY_1), Some((MY_2, false)));
324 assert_eq!(MY_0.opt_overflowing_div(MY_1), Some((MY_0, false)));
325 assert_eq!(MY_MAX.opt_overflowing_div(MY_2), Some((MY_HALF_MAX, false)));
326 assert_eq!(MY_MIN.opt_overflowing_div(MY_MINUS_1), Some((MY_MIN, true)));
327 assert_eq!(
328 SOME_MIN.opt_overflowing_div(MY_MINUS_1),
329 Some((MY_MIN, true))
330 );
331 assert_eq!(SOME_MIN.opt_overflowing_div(-1), Some((MY_MIN, true)));
332 assert_eq!(SOME_MIN.opt_overflowing_div(Some(-1)), Some((MY_MIN, true)));
333 assert_eq!(
334 SOME_MIN.opt_overflowing_div(&Some(-1)),
335 Some((MY_MIN, true))
336 );
337 assert_eq!(
338 MY_MIN.opt_overflowing_div(SOME_MINUS_1),
339 Some((MY_MIN, true))
340 );
341 assert_eq!(
342 MY_MIN.opt_overflowing_div(&SOME_MINUS_1),
343 Some((MY_MIN, true))
344 );
345 assert_eq!(MY_MIN.opt_overflowing_div(NONE), None);
346 assert_eq!(NONE.opt_overflowing_div(MY_MIN), None);
347 }
348
349 #[test]
350 fn wrapping_div() {
351 assert_eq!(MY_2.opt_wrapping_div(MY_1), SOME_2);
352 assert_eq!(MY_0.opt_wrapping_div(MY_1), SOME_0);
353 assert_eq!(MY_MIN.opt_wrapping_div(MY_MINUS_1), SOME_MIN);
354 assert_eq!(SOME_MIN.opt_wrapping_div(MY_MINUS_1), SOME_MIN);
355 assert_eq!(SOME_MIN.opt_wrapping_div(-1), SOME_MIN);
356 assert_eq!(SOME_MIN.opt_wrapping_div(Some(-1)), SOME_MIN);
357 assert_eq!(SOME_MIN.opt_wrapping_div(&Some(-1)), SOME_MIN);
358 assert_eq!(MY_MIN.opt_wrapping_div(SOME_MINUS_1), SOME_MIN);
359 assert_eq!(MY_MIN.opt_wrapping_div(&SOME_MINUS_1), SOME_MIN);
360 assert_eq!(MY_MIN.opt_wrapping_div(NONE), None);
361 assert_eq!(NONE.opt_wrapping_div(MY_MIN), None);
362 }
363}