msuk_scifi/unit/

temperature.rs

//! Generic temperature macros and "dispatching", etc.
pub mod k;

pub type TemperatureInternalType = f64;

#[macro_export]
/// Implement `as_FOOBAR`, `as_rounded_FOOBAR`, and `try_as_FOOBAR`
/// for (e.g.) a temperature type.
/// 
/// # Arguments
/// * `Temperature`-type.
/// * `for`, followed by a comma separated list of e.g. primitives that are to be supported.
/// 
/// # Examples
/// ```
/// # use msuk_scifi::{implement_as_for_temperature, unit::temperature::TemperatureInternalType};
/// # use paste::paste;
/// # struct K { value: f64 };
/// implement_as_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// ```
//
macro_rules! implement_as_for_temperature {
    ($c:ty, for $($t:ty),+) => {$(paste! {
        impl $c {
            /// Try convert [<$c>] into primitive [<$t>].
            /// 
            /// # Returns
            /// `None` if conversion is not possible, otherwise `Some([<$t>])`.
            pub fn [<try_as_ $t>](&self) -> Option<$t> {
                // Since K is always >= 0, we only need to check the MAX bound.
                if self.value <= $t::MAX as TemperatureInternalType {
                    Some(self.value.round() as $t)
                } else {
                    None
                }
            }

            /// Performs a direct, truncating conversion from [<$c>] to [<$t>].
            /// See `[<try_as_ $t>]` for a safe, but a tiny bit slower alternative.
            ///
            /// For rounding, use [<as_rounded_ $t>].
            /// 
            /// WARNING: in case of [<$c>→] being too large for [<$t>], wrap on overflow will happen.
            pub fn [<as_ $t>](&self) -> $t {
                self.value as $t
            }

            /// Performs a direct, rounding coversion from [<$c>] to [<$t>].
            /// 
            /// WARNING: in case of [<$c>] being too large for [<$t>], wrap on overflow will happen.
            pub fn [<as_rounded_ $t>](&self) -> $t {
                self.value.round() as $t
            }
        }
    })+};
}

#[macro_export]
/// Implement a number of `From<X>` for the given type.
/// 
/// # Implements
/// * `From<X> for $type`
/// * `From<$type> for X`
/// 
/// # Arguments
/// * `$type`— some "temperature" type, e.g. `K` (for Kelvin).
/// * `for`, followed by a comma separated list of e.g. primitives that are to be supported.
/// 
/// # Examples
/// ```
/// # use msuk_scifi::{implement_from_for_temperature, implement_as_for_temperature, unit::temperature::TemperatureInternalType};
/// # use paste::paste;
/// # struct K { value: f64 };
/// # implement_as_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// implement_from_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// ```
//
macro_rules! implement_from_for_temperature {
    ($type:ty, for $($t:ty),+) => {
        $(paste! {
                impl From<$type> for $t {
                    fn from(value: $type) -> $t {
                        value.[<as_ $t>]()
                    }
                }
        
                impl From<$t> for $type {
                    fn from(value: $t) -> Self {
                    Self { value: (value as TemperatureInternalType).max(0.0) }
                }
            }
        })+
    };
}

