1use core::ops::{Add, AddAssign};
4
5use crate::{Error, OptionOperations};
6
7common_option_op!(Add, add, addition);
8
9impl_for_ints!(OptionOverflowingAdd, {
10 type Output = Self;
11 fn opt_overflowing_add(self, rhs: Self) -> Option<(Self::Output, bool)> {
12 Some(self.overflowing_add(rhs))
13 }
14});
15
16impl_for_ints!(OptionWrappingAdd, {
17 type Output = Self;
18 fn opt_wrapping_add(self, rhs: Self) -> Option<Self::Output> {
19 Some(self.wrapping_add(rhs))
20 }
21});
22
23option_op_checked!(Add, add, addition);
24
25impl_for_ints_and_duration!(OptionCheckedAdd, {
26 type Output = Self;
27 fn opt_checked_add(self, rhs: Self) -> Result<Option<Self::Output>, Error> {
28 self.checked_add(rhs).ok_or(Error::Overflow).map(Some)
29 }
30});
31
32#[cfg(feature = "std")]
33impl OptionCheckedAdd<std::time::Duration> for std::time::Instant {
34 type Output = Self;
35 fn opt_checked_add(self, rhs: std::time::Duration) -> Result<Option<Self::Output>, Error> {
36 self.checked_add(rhs).ok_or(Error::Overflow).map(Some)
37 }
38}
39
40#[cfg(feature = "std")]
41impl OptionCheckedAdd<std::time::Duration> for std::time::SystemTime {
42 type Output = Self;
43 fn opt_checked_add(self, rhs: std::time::Duration) -> Result<Option<Self::Output>, Error> {
44 self.checked_add(rhs).ok_or(Error::Overflow).map(Some)
45 }
46}
47
48option_op_saturating!(Add, add, addition);
49
50impl_for_ints_and_duration!(OptionSaturatingAdd, {
51 type Output = Self;
52 fn opt_saturating_add(self, rhs: Self) -> Option<Self::Output> {
53 Some(self.saturating_add(rhs))
54 }
55});
56
57#[cfg(test)]
58mod test {
59 use super::*;
60 use crate::OptionOperations;
61 use core::ops::{Add, AddAssign};
62
63 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
64 struct MyInt(u64);
65
66 impl OptionOperations for MyInt {}
67
68 impl Add<MyInt> for MyInt {
69 type Output = MyInt;
70
71 fn add(self, rhs: MyInt) -> MyInt {
72 MyInt(self.0.add(rhs.0))
73 }
74 }
75
76 impl Add<u64> for MyInt {
77 type Output = MyInt;
78
79 fn add(self, rhs: u64) -> MyInt {
80 MyInt(self.0.add(rhs))
81 }
82 }
83
84 impl AddAssign<MyInt> for MyInt {
85 fn add_assign(&mut self, rhs: MyInt) {
86 self.0.add_assign(rhs.0)
87 }
88 }
89
90 impl AddAssign<u64> for MyInt {
91 fn add_assign(&mut self, rhs: u64) {
92 self.0.add_assign(rhs)
93 }
94 }
95
96 impl OptionCheckedAdd for MyInt {
97 type Output = MyInt;
98 fn opt_checked_add(self, rhs: MyInt) -> Result<Option<Self::Output>, Error> {
99 self.0.opt_checked_add(rhs.0).map(|ok| ok.map(MyInt))
100 }
101 }
102
103 impl OptionCheckedAdd<u64> for MyInt {
104 type Output = MyInt;
105 fn opt_checked_add(self, rhs: u64) -> Result<Option<Self::Output>, Error> {
106 self.0.opt_checked_add(rhs).map(|ok| ok.map(MyInt))
107 }
108 }
109
110 impl OptionSaturatingAdd for MyInt {
111 type Output = MyInt;
112 fn opt_saturating_add(self, rhs: MyInt) -> Option<Self::Output> {
113 self.0.opt_saturating_add(rhs.0).map(MyInt)
114 }
115 }
116
117 impl OptionSaturatingAdd<u64> for MyInt {
118 type Output = MyInt;
119 fn opt_saturating_add(self, rhs: u64) -> Option<Self::Output> {
120 self.0.opt_saturating_add(rhs).map(MyInt)
121 }
122 }
123
124 impl OptionOverflowingAdd for MyInt {
125 type Output = MyInt;
126 fn opt_overflowing_add(self, rhs: MyInt) -> Option<(Self::Output, bool)> {
127 self.0
128 .opt_overflowing_add(rhs.0)
129 .map(|(val, flag)| (MyInt(val), flag))
130 }
131 }
132
133 impl OptionOverflowingAdd<u64> for MyInt {
134 type Output = MyInt;
135 fn opt_overflowing_add(self, rhs: u64) -> Option<(Self::Output, bool)> {
136 self.0
137 .opt_overflowing_add(rhs)
138 .map(|(val, flag)| (MyInt(val), flag))
139 }
140 }
141
142 impl OptionWrappingAdd for MyInt {
143 type Output = MyInt;
144 fn opt_wrapping_add(self, rhs: MyInt) -> Option<Self::Output> {
145 self.0.opt_wrapping_add(rhs.0).map(MyInt)
146 }
147 }
148
149 impl OptionWrappingAdd<u64> for MyInt {
150 type Output = MyInt;
151 fn opt_wrapping_add(self, rhs: u64) -> Option<Self::Output> {
152 self.0.opt_wrapping_add(rhs).map(MyInt)
153 }
154 }
155
156 const MY_0: MyInt = MyInt(0);
157 const MY_1: MyInt = MyInt(1);
158 const MY_2: MyInt = MyInt(2);
159 const MY_MAX: MyInt = MyInt(u64::MAX);
160 const SOME_0: Option<MyInt> = Some(MY_0);
161 const SOME_1: Option<MyInt> = Some(MY_1);
162 const SOME_2: Option<MyInt> = Some(MY_2);
163 const SOME_MAX: Option<MyInt> = Some(MY_MAX);
164 const NONE: Option<MyInt> = None;
165
166 #[test]
167 fn add_my() {
168 assert_eq!(MY_1.opt_add(MY_1), SOME_2);
169 assert_eq!(SOME_1.opt_add(MY_1), SOME_2);
170 assert_eq!(MY_1.opt_add(SOME_1), SOME_2);
171 assert_eq!(MY_1.opt_add(&SOME_1), SOME_2);
172 assert_eq!(MY_1.opt_add(NONE), NONE);
173 assert_eq!(NONE.opt_add(MY_1), NONE);
174 }
175
176 #[test]
177 fn add_u64() {
178 assert_eq!(MY_1.opt_add(1), SOME_2);
179 assert_eq!(MY_1.opt_add(Some(1)), SOME_2);
180 assert_eq!(SOME_1.opt_add(1), SOME_2);
181 assert_eq!(SOME_1.opt_add(Some(1)), SOME_2);
182 assert_eq!(SOME_1.opt_add(&Some(1)), SOME_2);
183 assert_eq!(MY_1.opt_add(Option::<u64>::None), NONE);
184 assert_eq!(Option::<MyInt>::None.opt_add(MY_0), NONE);
185 }
186
187 #[test]
188 fn add_assign_my() {
189 let mut my = MY_1;
190 my.opt_add_assign(MY_1);
191 assert_eq!(my, MY_2);
192
193 let mut some = SOME_1;
194 some.opt_add_assign(MY_1);
195 assert_eq!(some, SOME_2);
196
197 let mut my = MY_1;
198 my.opt_add_assign(SOME_1);
199 assert_eq!(my, MY_2);
200
201 let mut my = MY_1;
202 my.opt_add_assign(&SOME_1);
203 assert_eq!(my, MY_2);
204
205 let mut my = MY_1;
206 my.opt_add_assign(NONE);
207 assert_eq!(my, MY_1);
208
209 let mut some = SOME_1;
210 some.opt_add_assign(SOME_1);
211 assert_eq!(some, SOME_2);
212
213 let mut some = SOME_1;
214 some.opt_add_assign(&SOME_1);
215 assert_eq!(some, SOME_2);
216
217 let mut some = SOME_1;
218 some.opt_add_assign(NONE);
219 assert_eq!(some, SOME_1);
220
221 let mut none = NONE;
222 none.opt_add_assign(SOME_1);
223 assert_eq!(none, NONE);
224
225 let mut none = NONE;
226 none.opt_add_assign(NONE);
227 assert_eq!(none, NONE);
228 }
229
230 #[test]
231 fn add_assign_u64() {
232 let mut my = MY_1;
233 my.opt_add_assign(1);
234 assert_eq!(my, MY_2);
235
236 let mut some = SOME_1;
237 some.opt_add_assign(1);
238 assert_eq!(some, SOME_2);
239
240 let mut my = MY_1;
241 my.opt_add_assign(Some(1));
242 assert_eq!(my, MY_2);
243
244 let mut my = MY_1;
245 my.opt_add_assign(&Some(1));
246 assert_eq!(my, MY_2);
247
248 let mut some = SOME_1;
249 some.opt_add_assign(Some(1));
250 assert_eq!(some, SOME_2);
251
252 let mut some = SOME_1;
253 some.opt_add_assign(&Some(1));
254 assert_eq!(some, SOME_2);
255
256 let mut none = NONE;
257 none.opt_add_assign(Some(1));
258 assert_eq!(none, NONE);
259 }
260
261 #[test]
262 fn checked_add() {
263 assert_eq!(MY_1.opt_checked_add(MY_1), Ok(SOME_2));
264 assert_eq!(MY_1.opt_checked_add(SOME_1), Ok(SOME_2));
265 assert_eq!(MY_1.opt_checked_add(&SOME_1), Ok(SOME_2));
266 assert_eq!(MY_MAX.opt_checked_add(MY_1), Err(Error::Overflow));
267
268 assert_eq!(SOME_1.opt_checked_add(MY_1), Ok(SOME_2));
269 assert_eq!(SOME_1.opt_checked_add(SOME_1), Ok(SOME_2));
270 assert_eq!(SOME_1.opt_checked_add(&SOME_1), Ok(SOME_2));
271
272 assert_eq!(SOME_MAX.opt_checked_add(MY_1), Err(Error::Overflow));
273 assert_eq!(SOME_MAX.opt_checked_add(1), Err(Error::Overflow));
274 assert_eq!(SOME_MAX.opt_checked_add(Some(1)), Err(Error::Overflow));
275 assert_eq!(MY_1.opt_checked_add(SOME_MAX), Err(Error::Overflow));
276 assert_eq!(MY_MAX.opt_checked_add(NONE), Ok(None));
277 assert_eq!(NONE.opt_checked_add(SOME_MAX), Ok(None));
278 }
279
280 #[test]
281 fn saturating_add() {
282 assert_eq!(MY_1.opt_saturating_add(MY_1), SOME_2);
283 assert_eq!(MY_MAX.opt_saturating_add(MY_1), SOME_MAX);
284 assert_eq!(SOME_MAX.opt_saturating_add(MY_1), SOME_MAX);
285 assert_eq!(SOME_MAX.opt_saturating_add(1), SOME_MAX);
286 assert_eq!(SOME_MAX.opt_saturating_add(Some(1)), SOME_MAX);
287 assert_eq!(SOME_MAX.opt_saturating_add(&Some(1)), SOME_MAX);
288 assert_eq!(MY_1.opt_saturating_add(SOME_MAX), SOME_MAX);
289 assert_eq!(MY_1.opt_saturating_add(&SOME_MAX), SOME_MAX);
290 assert_eq!(MY_MAX.opt_saturating_add(NONE), NONE);
291 assert_eq!(NONE.opt_saturating_add(SOME_MAX), NONE);
292 }
293
294 #[test]
295 fn overflowing_add() {
296 assert_eq!(MY_1.opt_overflowing_add(MY_1), Some((MY_2, false)));
297 assert_eq!(MY_MAX.opt_overflowing_add(MY_1), Some((MY_0, true)));
298 assert_eq!(SOME_MAX.opt_overflowing_add(MY_1), Some((MY_0, true)));
299 assert_eq!(SOME_MAX.opt_overflowing_add(1), Some((MY_0, true)));
300 assert_eq!(SOME_MAX.opt_overflowing_add(Some(1)), Some((MY_0, true)));
301 assert_eq!(SOME_MAX.opt_overflowing_add(&Some(1)), Some((MY_0, true)));
302 assert_eq!(MY_1.opt_overflowing_add(SOME_MAX), Some((MY_0, true)));
303 assert_eq!(MY_1.opt_overflowing_add(&SOME_MAX), Some((MY_0, true)));
304 assert_eq!(MY_MAX.opt_overflowing_add(NONE), None);
305 assert_eq!(NONE.opt_overflowing_add(SOME_MAX), None);
306 }
307
308 #[test]
309 fn wrapping_add() {
310 assert_eq!(MY_1.opt_wrapping_add(MY_1), SOME_2);
311 assert_eq!(MY_MAX.opt_wrapping_add(MY_1), SOME_0);
312 assert_eq!(SOME_MAX.opt_wrapping_add(MY_1), SOME_0);
313 assert_eq!(SOME_MAX.opt_wrapping_add(1), SOME_0);
314 assert_eq!(SOME_MAX.opt_wrapping_add(Some(1)), SOME_0);
315 assert_eq!(SOME_MAX.opt_wrapping_add(&Some(1)), SOME_0);
316 assert_eq!(MY_1.opt_wrapping_add(SOME_MAX), SOME_0);
317 assert_eq!(MY_1.opt_wrapping_add(&SOME_MAX), SOME_0);
318 assert_eq!(MY_MAX.opt_wrapping_add(NONE), NONE);
319 assert_eq!(NONE.opt_wrapping_add(SOME_MAX), NONE);
320 }
321}