base_traits/traits/
as_usize.rs

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

base_traits/traits/
as_usize.rs
