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(all(not(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(all(not(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 actual = (&value).as_usize();
187
188                assert_eq!(expected, actual);
189            }
190        }
191
192        #[test]
193        fn TEST_RANGE_OF_VALUES_IN_Box() {
194
195            const VALUES : &[usize] = &[
196                // insert list:
197                0,
198                1,
199                2,
200                4,
201                8,
202                16,
203                32,
204                64,
205                128,
206                256,
207                usize::MAX,
208            ];
209
210            for &value in VALUES {
211                let expected = value;
212                let instance = Box::new(value);
213                let actual = instance.as_usize();
214
215                assert_eq!(expected, actual);
216            }
217        }
218
219        #[test]
220        fn TEST_RANGE_OF_VALUES_IN_REF_Box() {
221
222            const VALUES : &[usize] = &[
223                // insert list:
224                0,
225                1,
226                2,
227                4,
228                8,
229                16,
230                32,
231                64,
232                128,
233                256,
234                usize::MAX,
235            ];
236
237            for &value in VALUES {
238                let expected = value;
239                let instance = Box::new(value);
240                let actual = (&instance).as_usize();
241
242                assert_eq!(expected, actual);
243            }
244        }
245
246        #[test]
247        fn TEST_RANGE_OF_VALUES_IN_Rc() {
248
249            const VALUES : &[usize] = &[
250                // insert list:
251                0,
252                1,
253                2,
254                4,
255                8,
256                16,
257                32,
258                64,
259                128,
260                256,
261                usize::MAX,
262            ];
263
264            for &value in VALUES {
265                let expected = value;
266                let instance = std_rc::Rc::new(value);
267                let actual = instance.as_usize();
268
269                assert_eq!(expected, actual);
270            }
271        }
272
273        #[test]
274        fn TEST_RANGE_OF_VALUES_IN_REF_Rc() {
275
276            const VALUES : &[usize] = &[
277                // insert list:
278                0,
279                1,
280                2,
281                4,
282                8,
283                16,
284                32,
285                64,
286                128,
287                256,
288                usize::MAX,
289            ];
290
291            for &value in VALUES {
292                let expected = value;
293                let instance = std_rc::Rc::new(value);
294                let actual = (&instance).as_usize();
295
296                assert_eq!(expected, actual);
297            }
298        }
299    }
300}
301
302
303// ///////////////////////////// end of file //////////////////////////// //
304
base_traits/traits/as_usize.rs

base_traits/traits/
as_usize.rs
