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            const VALUES : &[usize] = &[
80                // insert list:
81                0,
82                1,
83                2,
84                4,
85                8,
86                16,
87                32,
88                64,
89                128,
90                256,
91                u32::MAX as usize,
92            ];
93
94            for &value in VALUES {
95                let expected = value;
96                let instance = CustomType { value: value as u64 };
97                let actual = instance.as_usize();
98
99                assert_eq!(expected, actual);
100            }
101        }
102
103        #[test]
104        fn TEST_RANGE_OF_VALUES_IN_Box() {
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            const VALUES : &[usize] = &[
141                // insert list:
142                0,
143                1,
144                2,
145                4,
146                8,
147                16,
148                32,
149                64,
150                128,
151                256,
152                usize::MAX,
153            ];
154
155            for &value in VALUES {
156                let expected = value;
157                let actual = value.as_usize();
158
159                assert_eq!(expected, actual);
160            }
161        }
162
163        #[test]
164        fn TEST_RANGE_OF_VALUES_REF() {
165            const VALUES : &[usize] = &[
166                // insert list:
167                0,
168                1,
169                2,
170                4,
171                8,
172                16,
173                32,
174                64,
175                128,
176                256,
177                usize::MAX,
178            ];
179
180            for &value in VALUES {
181                let expected = value;
182                let value = &value;
183                let actual = value.as_usize();
184
185                assert_eq!(expected, actual);
186            }
187        }
188
189        #[test]
190        fn TEST_RANGE_OF_VALUES_IN_Box() {
191            const VALUES : &[usize] = &[
192                // insert list:
193                0,
194                1,
195                2,
196                4,
197                8,
198                16,
199                32,
200                64,
201                128,
202                256,
203                usize::MAX,
204            ];
205
206            for &value in VALUES {
207                let expected = value;
208                let instance = Box::new(value);
209                let actual = instance.as_usize();
210
211                assert_eq!(expected, actual);
212            }
213        }
214
215        #[test]
216        fn TEST_RANGE_OF_VALUES_IN_REF_Box() {
217            const VALUES : &[usize] = &[
218                // insert list:
219                0,
220                1,
221                2,
222                4,
223                8,
224                16,
225                32,
226                64,
227                128,
228                256,
229                usize::MAX,
230            ];
231
232            for &value in VALUES {
233                let expected = value;
234                let instance = &Box::new(value);
235                let actual = instance.as_usize();
236
237                assert_eq!(expected, actual);
238            }
239        }
240
241        #[test]
242        fn TEST_RANGE_OF_VALUES_IN_Rc() {
243            const VALUES : &[usize] = &[
244                // insert list:
245                0,
246                1,
247                2,
248                4,
249                8,
250                16,
251                32,
252                64,
253                128,
254                256,
255                usize::MAX,
256            ];
257
258            for &value in VALUES {
259                let expected = value;
260                let instance = std_rc::Rc::new(value);
261                let actual = instance.as_usize();
262
263                assert_eq!(expected, actual);
264            }
265        }
266
267        #[test]
268        fn TEST_RANGE_OF_VALUES_IN_REF_Rc() {
269            const VALUES : &[usize] = &[
270                // insert list:
271                0,
272                1,
273                2,
274                4,
275                8,
276                16,
277                32,
278                64,
279                128,
280                256,
281                usize::MAX,
282            ];
283
284            for &value in VALUES {
285                let expected = value;
286                let instance = &std_rc::Rc::new(value);
287                let actual = instance.as_usize();
288
289                assert_eq!(expected, actual);
290            }
291        }
292    }
293}
294
295
296// ///////////////////////////// end of file //////////////////////////// //
base_traits/traits/as_usize.rs

base_traits/traits/
as_usize.rs
