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

base_traits/traits/
as_usize.rs