#[macro_export]
/// Implement various arithmetic functionality for the given temperature type.
/// 
/// # Implements
/// * [Add], [Sub], [Mul], [Div], and associated variants thereof.
/// 
/// # Arguments
/// * Some "temperature" type, e.g. `K` (for Kelvin).
/// * `for`, followed by a comma separated list of e.g. primitives that are to be supported.
/// 
/// # Examples
/// ```
/// # use msuk_scifi::{implement_arith_generics_for_temperature, implement_from_for_temperature, implement_as_for_temperature, unit::temperature::TemperatureInternalType};
/// # use std::ops::{Add, Sub, Mul, Div};
/// # use paste::paste;
/// # struct K { value: TemperatureInternalType };
/// # implement_from_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// # implement_as_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// implement_arith_generics_for_temperature!(K, for u32, i32, u64, i64, f32, f64);
/// ```
//
macro_rules! implement_arith_generics_for_temperature {
    // Can't use <T:Into<f64>> generics with these, so - macro'd copy-pasta it is.
    ($c:ty, for $($t:ty),+) => {
        impl Add<$c> for $c {
            type Output = Self;
            fn add(self, rhs: $c) -> Self::Output { Self::Output::from(self.value + rhs.value)}
        }

        impl Sub<$c> for $c {
            type Output = Self;
            fn sub(self, rhs: $c) -> Self::Output { Self::Output::from(self.value - rhs.value)}
        }

        // Mul<$c> for $c is -NOT- defined. Aside blackbody T⁴, multiplying temperatures with
        // each other doesn't make sense.

        impl Div<$c> for $c {
            type Output = TemperatureInternalType;
            fn div(self, rhs: $c) -> Self::Output { self.value / {
                if rhs.value == 0.0 { panic!("It burns! It burns! DBZ!"); }
                rhs.value
            }}
        }

        $(
            impl Add<$c> for $t {
                type Output = $c;
                /// Add `rhs` to a number, e.g. `10 + rhs`.
                fn add(self, rhs: Self::Output) -> Self::Output {
                    (self as TemperatureInternalType + rhs.value).into()
                }
            }

            impl Add<$t> for $c {
                type Output = Self;
                fn add(self, rhs: $t) -> Self::Output { Self::Output::from(self.value + rhs as TemperatureInternalType) }
            }

            impl Sub<$c> for $t {
                type Output = $c;
                /// Subtract `rhs` from a number, e.g. `10 - rhs`.
                fn sub(self, rhs: Self::Output) -> Self::Output {
                    (self as TemperatureInternalType - rhs.value).into()
                }
            }

            impl Sub<$t> for $c {
                type Output = Self;
                fn sub(self, rhs: $t) -> Self::Output { Self::Output::from(self.value - rhs as TemperatureInternalType) }
            }

            impl Mul<$c> for $t {
                type Output = $c;
                /// Multiply by `rhs`, e.g. `10 * rhs`.
                fn mul(self, rhs: Self::Output) -> Self::Output {
                    (self as TemperatureInternalType + rhs.value).into()
                }
            }

            impl Mul<$t> for $c {
                type Output = Self;
                fn mul(self, rhs: $t) -> Self::Output { Self::Output::from(self.value * rhs as TemperatureInternalType) }
            }

            impl Div<$c> for $t {
                type Output = $c;
                /// Divide by `rhs`, e.g. `10 / rhs`.
                fn div(self, rhs: Self::Output) -> Self::Output {
                    (self as TemperatureInternalType / {
                        if rhs.value == 0.0 {
                            let context = stringify!(Div<$c> for $t);
                            $crate::dbz_panic!(context, self, rhs.value);
                        }
                        rhs }).into()
                }
            }

            impl Div<$t> for $c {
                type Output = Self;
                fn div(self, rhs: $t) -> Self::Output {
                    let rhs = rhs as TemperatureInternalType;
                    ( self.value / {
                        if rhs == 0.0 {
                            let context = stringify!(Div<$t> for $c);
                            $crate::dbz_panic!(context, self.value, rhs);
                        }
                        rhs }).into()
                }
            }
        )+
    };
}

#[cfg(test)]
mod temperature_tests {
    #[should_panic]
    #[test]
    fn dbz_context_formatting_works() {
        use super::*;
        use std::ops::{Add, Sub, Mul, Div};
        use paste::paste;
        struct X { value: f64 }
        let a = 10.0;
        let z = X { value: 0.0 };
        implement_as_for_temperature!(X, for f64);
        implement_from_for_temperature!(X, for f64);
        implement_arith_generics_for_temperature!(X, for f64);
        let _: X = a / z;
    }
}