tracing_formatters/
util.rs

1pub enum IntegerConversionError {
2    Underflow,
3    NaN,
4    Overflow,
5}
6
7pub trait UtilTryInto<I> {
8    type Error;
9
10    fn util_try_into(self) -> Result<I, Self::Error>;
11}
12
13impl UtilTryInto<i64> for f64 {
14    type Error = IntegerConversionError;
15    fn util_try_into(self) -> Result<i64, Self::Error> {
16        let f = self.round();
17
18        if f.is_nan() {
19            return Err(IntegerConversionError::NaN);
20        }
21
22        if f < 0.0 {
23            return Err(IntegerConversionError::Underflow);
24        }
25        if f > i64::MAX as f64 {
26            return Err(IntegerConversionError::Overflow);
27        }
28
29        Ok(f as i64)
30    }
31}
32
33impl UtilTryInto<i64> for u64 {
34    type Error = IntegerConversionError;
35    fn util_try_into(self) -> Result<i64, Self::Error> {
36        let f = self;
37
38        if f < 0 {
39            return Err(IntegerConversionError::Underflow);
40        }
41        if f > i64::MAX as u64 {
42            return Err(IntegerConversionError::Overflow);
43        }
44
45        Ok(f as i64)
46    }
47}
48
49impl UtilTryInto<u32> for f64 {
50    type Error = IntegerConversionError;
51    fn util_try_into(self) -> Result<u32, Self::Error> {
52        let f = self.round();
53
54        if f.is_nan() {
55            return Err(IntegerConversionError::NaN);
56        }
57
58        if f < 0.0 {
59            return Err(IntegerConversionError::Underflow);
60        }
61        if f > u32::MAX as f64 {
62            return Err(IntegerConversionError::Overflow);
63        }
64
65        Ok(f as u32)
66    }
67}
68impl UtilTryInto<u32> for u64 {
69    type Error = IntegerConversionError;
70    fn util_try_into(self) -> Result<u32, Self::Error> {
71        if self < 0 {
72            return Err(IntegerConversionError::Underflow);
73        }
74        if self > u32::MAX as u64 {
75            return Err(IntegerConversionError::Overflow);
76        }
77
78        Ok(self as u32)
79    }
80}
81
82impl UtilTryInto<u32> for i64 {
83    type Error = IntegerConversionError;
84    fn util_try_into(self) -> Result<u32, Self::Error> {
85        if self < 0 {
86            return Err(IntegerConversionError::Underflow);
87        }
88        if self > u32::MAX as i64 {
89            return Err(IntegerConversionError::Overflow);
90        }
91
92        Ok(self as u32)
93    }
94}
95
96impl UtilTryInto<i32> for f64 {
97    type Error = IntegerConversionError;
98    fn util_try_into(self) -> Result<i32, Self::Error> {
99        let f = self.round();
100
101        if f.is_nan() {
102            return Err(IntegerConversionError::NaN);
103        }
104
105        if f < i32::MIN as f64 {
106            return Err(IntegerConversionError::Underflow);
107        }
108        if f > u32::MAX as f64 {
109            return Err(IntegerConversionError::Overflow);
110        }
111
112        Ok(f as i32)
113    }
114}
115impl UtilTryInto<i32> for u64 {
116    type Error = IntegerConversionError;
117    fn util_try_into(self) -> Result<i32, Self::Error> {
118        if self > i32::MAX as u64 {
119            return Err(IntegerConversionError::Overflow);
120        }
121
122        Ok(self as i32)
123    }
124}
125
126impl UtilTryInto<i32> for i64 {
127    type Error = IntegerConversionError;
128    fn util_try_into(self) -> Result<i32, Self::Error> {
129        if self < i32::MIN as i64 {
130            return Err(IntegerConversionError::Underflow);
131        }
132        if self > i32::MAX as i64 {
133            return Err(IntegerConversionError::Overflow);
134        }
135
136        Ok(self as i32)
137    }
138}
tracing_formatters/util.rs

tracing_formatters/
util.rs
