comfy_bounded_ints/pad_to/
mod.rs1pub use pad_i128::PadTo_i128;
2pub use pad_i16::PadTo_i16;
3pub use pad_i32::PadTo_i32;
4pub use pad_i64::PadTo_i64;
5pub use pad_isize::PadTo_isize;
6pub use pad_u128::PadTo_u128;
7pub use pad_u16::PadTo_u16;
8pub use pad_u32::PadTo_u32;
9pub use pad_u64::PadTo_u64;
10pub use pad_usize::PadTo_usize;
11
12mod pad_i16;
13mod pad_i32;
14mod pad_i64;
15mod pad_i128;
16mod pad_isize;
17
18mod pad_u16;
19mod pad_u32;
20mod pad_u64;
21mod pad_u128;
22mod pad_usize;
23
24pub trait PadTo<T> {
25 fn pad_to(&self) -> T;
26}
27
28pub mod gen_i16 {
29 use super::*;
30
31 impl<T> PadTo<i16> for T where T: PadTo_i16 {
32 #[inline(always)]
33 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
34 fn pad_to(&self) -> i16 {
35 return self.pad_to_i16();
36 }
37 }
38
39 #[cfg(test)]
40 mod tests {
41 use super::*;
42
43 #[test]
44 fn test_pad_to_i16() {
45 inner(127_i8, 127);
46 inner(-128_i8, -128);
47
48 inner(32767_i16, 32767);
49 inner(-32768_i16, -32768);
50
51 inner(0_u8, 0);
52 inner(255_u8, 255);
53 }
54
55 fn inner(input: impl PadTo_i16, expect: i16) {
56 assert_eq!(input.pad_to(), expect);
57 }
58 }
59}
60
61pub mod gen_i32 {
62 use super::*;
63
64 impl<T> PadTo<i32> for T where T: PadTo_i32 {
65 #[inline(always)]
66 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
67 fn pad_to(&self) -> i32 {
68 return self.pad_to_i32();
69 }
70 }
71
72 #[cfg(test)]
73 mod tests {
74 use super::*;
75
76 #[test]
77 fn test_pad_to_i32() {
78 inner(127_i8, 127);
79 inner(-128_i8, -128);
80
81 inner(32767_i16, 32767);
82 inner(-32768_i16, -32768);
83
84 inner(2147483647_i32, 2147483647);
85 inner(-2147483648_i32, -2147483648);
86
87 #[cfg(target_pointer_width = "32")]
88 {
89 inner(isize::MIN, isize::MIN as i32);
90 inner(isize::MAX, isize::MAX as i32);
91 }
92
93
94 inner(0_u8, 0);
95 inner(255_u8, 255);
96
97 inner(0_u16, 0);
98 inner(65535_u16, 65535);
99 }
100
101 fn inner(input: impl PadTo_i32, expect: i32) {
102 assert_eq!(input.pad_to(), expect);
103 }
104 }
105}
106
107pub mod gen_i64 {
108 use super::*;
109
110 impl<T> PadTo<i64> for T where T: PadTo_i64 {
111 #[inline(always)]
112 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
113 fn pad_to(&self) -> i64 {
114 return self.pad_to_i64();
115 }
116 }
117
118 #[cfg(test)]
119 mod tests {
120 use super::*;
121
122 #[test]
123 fn test_pad_to_i64() {
124 inner(127_i8, 127);
125 inner(-128_i8, -128);
126
127 inner(32767_i16, 32767);
128 inner(-32768_i16, -32768);
129
130 inner(2147483647_i32, 2147483647);
131 inner(-2147483648_i32, -2147483648);
132
133 inner(9223372036854775807_i64, 9223372036854775807);
134 inner(-9223372036854775808_i64, -9223372036854775808);
135
136 inner(isize::MIN, isize::MIN as i64);
137 inner(isize::MAX, isize::MAX as i64);
138
139 inner(0_u8, 0);
140 inner(255_u8, 255);
141
142 inner(0_u16, 0);
143 inner(65535_u16, 65535);
144
145 inner(0_u32, 0);
146 inner(4294967295_u32, 4294967295);
147
148 #[cfg(target_pointer_width = "32")]
149 {
150 inner(0_usize, 0);
151 inner(usize::MAX, usize::MAX as i64);
152 }
153 }
154
155 fn inner(input: impl PadTo_i64, expect: i64) {
156 assert_eq!(input.pad_to(), expect);
157 }
158 }
159}
160
161pub mod gen_i128 {
162 use super::*;
163
164 impl<T> PadTo<i128> for T where T: PadTo_i128 {
165 #[inline(always)]
166 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
167 fn pad_to(&self) -> i128 {
168 return self.pad_to_i128();
169 }
170 }
171
172 #[cfg(test)]
173 mod tests {
174 use super::*;
175
176 #[test]
177 fn test_pad_to_i128() {
178 inner(127_i8, 127);
179 inner(-128_i8, -128);
180
181 inner(32767_i16, 32767);
182 inner(-32768_i16, -32768);
183
184 inner(2147483647_i32, 2147483647);
185 inner(-2147483648_i32, -2147483648);
186
187 inner(9223372036854775807_i64, 9223372036854775807);
188 inner(-9223372036854775808_i64, -9223372036854775808);
189
190 inner(isize::MIN, isize::MIN as i128);
191 inner(isize::MAX, isize::MAX as i128);
192
193 inner(170141183460469231731687303715884105727_i128, 170141183460469231731687303715884105727);
194 inner(-170141183460469231731687303715884105728_i128, -170141183460469231731687303715884105728);
195
196 inner(0_u8, 0);
197 inner(255_u8, 255);
198
199 inner(0_u16, 0);
200 inner(65535_u16, 65535);
201
202 inner(0_u32, 0);
203 inner(4294967295_u32, 4294967295);
204
205 inner(0_u64, 0);
206 inner(18446744073709551615_u64, 18446744073709551615);
207
208 inner(0_usize, 0);
209 inner(usize::MAX, usize::MAX as i128);
210 }
211
212 fn inner(input: impl PadTo_i128, expect: i128) {
213 assert_eq!(input.pad_to(), expect);
214 }
215 }
216}
217
218pub mod gen_isize {
219 use super::*;
220
221 impl<T> PadTo<isize> for T where T: PadTo_isize {
222 #[inline(always)]
223 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
224 fn pad_to(&self) -> isize {
225 return self.pad_to_isize();
226 }
227 }
228
229 #[cfg(test)]
230 mod tests {
231 use super::*;
232
233 #[test]
234 fn test_pad_to_isize() {
235 inner(127_i8, 127);
236 inner(-128_i8, -128);
237
238 inner(32767_i16, 32767);
239 inner(-32768_i16, -32768);
240
241 inner(2147483647_i32, 2147483647);
242 inner(-2147483648_i32, -2147483648);
243
244 #[cfg(target_pointer_width = "64")]
245 {
246 inner(9223372036854775807_i64, 9223372036854775807);
247 inner(-9223372036854775808_i64, -9223372036854775808);
248 }
249
250 inner(isize::MIN, isize::MIN);
251 inner(isize::MAX, isize::MAX);
252
253 inner(0_u8, 0);
254 inner(255_u8, 255);
255
256 inner(0_u16, 0);
257 inner(65535_u16, 65535);
258
259 #[cfg(target_pointer_width = "64")]
260 {
261 inner(0_u32, 0);
262 inner(4294967295_u32, 4294967295);
263 }
264 }
265
266 fn inner(input: impl PadTo_isize, expect: isize) {
267 assert_eq!(input.pad_to(), expect);
268 }
269 }
270}
271
272pub mod gen_u16 {
273 use super::*;
274
275 impl<T> PadTo<u16> for T where T: PadTo_u16 {
276 #[inline(always)]
277 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
278 fn pad_to(&self) -> u16 {
279 return self.pad_to_u16();
280 }
281 }
282
283 #[cfg(test)]
284 mod tests {
285 use super::*;
286
287 #[test]
288 fn test_pad_to_u16() {
289 inner(0_u8, 0);
290 inner(255_u8, 255);
291
292 inner(0_u16, 0);
293 inner(65535_u16, 65535);
294 }
295
296 fn inner(input: impl PadTo_u16, expect: u16) {
297 assert_eq!(input.pad_to(), expect);
298 }
299 }
300}
301
302pub mod gen_u32 {
303 use super::*;
304
305 impl<T> PadTo<u32> for T where T: PadTo_u32 {
306 #[inline(always)]
307 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
308 fn pad_to(&self) -> u32 {
309 return self.pad_to_u32();
310 }
311 }
312
313 #[cfg(test)]
314 mod tests {
315 use super::*;
316
317 #[test]
318 fn test_pad_to_u32() {
319 inner(0_u8, 0);
320 inner(255_u8, 255);
321
322 inner(0_u16, 0);
323 inner(65535_u16, 65535);
324
325 inner(0_u32, 0);
326 inner(4294967295_u32, 4294967295);
327
328 #[cfg(target_pointer_width = "32")]
329 {
330 inner(0_usize, 0);
331 inner(usize::MAX, usize::MAX as u32);
332 }
333 }
334
335 fn inner(input: impl PadTo_u32, expect: u32) {
336 assert_eq!(input.pad_to(), expect);
337 }
338 }
339}
340
341pub mod gen_u64 {
342 use super::*;
343
344 impl<T> PadTo<u64> for T where T: PadTo_u64 {
345 #[inline(always)]
346 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
347 fn pad_to(&self) -> u64 {
348 return self.pad_to_u64();
349 }
350 }
351
352 #[cfg(test)]
353 mod tests {
354 use super::*;
355
356 #[test]
357 fn test_pad_to_u64() {
358 inner(0_u8, 0);
359 inner(255_u8, 255);
360
361 inner(0_u16, 0);
362 inner(65535_u16, 65535);
363
364 inner(0_u32, 0);
365 inner(4294967295_u32, 4294967295);
366
367 inner(0_u64, 0);
368 inner(18446744073709551615_u64, 18446744073709551615);
369
370 inner(0_usize, 0);
371 inner(usize::MAX, usize::MAX as u64);
372 }
373
374 fn inner(input: impl PadTo_u64, expect: u64) {
375 assert_eq!(input.pad_to(), expect);
376 }
377 }
378}
379
380pub mod gen_u128 {
381 use super::*;
382
383 impl<T> PadTo<u128> for T where T: PadTo_u128 {
384 #[inline(always)]
385 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
386 fn pad_to(&self) -> u128 {
387 return self.pad_to_u128();
388 }
389 }
390
391 #[cfg(test)]
392 mod tests {
393 use super::*;
394
395 #[test]
396 fn test_pad_to_u128() {
397 inner(0_u8, 0);
398 inner(255_u8, 255);
399
400 inner(0_u16, 0);
401 inner(65535_u16, 65535);
402
403 inner(0_u32, 0);
404 inner(4294967295_u32, 4294967295);
405
406 inner(0_u64, 0);
407 inner(18446744073709551615_u64, 18446744073709551615);
408
409 inner(0_u128, 0);
410 inner(340282366920938463463374607431768211455_u128, 340282366920938463463374607431768211455);
411
412 inner(0_usize, 0);
413 inner(usize::MAX, usize::MAX as u128);
414 }
415
416 fn inner(input: impl PadTo_u128, expect: u128) {
417 assert_eq!(input.pad_to(), expect);
418 }
419 }
420}
421
422pub mod gen_usize {
423 use super::*;
424
425 impl<T> PadTo<usize> for T where T: PadTo_usize {
426 #[inline(always)]
427 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
428 fn pad_to(&self) -> usize {
429 return self.pad_to_usize();
430 }
431 }
432
433 #[cfg(test)]
434 mod tests {
435 use super::*;
436
437 #[test]
438 fn test_pad_to_usize() {
439 inner(0_u8, 0);
440 inner(255_u8, 255);
441
442 inner(0_u16, 0);
443 inner(65535_u16, 65535);
444
445 inner(0_u32, 0);
446 inner(4294967295_u32, 4294967295);
447
448 #[cfg(target_pointer_width = "64")]
449 {
450 inner(0_u64, 0);
451 inner(18446744073709551615_u64, 18446744073709551615);
452 }
453
454 inner(0_usize, 0);
455 inner(usize::MAX, usize::MAX);
456 }
457
458 fn inner(input: impl PadTo_usize, expect: usize) {
459 assert_eq!(input.pad_to(), expect);
460 }
461 }
462}