base_traits/traits/
zero.rs

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
// src/traits/zero.rs : `Zero`

/// Trait defining class method `zero() : T` that creates an instance of
/// the implementing type that is conceptually (or actually) zero.
pub trait Zero {
    fn zero() -> Self;
}


#[cfg(feature = "implement-Zero-for-built_ins")]
mod impl_for_built_ins {
    #![allow(non_snake_case)]

    macro_rules! implement_IsZero_ {
        ($type:tt, $zero_value:expr) => {
            impl super::Zero for $type {
                #[inline]
                fn zero() -> Self {
                    $zero_value
                }
            }
        };
    }

    implement_IsZero_!(i8, 0);
    implement_IsZero_!(i16, 0);
    implement_IsZero_!(i32, 0);
    implement_IsZero_!(i64, 0);
    implement_IsZero_!(i128, 0);

    implement_IsZero_!(u8, 0);
    implement_IsZero_!(u16, 0);
    implement_IsZero_!(u32, 0);
    implement_IsZero_!(u64, 0);
    implement_IsZero_!(u128, 0);

    implement_IsZero_!(isize, 0);
    implement_IsZero_!(usize, 0);

    implement_IsZero_!(f32, 0.0);
    implement_IsZero_!(f64, 0.0);

    implement_IsZero_!(char, '\0');
}


#[cfg(test)]
mod tests {
    #![allow(non_snake_case)]

    use super::Zero;


    mod TEST_CUSTOM_TYPE {
        #![allow(non_snake_case)]

        use super::*;


        #[derive(Debug)]
        struct CustomType {
            pub value : i32,
        }

        impl Zero for CustomType {
            fn zero() -> Self {
                Self {
                    value : -1,
                }
            }
        }


        #[test]
        fn TEST_Zero() {
            let ct = CustomType::zero();

            assert_eq!(-1, ct.value);
        }
    }


    #[cfg(feature = "implement-Zero-for-built_ins")]
    mod TEST_BUILTIN_TYPES {
        #![allow(non_snake_case)]
        use super::*;


        #[test]
        fn TEST_INTEGERS() {
            assert_eq!(0, i8::zero());
            assert_eq!(0, i16::zero());
            assert_eq!(0, i32::zero());
            assert_eq!(0, i64::zero());
            assert_eq!(0, i128::zero());

            assert_eq!(0, u8::zero());
            assert_eq!(0, u16::zero());
            assert_eq!(0, u32::zero());
            assert_eq!(0, u64::zero());
            assert_eq!(0, u128::zero());

            assert_eq!(0, isize::zero());
            assert_eq!(0, usize::zero());

            assert_eq!(0.0f32, f32::zero());
            assert_eq!(0.0f64, f64::zero());

            assert_eq!('\0', char::zero());
        }
    }
}