base_traits/traits/
to_u64.rs

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

base_traits/traits/
to_u64.rs
