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(any(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(any(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(clippy::redundant_field_names)]
81        #![allow(non_snake_case)]
82
83        use super::ToU64;
84
85
86        struct CustomType {
87            value : u64,
88        }
89
90        impl ToU64 for CustomType {
91            fn to_u64(&self) -> u64 {
92                self.value
93            }
94        }
95
96        #[test]
97        fn TEST_RANGE_OF_VALUES() {
98            const VALUES : &[u64] = &[
99                // insert list:
100                0,
101                1,
102                2,
103                4,
104                8,
105                16,
106                32,
107                64,
108                64,
109                256,
110                u16::MAX as u64,
111                u32::MAX as u64,
112                u64::MAX,
113            ];
114
115            for &value in VALUES {
116                let expected = value;
117                let instance = CustomType { value: value };
118                let actual = instance.to_u64();
119
120                assert_eq!(expected, actual);
121            }
122        }
123    }
124
125
126    #[cfg(feature = "implement-ToU64-for-built_ins")]
127    mod TEST_BUILTIN_TYPES {
128        #![allow(non_snake_case)]
129
130        use super::*;
131
132
133        #[test]
134        fn TEST_RANGE_OF_u64_VALUES() {
135            const VALUES : &[u64] = &[
136                // insert list:
137                0,
138                1,
139                2,
140                4,
141                8,
142                16,
143                32,
144                64,
145                64,
146                256,
147                u64::MAX,
148            ];
149
150            for &value in VALUES {
151                let expected = value;
152                let actual = value.to_u64();
153
154                assert_eq!(expected, actual);
155            }
156        }
157
158        #[test]
159        fn TEST_RANGE_OF_u16_VALUES_REF() {
160            const VALUES : &[u16] = &[
161                // insert list:
162                0,
163                1,
164                2,
165                4,
166                8,
167                16,
168                32,
169                64,
170                64,
171                256,
172                u16::MAX,
173            ];
174
175            for &value in VALUES {
176                let expected = value as u64;
177                let value = &value;
178                let actual = value.to_u64();
179
180                assert_eq!(expected, actual);
181            }
182        }
183
184        #[test]
185        fn TEST_RANGE_OF_u32_VALUES_REF() {
186            const VALUES : &[u32] = &[
187                // insert list:
188                0,
189                1,
190                2,
191                4,
192                8,
193                16,
194                32,
195                64,
196                64,
197                256,
198                u32::MAX,
199            ];
200
201            for &value in VALUES {
202                let expected = value as u64;
203                let value = &value;
204                let actual = value.to_u64();
205
206                assert_eq!(expected, actual);
207            }
208        }
209
210        #[test]
211        fn TEST_RANGE_OF_u64_VALUES_REF() {
212            const VALUES : &[u64] = &[
213                // insert list:
214                0,
215                1,
216                2,
217                4,
218                8,
219                16,
220                32,
221                64,
222                64,
223                256,
224                u64::MAX,
225            ];
226
227            for &value in VALUES {
228                let expected = value;
229                let value = &value;
230                let actual = value.to_u64();
231
232                assert_eq!(expected, actual);
233            }
234        }
235
236        #[test]
237        fn TEST_RANGE_OF_u64_VALUES_IN_Box() {
238            const VALUES : &[u64] = &[
239                // insert list:
240                0,
241                1,
242                2,
243                4,
244                8,
245                16,
246                32,
247                64,
248                64,
249                256,
250                u64::MAX,
251            ];
252
253            for &value in VALUES {
254                let expected = value;
255                let instance = Box::new(value);
256                let actual = instance.to_u64();
257
258                assert_eq!(expected, actual);
259            }
260        }
261
262        #[test]
263        fn TEST_RANGE_OF_u64_VALUES_IN_REF_Box() {
264            const VALUES : &[u64] = &[
265                // insert list:
266                0,
267                1,
268                2,
269                4,
270                8,
271                16,
272                32,
273                64,
274                64,
275                256,
276                u64::MAX,
277            ];
278
279            for &value in VALUES {
280                let expected = value;
281                let instance = &Box::new(value);
282                let actual = instance.to_u64();
283
284                assert_eq!(expected, actual);
285            }
286        }
287
288        #[test]
289        fn TEST_RANGE_OF_u64_VALUES_IN_Rc() {
290            const VALUES : &[u64] = &[
291                // insert list:
292                0,
293                1,
294                2,
295                4,
296                8,
297                16,
298                32,
299                64,
300                64,
301                256,
302                u64::MAX,
303            ];
304
305            for &value in VALUES {
306                let expected = value;
307                let instance = std_rc::Rc::new(value);
308                let actual = instance.to_u64();
309
310                assert_eq!(expected, actual);
311            }
312        }
313
314        #[test]
315        fn TEST_RANGE_OF_u64_VALUES_IN_REF_Rc() {
316            const VALUES : &[u64] = &[
317                // insert list:
318                0,
319                1,
320                2,
321                4,
322                8,
323                16,
324                32,
325                64,
326                64,
327                256,
328                u64::MAX,
329            ];
330
331            for &value in VALUES {
332                let expected = value;
333                let instance = &std_rc::Rc::new(value);
334                let actual = instance.to_u64();
335
336                assert_eq!(expected, actual);
337            }
338        }
339    }
340}
341
342
343// ///////////////////////////// end of file //////////////////////////// //
base_traits/traits/to_u64.rs

base_traits/traits/
to_u64.rs
