bxvl 0.1.1

A datatype library that allows for measurement unit association, conversion, and operations for values.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::fmt::Display;

use super::{BaseUnit, Convert, Metric, UnitNone};

impl Display for UnitNone {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                Self::None => "",
                Self::Percentage => "%",
            }
        )
    }
}

impl From<UnitNone> for String {
    fn from(val: UnitNone) -> Self {
        val.to_string()
    }
}

impl<T> Convert<T> for UnitNone
where
    T: BaseUnit,
{
    fn convert(&self, other: &T) -> f64 {
        other.scale() * other.base()
    }
}

impl BaseUnit for UnitNone {
    fn scale(&self) -> f64 {
        1.0
    }

    fn base(&self) -> f64 {
        1.0
    }

    fn get_metric(&self) -> Metric {
        Metric::None
    }
}

#[cfg(test)]
mod unitless_testing {
    use crate::{
        consts::LENGTH_MILE_TO_METER,
        units::{BaseUnit, Convert, Metric, UnitLength, UnitNone},
    };

    /// Unit Time Comparison Base
    ///
    /// All units must return the 'base' value relative to the standard SI unit
    #[test]
    fn unit_time_base_comparison() {
        assert_eq!(UnitNone::None.base(), 1.0);
        assert_eq!(UnitNone::Percentage.base(), 1.0);
    }

    #[test]
    fn unit_angle_to_string() {
        for i in [(UnitNone::None, ""), (UnitNone::Percentage, "%")] {
            assert_eq!(&i.0.to_string(), i.1);
            let t: String = i.0.into();
            assert_eq!(t, i.1.to_string());
        }
    }

    #[test]
    fn unit_angle_scale() {
        for i in [
            (UnitNone::None, Metric::None),
            (UnitNone::None, Metric::None),
        ] {
            assert_eq!(i.0.get_metric(), i.1);
        }

        for i in [(UnitNone::None, 1.0), (UnitNone::None, 1.0)] {
            assert_eq!(i.0.scale(), i.1);
        }
    }

    #[test]
    fn unitless_convert() {
        assert_eq!(
            (UnitNone::None).convert(&UnitLength::Mile),
            LENGTH_MILE_TO_METER
        );
    }
}