numera/number/integer/prime/
convert.rs

1// numera::number::integer::prime::convert
2//
3//!
4//
5
6use crate::{
7    error::{IntegerErrors, NumeraErrors, NumeraResult},
8    number::{integer::prime::all::*, traits::Number},
9};
10use devela::convert::az::CheckedAs;
11
12/* conversions between primes */
13
14#[rustfmt::skip]
15mod between_primes {
16    use super::*;
17
18    /* infallible */
19
20    impl From<Prime8> for Prime16 {
21        #[inline]
22        fn from(p: Prime8) -> Prime16 { Prime16(p.0.into()) }
23    }
24    impl From<Prime8> for Prime32 {
25        #[inline]
26        fn from(p: Prime8) -> Prime32 { Prime32(p.0.into()) }
27    }
28    impl From<Prime8> for Prime64 {
29        #[inline]
30        fn from(p: Prime8) -> Prime64 { Prime64(p.0.into()) }
31    }
32    impl From<Prime8> for Prime128 {
33        #[inline]
34        fn from(p: Prime8) -> Prime128 { Prime128(p.0.into()) }
35    }
36    impl From<Prime8> for Primes {
37        #[inline]
38        fn from(p: Prime8) -> Primes { Primes::_8(p) }
39    }
40
41    impl From<Prime16> for Prime32 {
42        #[inline]
43        fn from(p: Prime16) -> Prime32 { Prime32(p.0.into()) }
44    }
45    impl From<Prime16> for Prime64 {
46        #[inline]
47        fn from(p: Prime16) -> Prime64 { Prime64(p.0.into()) }
48    }
49    impl From<Prime16> for Prime128 {
50        #[inline]
51        fn from(p: Prime16) -> Prime128 { Prime128(p.0.into()) }
52    }
53    impl From<Prime16> for Primes {
54        #[inline]
55        fn from(p: Prime16) -> Primes { Primes::_16(p) }
56    }
57
58    impl From<Prime32> for Prime64 {
59        #[inline]
60        fn from(p: Prime32) -> Prime64 { Prime64(p.0.into()) }
61    }
62    impl From<Prime32> for Prime128 {
63        #[inline]
64        fn from(p: Prime32) -> Prime128 { Prime128(p.0.into()) }
65    }
66    impl From<Prime32> for Primes {
67        #[inline]
68        fn from(p: Prime32) -> Primes { Primes::_32(p) }
69    }
70
71    impl From<Prime64> for Prime128 {
72        #[inline]
73        fn from(p: Prime64) -> Prime128 { Prime128(p.0.into()) }
74    }
75    impl From<Prime64> for Primes {
76        #[inline]
77        fn from(p: Prime64) -> Primes { Primes::_64(p) }
78    }
79
80    impl From<Prime128> for Primes {
81        #[inline]
82        fn from(p: Prime128) -> Primes { Primes::_128(p) }
83    }
84
85    /* fallible */
86
87    impl TryFrom<Prime16> for Prime8 {
88        type Error = NumeraErrors;
89        #[inline]
90        fn try_from(value: Prime16) -> NumeraResult<Prime8> {
91            Ok(Prime8(u8::try_from(value.0)?))
92        }
93    }
94    impl TryFrom<Prime32> for Prime8 {
95        type Error = NumeraErrors;
96        #[inline]
97        fn try_from(value: Prime32) -> NumeraResult<Prime8> {
98            Ok(Prime8(u8::try_from(value.0)?))
99        }
100    }
101    impl TryFrom<Prime64> for Prime8 {
102        type Error = NumeraErrors;
103        #[inline]
104        fn try_from(value: Prime64) -> NumeraResult<Prime8> {
105            Ok(Prime8(u8::try_from(value.0)?))
106        }
107    }
108    impl TryFrom<Prime128> for Prime8 {
109        type Error = NumeraErrors;
110        #[inline]
111        fn try_from(value: Prime128) -> NumeraResult<Prime8> {
112            Ok(Prime8(u8::try_from(value.0)?))
113        }
114    }
115
116    impl TryFrom<Prime32> for Prime16 {
117        type Error = NumeraErrors;
118        #[inline]
119        fn try_from(value: Prime32) -> NumeraResult<Prime16> {
120            Ok(Prime16(u16::try_from(value.0)?))
121        }
122    }
123    impl TryFrom<Prime64> for Prime16 {
124        type Error = NumeraErrors;
125        #[inline]
126        fn try_from(value: Prime64) -> NumeraResult<Prime16> {
127            Ok(Prime16(u16::try_from(value.0)?))
128        }
129    }
130    impl TryFrom<Prime128> for Prime16 {
131        type Error = NumeraErrors;
132        #[inline]
133        fn try_from(value: Prime128) -> NumeraResult<Prime16> {
134            Ok(Prime16(u16::try_from(value.0)?))
135        }
136    }
137
138    impl TryFrom<Prime64> for Prime32 {
139        type Error = NumeraErrors;
140        #[inline]
141        fn try_from(value: Prime64) -> NumeraResult<Prime32> {
142            Ok(Prime32(u32::try_from(value.0)?))
143        }
144    }
145    impl TryFrom<Prime128> for Prime32 {
146        type Error = NumeraErrors;
147        #[inline]
148        fn try_from(value: Prime128) -> NumeraResult<Prime32> {
149            Ok(Prime32(u32::try_from(value.0)?))
150        }
151    }
152
153    impl TryFrom<Prime128> for Prime64 {
154        type Error = NumeraErrors;
155        #[inline]
156        fn try_from(value: Prime128) -> NumeraResult<Prime64> {
157            Ok(Prime64(u64::try_from(value.0)?))
158        }
159    }
160
161    impl TryFrom<Primes> for Prime8 {
162        type Error = NumeraErrors;
163        #[inline]
164        fn try_from(value: Primes) -> NumeraResult<Prime8> {
165            match value {
166                Primes::_8(p) => Ok(p),
167                Primes::_16(p) => Ok(p.try_into()?),
168                Primes::_32(p) => Ok(p.try_into()?),
169                Primes::_64(p) => Ok(p.try_into()?),
170                Primes::_128(p) => Ok(p.try_into()?),
171            }
172        }
173    }
174}
175
176/* conversions to primitives */
177
178// Conversions that can't fail.
179macro_rules! from_prime_to_primitive {
180    ($Prime:ident, $($primitive:ty),+) => {
181        $( from_prime_to_primitive![@ $Prime, $primitive]; )*
182    };
183    (@ $Prime:ident, $primitive:ty) => {
184        impl From<$Prime> for $primitive {
185            fn from(p: $Prime) -> $primitive {
186                p.0.into()
187            }
188        }
189    };
190}
191from_prime_to_primitive![Prime8, u8, u16, u32, u64, u128, usize, i16, i32, i64, i128, isize];
192from_prime_to_primitive![Prime16, u16, u32, u64, u128, usize, i32, i64, i128];
193from_prime_to_primitive![Prime32, u32, u64, u128, i64, i128];
194from_prime_to_primitive![Prime64, u64, u128, i128];
195from_prime_to_primitive![Prime128, u128];
196
197// Conversions that can fail.
198macro_rules! try_from_prime_to_primitive {
199    ($Prime:ident, $($primitive:ty),+) => {
200        $( try_from_prime_to_primitive![@ $Prime, $primitive]; )*
201    };
202    (@ $Prime:ident, $primitive:ty) => {
203        impl TryFrom<$Prime> for $primitive {
204            type Error = NumeraErrors;
205            #[inline]
206            fn try_from(p: $Prime) -> NumeraResult<$primitive> {
207                Ok(<$primitive>::try_from(p.0)?)
208            }
209        }
210    };
211}
212try_from_prime_to_primitive![Prime8, i8];
213try_from_prime_to_primitive![Prime16, u8, i8, i16, isize];
214try_from_prime_to_primitive![Prime32, u8, u16, usize, i8, i16, i32, isize];
215try_from_prime_to_primitive![Prime64, u8, u16, u32, usize, i8, i16, i32, i64, isize];
216try_from_prime_to_primitive![Prime128, u8, u16, u32, u64, usize, i8, i16, i32, i64, i128, isize];
217
218/* conversions from primitives */
219
220// tries to convert a primitive into a prime.
221macro_rules! try_from_primitive_to_prime {
222    ($Prime:ident, $PrimeInnerRepr:ty; $($primitive:ty),+) => {
223        $( try_from_primitive_to_prime![@ $Prime, $PrimeInnerRepr; $primitive]; )*
224    };
225    (@ $Prime:ident, $PrimeInnerRepr:ty; $primitive:ty) => {
226        impl TryFrom<$primitive> for $Prime {
227            type Error = NumeraErrors;
228            #[inline]
229            fn try_from(p: $primitive) -> NumeraResult<$Prime> {
230                let arg = p.checked_as::<$PrimeInnerRepr>().ok_or(IntegerErrors::Overflow)?;
231                $Prime::from_inner_repr(arg)
232            }
233        }
234    };
235}
236try_from_primitive_to_prime![Prime8,
237    u8; u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize];
238try_from_primitive_to_prime![Prime16,
239    u16; u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize];
240try_from_primitive_to_prime![Prime32,
241    u32; u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize];
242try_from_primitive_to_prime![Prime64,
243    u64; u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize];
244try_from_primitive_to_prime![Prime128,
245    u128; u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize];
numera/number/integer/prime/convert.rs

numera/number/integer/prime/
convert.rs
