base_traits/traits/
to_i128.rs

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

base_traits/traits/
to_i128.rs
