base_traits/traits/
to_u16.rs

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

base_traits/traits/
to_u16.rs
