gearbox 3.0.0

Excessive tooling for Rust, boosting productivity and operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

pub enum IntegerConversionError {
    Underflow,
    NaN,
    Overflow,
}

pub trait UtilTryInto<I> {
    type Error;

    fn util_try_into(self) -> Result<I, Self::Error>;
}

impl UtilTryInto<i64> for f64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<i64, Self::Error> {
        let f = self.round();

        if f.is_nan() {
            return Err(IntegerConversionError::NaN);
        }

        if f < 0.0 {
            return Err(IntegerConversionError::Underflow);
        }
        if f > i64::MAX as f64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(f as i64)
    }
}

impl UtilTryInto<i64> for u64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<i64, Self::Error> {
        let f = self;
        if f > i64::MAX as u64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(f as i64)
    }
}

impl UtilTryInto<u32> for f64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<u32, Self::Error> {
        let f = self.round();

        if f.is_nan() {
            return Err(IntegerConversionError::NaN);
        }

        if f < 0.0 {
            return Err(IntegerConversionError::Underflow);
        }
        if f > u32::MAX as f64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(f as u32)
    }
}
impl UtilTryInto<u32> for u64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<u32, Self::Error> {
        if self > u32::MAX as u64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(self as u32)
    }
}

impl UtilTryInto<u32> for i64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<u32, Self::Error> {
        if self < 0 {
            return Err(IntegerConversionError::Underflow);
        }
        if self > u32::MAX as i64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(self as u32)
    }
}

impl UtilTryInto<i32> for f64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<i32, Self::Error> {
        let f = self.round();

        if f.is_nan() {
            return Err(IntegerConversionError::NaN);
        }

        if f < i32::MIN as f64 {
            return Err(IntegerConversionError::Underflow);
        }
        if f > u32::MAX as f64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(f as i32)
    }
}
impl UtilTryInto<i32> for u64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<i32, Self::Error> {
        if self > i32::MAX as u64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(self as i32)
    }
}

impl UtilTryInto<i32> for i64 {
    type Error = IntegerConversionError;
    fn util_try_into(self) -> Result<i32, Self::Error> {
        if self < i32::MIN as i64 {
            return Err(IntegerConversionError::Underflow);
        }
        if self > i32::MAX as i64 {
            return Err(IntegerConversionError::Overflow);
        }

        Ok(self as i32)
    }
}