//! Optimistic type conversion
//!
//! When [std::convert::TryFrom] and [std::convert::TryInto] get stabilised
//! they should be used instead. However, at this point we need our
//! own implementation for optional conversion between types.
//!
//! The particular use case is when we have a data type claiming
//! more space than it's using and we want to move the value into
//! another, smaller data type. Such operation may only be performed
//! at runtime with particular checks that the value fits into the
//! smaller data type. Otherwise we cannot perform safe cast.
//!
//! # Examples
//! Integer conversion
//! ```
//! use fraction::convert::TryToConvertFrom;
//!
//! assert_eq!(Some(255u8), u8::try_to_convert_from(255u16));
//! assert_eq!(None, u8::try_to_convert_from(256u16));
//! ```
//!
//! Fraction conversion
//! ```
//! use fraction::{GenericFraction, convert::TryToConvertFrom, One};
//!
//! type F8 = GenericFraction<u8>;
//! type F16 = GenericFraction<u16>;
//!
//! let f8_255 = F8::new(255u8, 1u8);
//! let f16_255 = F16::try_to_convert_from(f8_255).unwrap();
//! let f16_256 = f16_255 + F16::one();
//!
//! assert_eq!(Some(f8_255), F8::try_to_convert_from(f16_255));
//! assert_eq!(None, F8::try_to_convert_from(f16_256));
//! ```
use generic::{read_generic_integer, GenericInteger};
use num::{CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Integer, One};
use super::GenericFraction;
#[cfg(feature = "with-bigint")]
use super::{BigInt, BigUint};
pub trait TryToConvertFrom<F>: Sized {
fn try_to_convert_from(src: F) -> Option<Self>;
}
macro_rules! convert_impl {
(unsigned; $($T:ty),+) => {
$(
impl<T> TryToConvertFrom<T> for $T
where
T: GenericInteger + Clone + One + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,
$T: GenericInteger
{
fn try_to_convert_from(src: T) -> Option<Self> {
read_generic_integer::<Self, T>(src)
.map_or_else(
|| None,
|(sign, val)| if sign.is_positive () { Some(val) } else { None }
)
}
}
)+
};
(signed; $($T:ty),+) => {
$(
impl<T> TryToConvertFrom<T> for $T
where
T: GenericInteger + Clone + One + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,
$T: GenericInteger
{
fn try_to_convert_from(src: T) -> Option<Self> {
read_generic_integer::<Self, T>(src)
.map_or_else(
|| None,
|(sign, val)| Some(if sign.is_negative() {-val} else {val})
)
}
}
)+
};
/* when Rust gets specializations we'll be able to do cheaper conversions for some types
(cast; $($F:ty => $T:ty),+) => {
$(
impl TryToConvertFrom<$F> for $T
{
fn try_to_convert_from(src: $F) -> Option<$T> {
Some(src as $T)
}
}
)+
};
*/
}
convert_impl!(unsigned; u8, u16, u32, u64, u128, usize);
convert_impl!(signed; i8, i16, i32, i64, i128, isize);
#[cfg(feature = "with-bigint")]
convert_impl!(unsigned; BigUint);
#[cfg(feature = "with-bigint")]
convert_impl!(signed; BigInt);
impl<T, F> TryToConvertFrom<GenericFraction<F>> for GenericFraction<T>
where
T: TryToConvertFrom<F> + Clone + Integer,
F: Clone + Integer,
{
fn try_to_convert_from(src: GenericFraction<F>) -> Option<Self> {
match src {
GenericFraction::NaN => Some(GenericFraction::NaN),
GenericFraction::Infinity(sign) => Some(GenericFraction::Infinity(sign)),
GenericFraction::Rational(sign, ratio) => {
let (n, d): (F, F) = ratio.into();
let numer = <T as TryToConvertFrom<F>>::try_to_convert_from(n)?;
let denom = <T as TryToConvertFrom<F>>::try_to_convert_from(d)?;
Some(GenericFraction::Rational(
sign,
super::Ratio::new_raw(numer, denom),
))
}
}
}
}
#[cfg(test)]
mod tests {
use convert::TryToConvertFrom;
use fraction::GenericFraction;
type F1 = GenericFraction<u8>;
type F2 = GenericFraction<i8>;
#[test]
fn try_to_convert_integers() {
{
assert_eq!(Some(127i8), i8::try_to_convert_from(127u8));
assert_eq!(Some(127u8), u8::try_to_convert_from(127i8));
assert_eq!(None, i8::try_to_convert_from(128u8));
assert_eq!(None, u8::try_to_convert_from(-127i8));
assert_eq!(None, u8::try_to_convert_from(256u16));
}
}
#[test]
fn try_to_convert_generic_fraction() {
{
let fu = F1::new(1u8, 2u8);
let fi = F2::try_to_convert_from(fu);
assert!(fi.is_some());
assert_eq!(fi.unwrap(), F2::new(1i8, 2i8));
}
{
let fi = F2::new(1i8, 2i8);
let fu = F1::try_to_convert_from(fi);
assert!(fu.is_some());
assert_eq!(fu.unwrap(), F1::new(1u8, 2u8));
}
{
let fu = F1::infinity();
let fi = F2::try_to_convert_from(fu);
assert!(fi.is_some());
assert_eq!(fi.unwrap(), F2::infinity());
}
{
let fu = F1::neg_infinity();
let fi = F2::try_to_convert_from(fu);
assert!(fi.is_some());
assert_eq!(fi.unwrap(), F2::neg_infinity());
}
}
}
