strafe_type/float/constraint/
integer.rs1use std::fmt::{Debug, Display, Formatter};
2
3use num_traits::{FromPrimitive, ToPrimitive};
4
5use crate::float::constraint::float_constraint::FloatConstraint;
6
7#[derive(Debug, Copy, Clone)]
8pub struct Integer<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint>(
9 pub(crate) T,
10);
11
12impl<T> Display for Integer<T>
13where
14 T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint + Display,
15{
16 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
17 Display::fmt(&self.0, f)
18 }
19}
20
21impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> FloatConstraint
22 for Integer<T>
23{
24 #[inline]
25 fn get_f64(&self) -> f64 {
26 self.0.get_f64()
27 }
28
29 #[inline]
30 fn constraint(&self) -> bool {
31 self.0.constraint() && self.0.get_f64().trunc() == self.0.get_f64()
32 }
33}
34
35impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<isize>
36 for Integer<T>
37{
38 #[inline]
39 fn from(n: isize) -> Self {
40 Self::from_isize(n).unwrap()
41 }
42}
43
44impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&isize>
45 for Integer<T>
46{
47 #[inline]
48 fn from(n: &isize) -> Self {
49 Self::from_isize(*n).unwrap()
50 }
51}
52
53impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut isize>
54 for Integer<T>
55{
56 #[inline]
57 fn from(n: &mut isize) -> Self {
58 Self::from_isize(*n).unwrap()
59 }
60}
61
62impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
63 for isize
64{
65 #[inline]
66 fn from(n: Integer<T>) -> Self {
67 n.to_isize().unwrap()
68 }
69}
70
71impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i8>
72 for Integer<T>
73{
74 #[inline]
75 fn from(n: i8) -> Self {
76 Self::from_i8(n).unwrap()
77 }
78}
79
80impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i8>
81 for Integer<T>
82{
83 #[inline]
84 fn from(n: &i8) -> Self {
85 Self::from_i8(*n).unwrap()
86 }
87}
88
89impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i8>
90 for Integer<T>
91{
92 #[inline]
93 fn from(n: &mut i8) -> Self {
94 Self::from_i8(*n).unwrap()
95 }
96}
97
98impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
99 for i8
100{
101 #[inline]
102 fn from(n: Integer<T>) -> Self {
103 n.to_i8().unwrap()
104 }
105}
106
107impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i16>
108 for Integer<T>
109{
110 #[inline]
111 fn from(n: i16) -> Self {
112 Self::from_i16(n).unwrap()
113 }
114}
115
116impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i16>
117 for Integer<T>
118{
119 #[inline]
120 fn from(n: &i16) -> Self {
121 Self::from_i16(*n).unwrap()
122 }
123}
124
125impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i16>
126 for Integer<T>
127{
128 #[inline]
129 fn from(n: &mut i16) -> Self {
130 Self::from_i16(*n).unwrap()
131 }
132}
133
134impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
135 for i16
136{
137 #[inline]
138 fn from(n: Integer<T>) -> Self {
139 n.to_i16().unwrap()
140 }
141}
142
143impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i32>
144 for Integer<T>
145{
146 #[inline]
147 fn from(n: i32) -> Self {
148 Self::from_i32(n).unwrap()
149 }
150}
151
152impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i32>
153 for Integer<T>
154{
155 #[inline]
156 fn from(n: &i32) -> Self {
157 Self::from_i32(*n).unwrap()
158 }
159}
160
161impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i32>
162 for Integer<T>
163{
164 #[inline]
165 fn from(n: &mut i32) -> Self {
166 Self::from_i32(*n).unwrap()
167 }
168}
169
170impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
171 for i32
172{
173 #[inline]
174 fn from(n: Integer<T>) -> Self {
175 n.to_i32().unwrap()
176 }
177}
178
179impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i64>
180 for Integer<T>
181{
182 #[inline]
183 fn from(n: i64) -> Self {
184 Self::from_i64(n).unwrap()
185 }
186}
187
188impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i64>
189 for Integer<T>
190{
191 #[inline]
192 fn from(n: &i64) -> Self {
193 Self::from_i64(*n).unwrap()
194 }
195}
196
197impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i64>
198 for Integer<T>
199{
200 #[inline]
201 fn from(n: &mut i64) -> Self {
202 Self::from_i64(*n).unwrap()
203 }
204}
205
206impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
207 for i64
208{
209 #[inline]
210 fn from(n: Integer<T>) -> Self {
211 n.to_i64().unwrap()
212 }
213}
214
215impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i128>
216 for Integer<T>
217{
218 #[inline]
219 fn from(n: i128) -> Self {
220 Self::from_i128(n).unwrap()
221 }
222}
223
224impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i128>
225 for Integer<T>
226{
227 #[inline]
228 fn from(n: &i128) -> Self {
229 Self::from_i128(*n).unwrap()
230 }
231}
232
233impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i128>
234 for Integer<T>
235{
236 #[inline]
237 fn from(n: &mut i128) -> Self {
238 Self::from_i128(*n).unwrap()
239 }
240}
241
242impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
243 for i128
244{
245 #[inline]
246 fn from(n: Integer<T>) -> Self {
247 n.to_i128().unwrap()
248 }
249}
250
251impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<usize>
252 for Integer<T>
253{
254 #[inline]
255 fn from(n: usize) -> Self {
256 Self::from_usize(n).unwrap()
257 }
258}
259
260impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&usize>
261 for Integer<T>
262{
263 #[inline]
264 fn from(n: &usize) -> Self {
265 Self::from_usize(*n).unwrap()
266 }
267}
268
269impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut usize>
270 for Integer<T>
271{
272 #[inline]
273 fn from(n: &mut usize) -> Self {
274 Self::from_usize(*n).unwrap()
275 }
276}
277
278impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
279 for usize
280{
281 #[inline]
282 fn from(n: Integer<T>) -> Self {
283 n.to_usize().unwrap()
284 }
285}
286
287impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u8>
288 for Integer<T>
289{
290 #[inline]
291 fn from(n: u8) -> Self {
292 Self::from_u8(n).unwrap()
293 }
294}
295
296impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u8>
297 for Integer<T>
298{
299 #[inline]
300 fn from(n: &u8) -> Self {
301 Self::from_u8(*n).unwrap()
302 }
303}
304
305impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u8>
306 for Integer<T>
307{
308 #[inline]
309 fn from(n: &mut u8) -> Self {
310 Self::from_u8(*n).unwrap()
311 }
312}
313
314impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
315 for u8
316{
317 #[inline]
318 fn from(n: Integer<T>) -> Self {
319 n.to_u8().unwrap()
320 }
321}
322
323impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u16>
324 for Integer<T>
325{
326 #[inline]
327 fn from(n: u16) -> Self {
328 Self::from_u16(n).unwrap()
329 }
330}
331
332impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u16>
333 for Integer<T>
334{
335 #[inline]
336 fn from(n: &u16) -> Self {
337 Self::from_u16(*n).unwrap()
338 }
339}
340
341impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u16>
342 for Integer<T>
343{
344 #[inline]
345 fn from(n: &mut u16) -> Self {
346 Self::from_u16(*n).unwrap()
347 }
348}
349
350impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
351 for u16
352{
353 #[inline]
354 fn from(n: Integer<T>) -> Self {
355 n.to_u16().unwrap()
356 }
357}
358
359impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u32>
360 for Integer<T>
361{
362 #[inline]
363 fn from(n: u32) -> Self {
364 Self::from_u32(n).unwrap()
365 }
366}
367
368impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u32>
369 for Integer<T>
370{
371 #[inline]
372 fn from(n: &u32) -> Self {
373 Self::from_u32(*n).unwrap()
374 }
375}
376
377impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u32>
378 for Integer<T>
379{
380 #[inline]
381 fn from(n: &mut u32) -> Self {
382 Self::from_u32(*n).unwrap()
383 }
384}
385
386impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
387 for u32
388{
389 #[inline]
390 fn from(n: Integer<T>) -> Self {
391 n.to_u32().unwrap()
392 }
393}
394
395impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u64>
396 for Integer<T>
397{
398 #[inline]
399 fn from(n: u64) -> Self {
400 Self::from_u64(n).unwrap()
401 }
402}
403
404impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u64>
405 for Integer<T>
406{
407 #[inline]
408 fn from(n: &u64) -> Self {
409 Self::from_u64(*n).unwrap()
410 }
411}
412
413impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u64>
414 for Integer<T>
415{
416 #[inline]
417 fn from(n: &mut u64) -> Self {
418 Self::from_u64(*n).unwrap()
419 }
420}
421
422impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
423 for u64
424{
425 #[inline]
426 fn from(n: Integer<T>) -> Self {
427 n.to_u64().unwrap()
428 }
429}
430
431impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u128>
432 for Integer<T>
433{
434 #[inline]
435 fn from(n: u128) -> Self {
436 Self::from_u128(n).unwrap()
437 }
438}
439
440impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u128>
441 for Integer<T>
442{
443 #[inline]
444 fn from(n: &u128) -> Self {
445 Self::from_u128(*n).unwrap()
446 }
447}
448
449impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u128>
450 for Integer<T>
451{
452 #[inline]
453 fn from(n: &mut u128) -> Self {
454 Self::from_u128(*n).unwrap()
455 }
456}
457
458impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
459 for u128
460{
461 #[inline]
462 fn from(n: Integer<T>) -> Self {
463 n.to_u128().unwrap()
464 }
465}
466
467impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<f32>
468 for Integer<T>
469{
470 #[inline]
471 fn from(n: f32) -> Self {
472 Self::from_f32(n).unwrap()
473 }
474}
475
476impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&f32>
477 for Integer<T>
478{
479 #[inline]
480 fn from(n: &f32) -> Self {
481 Self::from_f32(*n).unwrap()
482 }
483}
484
485impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut f32>
486 for Integer<T>
487{
488 #[inline]
489 fn from(n: &mut f32) -> Self {
490 Self::from_f32(*n).unwrap()
491 }
492}
493
494impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
495 for f32
496{
497 #[inline]
498 fn from(n: Integer<T>) -> Self {
499 n.to_f32().unwrap()
500 }
501}
502
503impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<f64>
504 for Integer<T>
505{
506 #[inline]
507 fn from(n: f64) -> Self {
508 Self::from_f64(n).unwrap()
509 }
510}
511
512impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&f64>
513 for Integer<T>
514{
515 #[inline]
516 fn from(n: &f64) -> Self {
517 Self::from_f64(*n).unwrap()
518 }
519}
520
521impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut f64>
522 for Integer<T>
523{
524 #[inline]
525 fn from(n: &mut f64) -> Self {
526 Self::from_f64(*n).unwrap()
527 }
528}
529
530impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Integer<T>>
531 for f64
532{
533 #[inline]
534 fn from(n: Integer<T>) -> Self {
535 n.to_f64().unwrap()
536 }
537}
538
539impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> ToPrimitive
540 for Integer<T>
541{
542 #[inline]
543 fn to_isize(&self) -> Option<isize> {
544 self.0.to_isize()
545 }
546
547 #[inline]
548 fn to_i8(&self) -> Option<i8> {
549 self.0.to_i8()
550 }
551
552 #[inline]
553 fn to_i16(&self) -> Option<i16> {
554 self.0.to_i16()
555 }
556
557 #[inline]
558 fn to_i32(&self) -> Option<i32> {
559 self.0.to_i32()
560 }
561
562 #[inline]
563 fn to_i64(&self) -> Option<i64> {
564 self.0.to_i64()
565 }
566
567 #[inline]
568 fn to_i128(&self) -> Option<i128> {
569 self.0.to_i128()
570 }
571
572 #[inline]
573 fn to_usize(&self) -> Option<usize> {
574 self.0.to_usize()
575 }
576
577 #[inline]
578 fn to_u8(&self) -> Option<u8> {
579 self.0.to_u8()
580 }
581
582 #[inline]
583 fn to_u16(&self) -> Option<u16> {
584 self.0.to_u16()
585 }
586
587 #[inline]
588 fn to_u32(&self) -> Option<u32> {
589 self.0.to_u32()
590 }
591
592 #[inline]
593 fn to_u64(&self) -> Option<u64> {
594 self.0.to_u64()
595 }
596
597 #[inline]
598 fn to_u128(&self) -> Option<u128> {
599 self.0.to_u128()
600 }
601
602 #[inline]
603 fn to_f32(&self) -> Option<f32> {
604 self.0.to_f32()
605 }
606
607 #[inline]
608 fn to_f64(&self) -> Option<f64> {
609 self.0.to_f64()
610 }
611}
612
613impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> FromPrimitive
614 for Integer<T>
615{
616 #[inline]
617 fn from_isize(n: isize) -> Option<Self> {
618 let ret = T::from_isize(n).map(|t| Self(t));
619 #[cfg(debug_assertions)]
620 if !ret.clone().unwrap().constraint() {
621 panic!("Integer failed: {:?}", ret);
622 }
623 ret
624 }
625
626 #[inline]
627 fn from_i8(n: i8) -> Option<Self> {
628 let ret = T::from_i8(n).map(|t| Self(t));
629 #[cfg(debug_assertions)]
630 if !ret.clone().unwrap().constraint() {
631 panic!("Integer failed: {:?}", ret);
632 }
633 ret
634 }
635
636 #[inline]
637 fn from_i16(n: i16) -> Option<Self> {
638 let ret = T::from_i16(n).map(|t| Self(t));
639 #[cfg(debug_assertions)]
640 if !ret.clone().unwrap().constraint() {
641 panic!("Integer failed: {:?}", ret);
642 }
643 ret
644 }
645
646 #[inline]
647 fn from_i32(n: i32) -> Option<Self> {
648 let ret = T::from_i32(n).map(|t| Self(t));
649 #[cfg(debug_assertions)]
650 if !ret.clone().unwrap().constraint() {
651 panic!("Integer failed: {:?}", ret);
652 }
653 ret
654 }
655
656 #[inline]
657 fn from_i64(n: i64) -> Option<Self> {
658 let ret = T::from_i64(n).map(|t| Self(t));
659 #[cfg(debug_assertions)]
660 if !ret.clone().unwrap().constraint() {
661 panic!("Integer failed: {:?}", ret);
662 }
663 ret
664 }
665
666 #[inline]
667 fn from_i128(n: i128) -> Option<Self> {
668 let ret = T::from_i128(n).map(|t| Self(t));
669 #[cfg(debug_assertions)]
670 if !ret.clone().unwrap().constraint() {
671 panic!("Integer failed: {:?}", ret);
672 }
673 ret
674 }
675
676 #[inline]
677 fn from_usize(n: usize) -> Option<Self> {
678 let ret = T::from_usize(n).map(|t| Self(t));
679 #[cfg(debug_assertions)]
680 if !ret.clone().unwrap().constraint() {
681 panic!("Integer failed: {:?}", ret);
682 }
683 ret
684 }
685
686 #[inline]
687 fn from_u8(n: u8) -> Option<Self> {
688 let ret = T::from_u8(n).map(|t| Self(t));
689 #[cfg(debug_assertions)]
690 if !ret.clone().unwrap().constraint() {
691 panic!("Integer failed: {:?}", ret);
692 }
693 ret
694 }
695
696 #[inline]
697 fn from_u16(n: u16) -> Option<Self> {
698 let ret = T::from_u16(n).map(|t| Self(t));
699 #[cfg(debug_assertions)]
700 if !ret.clone().unwrap().constraint() {
701 panic!("Integer failed: {:?}", ret);
702 }
703 ret
704 }
705
706 #[inline]
707 fn from_u32(n: u32) -> Option<Self> {
708 let ret = T::from_u32(n).map(|t| Self(t));
709 #[cfg(debug_assertions)]
710 if !ret.clone().unwrap().constraint() {
711 panic!("Integer failed: {:?}", ret);
712 }
713 ret
714 }
715
716 #[inline]
717 fn from_u64(n: u64) -> Option<Self> {
718 let ret = T::from_u64(n).map(|t| Self(t));
719 #[cfg(debug_assertions)]
720 if !ret.clone().unwrap().constraint() {
721 panic!("Integer failed: {:?}", ret);
722 }
723 ret
724 }
725
726 #[inline]
727 fn from_u128(n: u128) -> Option<Self> {
728 let ret = T::from_u128(n).map(|t| Self(t));
729 #[cfg(debug_assertions)]
730 if !ret.clone().unwrap().constraint() {
731 panic!("Integer failed: {:?}", ret);
732 }
733 ret
734 }
735
736 #[inline]
737 fn from_f32(n: f32) -> Option<Self> {
738 let ret = T::from_f32(n).map(|t| Self(t));
739 #[cfg(debug_assertions)]
740 if !ret.clone().unwrap().constraint() {
741 panic!("Integer failed: {:?}", ret);
742 }
743 ret
744 }
745
746 #[inline]
747 fn from_f64(n: f64) -> Option<Self> {
748 let ret = T::from_f64(n).map(|t| Self(t));
749 #[cfg(debug_assertions)]
750 if !ret.clone().unwrap().constraint() {
751 panic!("Integer failed: {:?}", ret);
752 }
753 ret
754 }
755}