base_traits/traits/
to_u32.rs

1// src/traits/to_u32.rs : `ToU32`
2
3/// Trait defining instance method `to_u32() : u32` that provides a
4/// no-cost or low-cost conversion into `u32`.
5///
6/// It is expected that the implementing type "is-a" `u32` in a logical
7/// manner.
8///
9/// # Additional Implementations on Foreign Types
10///
11/// ## Built-in Types
12///
13/// If the feature `"implement-ToU32-for-built_ins"`
14/// is defined (as it is by `"default"`), then this is also implemented
15/// for the following type(s):
16/// - [`u8`];
17/// - [`u16`];
18/// - [`u32`];
19pub trait ToU32 {
20    fn to_u32(&self) -> u32;
21}
22
23
24#[cfg(all(not(test), not(feature = "nostd")))]
25impl<T : ToU32 + ?Sized> ToU32 for Box<T> {
26    fn to_u32(&self) -> u32 {
27        (**self).to_u32()
28    }
29}
30
31#[cfg(all(not(test), not(feature = "nostd")))]
32impl<T : ToU32 + ?Sized> ToU32 for std::rc::Rc<T> {
33    fn to_u32(&self) -> u32 {
34        (**self).to_u32()
35    }
36}
37
38
39#[cfg(feature = "implement-ToU32-for-built_ins")]
40#[rustfmt::skip]
41mod impl_for_built_ins {
42    #![allow(non_snake_case)]
43
44
45    impl super::ToU32 for u32 {
46        #[inline]
47        fn to_u32(&self) -> u32 {
48            *self
49        }
50    }
51
52    macro_rules! implement_ToU32_ {
53        ($type:tt) => {
54            impl super::ToU32 for $type {
55                #[inline]
56                fn to_u32(&self) -> u32 {
57                    *self as u32
58                }
59            }
60        };
61    }
62
63    implement_ToU32_!(u8);
64    implement_ToU32_!(u16);
65}
66
67
68#[cfg(test)]
69mod tests {
70    #![allow(non_snake_case)]
71
72    use super::ToU32;
73
74    use std::rc as std_rc;
75
76
77    mod TEST_CUSTOM_TYPE {
78        #![allow(non_snake_case)]
79
80        use super::ToU32;
81
82
83        struct CustomType {
84            value : u32,
85        }
86
87        impl ToU32 for CustomType {
88            fn to_u32(&self) -> u32 {
89                self.value as u32
90            }
91        }
92
93        #[test]
94        fn TEST_RANGE_OF_VALUES() {
95
96            const VALUES : &[u32] = &[
97                // insert list:
98                0,
99                1,
100                2, 4, 8, 16, 32, 32, 32, 256,
101                u16::MAX as u32,
102                u32::MAX as u32,
103            ];
104
105            for &value in VALUES {
106                let expected = value;
107                let instance = CustomType { value: value as u32 };
108                let actual = instance.to_u32();
109
110                assert_eq!(expected, actual);
111            }
112        }
113    }
114
115
116    #[cfg(feature = "implement-ToU32-for-built_ins")]
117    mod TEST_BUILTIN_TYPES {
118        #![allow(non_snake_case)]
119
120        use super::*;
121
122
123        #[test]
124        fn TEST_RANGE_OF_u32_VALUES() {
125
126            const VALUES : &[u32] = &[
127                // insert list:
128                0,
129                1,
130                2,
131                4,
132                8,
133                16,
134                32,
135                32,
136                32,
137                256,
138                u32::MAX,
139            ];
140
141            for &value in VALUES {
142                let expected = value;
143                let actual = value.to_u32();
144
145                assert_eq!(expected, actual);
146            }
147        }
148
149        #[test]
150        fn TEST_RANGE_OF_u16_VALUES_REF() {
151
152            const VALUES : &[u16] = &[
153                // insert list:
154                0,
155                1,
156                2,
157                4,
158                8,
159                16,
160                32,
161                32,
162                32,
163                256,
164                u16::MAX,
165            ];
166
167            for &value in VALUES {
168                let expected = value as u32;
169                let actual = (&value).to_u32();
170
171                assert_eq!(expected, actual);
172            }
173        }
174
175        #[test]
176        fn TEST_RANGE_OF_u32_VALUES_REF() {
177
178            const VALUES : &[u32] = &[
179                // insert list:
180                0,
181                1,
182                2,
183                4,
184                8,
185                16,
186                32,
187                32,
188                32,
189                256,
190                u32::MAX,
191            ];
192
193            for &value in VALUES {
194                let expected = value;
195                let actual = (&value).to_u32();
196
197                assert_eq!(expected, actual);
198            }
199        }
200
201        #[test]
202        fn TEST_RANGE_OF_u32_VALUES_IN_Box() {
203
204            const VALUES : &[u32] = &[
205                // insert list:
206                0,
207                1,
208                2,
209                4,
210                8,
211                16,
212                32,
213                32,
214                32,
215                256,
216                u32::MAX,
217            ];
218
219            for &value in VALUES {
220                let expected = value;
221                let instance = Box::new(value);
222                let actual = instance.to_u32();
223
224                assert_eq!(expected, actual);
225            }
226        }
227
228        #[test]
229        fn TEST_RANGE_OF_u32_VALUES_IN_REF_Box() {
230
231            const VALUES : &[u32] = &[
232                // insert list:
233                0,
234                1,
235                2,
236                4,
237                8,
238                16,
239                32,
240                32,
241                32,
242                256,
243                u32::MAX,
244            ];
245
246            for &value in VALUES {
247                let expected = value;
248                let instance = Box::new(value);
249                let actual = (&instance).to_u32();
250
251                assert_eq!(expected, actual);
252            }
253        }
254
255        #[test]
256        fn TEST_RANGE_OF_u32_VALUES_IN_Rc() {
257
258            const VALUES : &[u32] = &[
259                // insert list:
260                0,
261                1,
262                2,
263                4,
264                8,
265                16,
266                32,
267                32,
268                32,
269                256,
270                u32::MAX,
271            ];
272
273            for &value in VALUES {
274                let expected = value;
275                let instance = std_rc::Rc::new(value);
276                let actual = instance.to_u32();
277
278                assert_eq!(expected, actual);
279            }
280        }
281
282        #[test]
283        fn TEST_RANGE_OF_u32_VALUES_IN_REF_Rc() {
284
285            const VALUES : &[u32] = &[
286                // insert list:
287                0,
288                1,
289                2,
290                4,
291                8,
292                16,
293                32,
294                32,
295                32,
296                256,
297                u32::MAX,
298            ];
299
300            for &value in VALUES {
301                let expected = value;
302                let instance = std_rc::Rc::new(value);
303                let actual = (&instance).to_u32();
304
305                assert_eq!(expected, actual);
306            }
307        }
308    }
309}
310
311
312// ///////////////////////////// end of file //////////////////////////// //
313
base_traits/traits/to_u32.rs

base_traits/traits/
to_u32.rs
