1use core::num::Wrapping;
2use core::ops::{Add, Mul, Shl, Shr, Sub};
3
4macro_rules! wrapping_impl {
5 ($trait_name:ident, $method:ident, $t:ty) => {
6 impl $trait_name for $t {
7 #[inline]
8 fn $method(&self, v: &Self) -> Self {
9 <$t>::$method(*self, *v)
10 }
11 }
12 };
13 ($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
14 impl $trait_name<$rhs> for $t {
15 #[inline]
16 fn $method(&self, v: &$rhs) -> Self {
17 <$t>::$method(*self, *v)
18 }
19 }
20 };
21}
22
23pub trait WrappingAdd: Sized + Add<Self, Output = Self> {
25 fn wrapping_add(&self, v: &Self) -> Self;
28}
29
30wrapping_impl!(WrappingAdd, wrapping_add, u8);
31wrapping_impl!(WrappingAdd, wrapping_add, u16);
32wrapping_impl!(WrappingAdd, wrapping_add, u32);
33wrapping_impl!(WrappingAdd, wrapping_add, u64);
34wrapping_impl!(WrappingAdd, wrapping_add, usize);
35#[cfg(has_i128)]
36wrapping_impl!(WrappingAdd, wrapping_add, u128);
37
38wrapping_impl!(WrappingAdd, wrapping_add, i8);
39wrapping_impl!(WrappingAdd, wrapping_add, i16);
40wrapping_impl!(WrappingAdd, wrapping_add, i32);
41wrapping_impl!(WrappingAdd, wrapping_add, i64);
42wrapping_impl!(WrappingAdd, wrapping_add, isize);
43#[cfg(has_i128)]
44wrapping_impl!(WrappingAdd, wrapping_add, i128);
45
46pub trait WrappingSub: Sized + Sub<Self, Output = Self> {
48 fn wrapping_sub(&self, v: &Self) -> Self;
51}
52
53wrapping_impl!(WrappingSub, wrapping_sub, u8);
54wrapping_impl!(WrappingSub, wrapping_sub, u16);
55wrapping_impl!(WrappingSub, wrapping_sub, u32);
56wrapping_impl!(WrappingSub, wrapping_sub, u64);
57wrapping_impl!(WrappingSub, wrapping_sub, usize);
58#[cfg(has_i128)]
59wrapping_impl!(WrappingSub, wrapping_sub, u128);
60
61wrapping_impl!(WrappingSub, wrapping_sub, i8);
62wrapping_impl!(WrappingSub, wrapping_sub, i16);
63wrapping_impl!(WrappingSub, wrapping_sub, i32);
64wrapping_impl!(WrappingSub, wrapping_sub, i64);
65wrapping_impl!(WrappingSub, wrapping_sub, isize);
66#[cfg(has_i128)]
67wrapping_impl!(WrappingSub, wrapping_sub, i128);
68
69pub trait WrappingMul: Sized + Mul<Self, Output = Self> {
71 fn wrapping_mul(&self, v: &Self) -> Self;
74}
75
76wrapping_impl!(WrappingMul, wrapping_mul, u8);
77wrapping_impl!(WrappingMul, wrapping_mul, u16);
78wrapping_impl!(WrappingMul, wrapping_mul, u32);
79wrapping_impl!(WrappingMul, wrapping_mul, u64);
80wrapping_impl!(WrappingMul, wrapping_mul, usize);
81#[cfg(has_i128)]
82wrapping_impl!(WrappingMul, wrapping_mul, u128);
83
84wrapping_impl!(WrappingMul, wrapping_mul, i8);
85wrapping_impl!(WrappingMul, wrapping_mul, i16);
86wrapping_impl!(WrappingMul, wrapping_mul, i32);
87wrapping_impl!(WrappingMul, wrapping_mul, i64);
88wrapping_impl!(WrappingMul, wrapping_mul, isize);
89#[cfg(has_i128)]
90wrapping_impl!(WrappingMul, wrapping_mul, i128);
91
92macro_rules! wrapping_shift_impl {
93 ($trait_name:ident, $method:ident, $t:ty) => {
94 impl $trait_name for $t {
95 #[inline]
96 fn $method(&self, rhs: u32) -> $t {
97 <$t>::$method(*self, rhs)
98 }
99 }
100 };
101}
102
103pub trait WrappingShl: Sized + Shl<usize, Output = Self> {
105 fn wrapping_shl(&self, rhs: u32) -> Self;
120}
121
122wrapping_shift_impl!(WrappingShl, wrapping_shl, u8);
123wrapping_shift_impl!(WrappingShl, wrapping_shl, u16);
124wrapping_shift_impl!(WrappingShl, wrapping_shl, u32);
125wrapping_shift_impl!(WrappingShl, wrapping_shl, u64);
126wrapping_shift_impl!(WrappingShl, wrapping_shl, usize);
127#[cfg(has_i128)]
128wrapping_shift_impl!(WrappingShl, wrapping_shl, u128);
129
130wrapping_shift_impl!(WrappingShl, wrapping_shl, i8);
131wrapping_shift_impl!(WrappingShl, wrapping_shl, i16);
132wrapping_shift_impl!(WrappingShl, wrapping_shl, i32);
133wrapping_shift_impl!(WrappingShl, wrapping_shl, i64);
134wrapping_shift_impl!(WrappingShl, wrapping_shl, isize);
135#[cfg(has_i128)]
136wrapping_shift_impl!(WrappingShl, wrapping_shl, i128);
137
138pub trait WrappingShr: Sized + Shr<usize, Output = Self> {
140 fn wrapping_shr(&self, rhs: u32) -> Self;
155}
156
157wrapping_shift_impl!(WrappingShr, wrapping_shr, u8);
158wrapping_shift_impl!(WrappingShr, wrapping_shr, u16);
159wrapping_shift_impl!(WrappingShr, wrapping_shr, u32);
160wrapping_shift_impl!(WrappingShr, wrapping_shr, u64);
161wrapping_shift_impl!(WrappingShr, wrapping_shr, usize);
162#[cfg(has_i128)]
163wrapping_shift_impl!(WrappingShr, wrapping_shr, u128);
164
165wrapping_shift_impl!(WrappingShr, wrapping_shr, i8);
166wrapping_shift_impl!(WrappingShr, wrapping_shr, i16);
167wrapping_shift_impl!(WrappingShr, wrapping_shr, i32);
168wrapping_shift_impl!(WrappingShr, wrapping_shr, i64);
169wrapping_shift_impl!(WrappingShr, wrapping_shr, isize);
170#[cfg(has_i128)]
171wrapping_shift_impl!(WrappingShr, wrapping_shr, i128);
172
173impl<T: WrappingAdd> WrappingAdd for Wrapping<T>
175where
176 Wrapping<T>: Add<Output = Wrapping<T>>,
177{
178 fn wrapping_add(&self, v: &Self) -> Self {
179 Wrapping(self.0.wrapping_add(&v.0))
180 }
181}
182impl<T: WrappingSub> WrappingSub for Wrapping<T>
183where
184 Wrapping<T>: Sub<Output = Wrapping<T>>,
185{
186 fn wrapping_sub(&self, v: &Self) -> Self {
187 Wrapping(self.0.wrapping_sub(&v.0))
188 }
189}
190impl<T: WrappingMul> WrappingMul for Wrapping<T>
191where
192 Wrapping<T>: Mul<Output = Wrapping<T>>,
193{
194 fn wrapping_mul(&self, v: &Self) -> Self {
195 Wrapping(self.0.wrapping_mul(&v.0))
196 }
197}
198impl<T: WrappingShl> WrappingShl for Wrapping<T>
199where
200 Wrapping<T>: Shl<usize, Output = Wrapping<T>>,
201{
202 fn wrapping_shl(&self, rhs: u32) -> Self {
203 Wrapping(self.0.wrapping_shl(rhs))
204 }
205}
206impl<T: WrappingShr> WrappingShr for Wrapping<T>
207where
208 Wrapping<T>: Shr<usize, Output = Wrapping<T>>,
209{
210 fn wrapping_shr(&self, rhs: u32) -> Self {
211 Wrapping(self.0.wrapping_shr(rhs))
212 }
213}
214
215#[test]
216fn test_wrapping_traits() {
217 fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T {
218 a.wrapping_add(&b)
219 }
220 fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T {
221 a.wrapping_sub(&b)
222 }
223 fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T {
224 a.wrapping_mul(&b)
225 }
226 fn wrapping_shl<T: WrappingShl>(a: T, b: u32) -> T {
227 a.wrapping_shl(b)
228 }
229 fn wrapping_shr<T: WrappingShr>(a: T, b: u32) -> T {
230 a.wrapping_shr(b)
231 }
232 assert_eq!(wrapping_add(255, 1), 0u8);
233 assert_eq!(wrapping_sub(0, 1), 255u8);
234 assert_eq!(wrapping_mul(255, 2), 254u8);
235 assert_eq!(wrapping_shl(255, 8), 255u8);
236 assert_eq!(wrapping_shr(255, 8), 255u8);
237 assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
238 assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
239 assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
240 assert_eq!(wrapping_shl(255, 8), (Wrapping(255u8) << 8).0);
241 assert_eq!(wrapping_shr(255, 8), (Wrapping(255u8) >> 8).0);
242}
243
244#[test]
245fn wrapping_is_wrappingadd() {
246 fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
247 require_wrappingadd(&Wrapping(42));
248}
249
250#[test]
251fn wrapping_is_wrappingsub() {
252 fn require_wrappingsub<T: WrappingSub>(_: &T) {}
253 require_wrappingsub(&Wrapping(42));
254}
255
256#[test]
257fn wrapping_is_wrappingmul() {
258 fn require_wrappingmul<T: WrappingMul>(_: &T) {}
259 require_wrappingmul(&Wrapping(42));
260}
261
262#[test]
263fn wrapping_is_wrappingshl() {
264 fn require_wrappingshl<T: WrappingShl>(_: &T) {}
265 require_wrappingshl(&Wrapping(42));
266}
267
268#[test]
269fn wrapping_is_wrappingshr() {
270 fn require_wrappingshr<T: WrappingShr>(_: &T) {}
271 require_wrappingshr(&Wrapping(42));
272}