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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
// 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.
///
/// # Additional Implementations on Foreign Types
///
/// ## Built-in Types
///
/// If the feature `"implement-Zero-for-built_ins"`
/// is defined (as it is by `"default"`), then this is also implemented
/// for the following type(s):
/// - [`i8`];
/// - [`i16`];
/// - [`i32`];
/// - [`i64`];
/// - [`i128`];
/// - [`u8`];
/// - [`u16`];
/// - [`u32`];
/// - [`u64`];
/// - [`u128`];
/// - [`isize`];
/// - [`usize`];
/// - [`f32`];
/// - [`f64`];
/// - [`char`];
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());
        }
    }
}