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    #[allow(unused_imports)]
58    use std::rc as std_rc;
59
60
61    mod TEST_CUSTOM_TYPE {
62        #![allow(non_snake_case)]
63
64        use super::*;
65
66
67        struct CustomType {
68            value : u64,
69        }
70
71        impl AsUSize for CustomType {
72            fn as_usize(&self) -> usize {
73                self.value as usize
74            }
75        }
76
77
78        #[test]
79        fn TEST_RANGE_OF_VALUES() {
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            const VALUES : &[usize] = &[
107                // insert list:
108                0,
109                1,
110                2,
111                4,
112                8,
113                16,
114                32,
115                64,
116                128,
117                256,
118                u32::MAX as usize,
119            ];
120
121            for &value in VALUES {
122                let expected = value;
123                let instance = Box::new(CustomType { value: value as u64 });
124                let actual = instance.as_usize();
125
126                assert_eq!(expected, actual);
127            }
128        }
129    }
130
131
132    #[cfg(feature = "implement-AsUSize-for-built_ins")]
133    mod TEST_BUILTIN_TYPES {
134        #![allow(non_snake_case)]
135
136        use super::*;
137
138
139        #[test]
140        fn TEST_RANGE_OF_VALUES() {
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            const VALUES : &[usize] = &[
167                // insert list:
168                0,
169                1,
170                2,
171                4,
172                8,
173                16,
174                32,
175                64,
176                128,
177                256,
178                usize::MAX,
179            ];
180
181            for &value in VALUES {
182                let expected = value;
183                let value = &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            const VALUES : &[usize] = &[
193                // insert list:
194                0,
195                1,
196                2,
197                4,
198                8,
199                16,
200                32,
201                64,
202                128,
203                256,
204                usize::MAX,
205            ];
206
207            for &value in VALUES {
208                let expected = value;
209                let instance = Box::new(value);
210                let actual = instance.as_usize();
211
212                assert_eq!(expected, actual);
213            }
214        }
215
216        #[test]
217        fn TEST_RANGE_OF_VALUES_IN_REF_Box() {
218            const VALUES : &[usize] = &[
219                // insert list:
220                0,
221                1,
222                2,
223                4,
224                8,
225                16,
226                32,
227                64,
228                128,
229                256,
230                usize::MAX,
231            ];
232
233            for &value in VALUES {
234                let expected = value;
235                let instance = &Box::new(value);
236                let actual = instance.as_usize();
237
238                assert_eq!(expected, actual);
239            }
240        }
241
242        #[test]
243        fn TEST_RANGE_OF_VALUES_IN_Rc() {
244            const VALUES : &[usize] = &[
245                // insert list:
246                0,
247                1,
248                2,
249                4,
250                8,
251                16,
252                32,
253                64,
254                128,
255                256,
256                usize::MAX,
257            ];
258
259            for &value in VALUES {
260                let expected = value;
261                let instance = std_rc::Rc::new(value);
262                let actual = instance.as_usize();
263
264                assert_eq!(expected, actual);
265            }
266        }
267
268        #[test]
269        fn TEST_RANGE_OF_VALUES_IN_REF_Rc() {
270            const VALUES : &[usize] = &[
271                // insert list:
272                0,
273                1,
274                2,
275                4,
276                8,
277                16,
278                32,
279                64,
280                128,
281                256,
282                usize::MAX,
283            ];
284
285            for &value in VALUES {
286                let expected = value;
287                let instance = &std_rc::Rc::new(value);
288                let actual = instance.as_usize();
289
290                assert_eq!(expected, actual);
291            }
292        }
293    }
294}
295
296
297// ///////////////////////////// end of file //////////////////////////// //
base_traits/traits/as_usize.rs

base_traits/traits/
as_usize.rs
