lexe-common 0.1.5

Lexe common types, traits, and utilities
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use rust_decimal::Decimal;

/// A simpler, const-friendly, proc-macro-free `rust_decimal_macros::dec`.
///
/// Only handles decimals in the range `-2**63 <= x <= 2**63` to keep the
/// implementation simpler.
#[macro_export]
macro_rules! dec {
    ($amount:expr) => {
        const { $crate::decimal::decimal_from_str_const(stringify!($amount)) }
    };
}

/// A `const` version of [`Decimal::from_str_radix`] (with radix=10).
///
/// Only handles decimals in the range `-2**63 <= x <= 2**63` to keep the
/// implementation simpler.
pub const fn decimal_from_str_const(s: &str) -> Decimal {
    let mut bs = s.as_bytes();

    // check sign
    let mut negative = false;
    match bs.split_first() {
        Some((b, rest)) => match b {
            b'-' => {
                negative = true;
                bs = rest;
            }
            b'+' => bs = rest,
            _ => {}
        },
        None => panic!("empty"),
    }

    // parse the actual number, keeping track of the decimal position and
    // skipping any "_" characters.
    let mut num_digits: u8 = 0;
    let mut idx_point: Option<u8> = None;
    let mut accum: u64 = 0;
    while let [b, rest @ ..] = bs {
        bs = rest;
        match *b {
            b'0'..=b'9' => {
                let d = (*b - b'0') as u64;
                accum = accum.checked_mul(10).expect("overflow");
                accum = accum.checked_add(d).expect("overflow");
                num_digits += 1;
            }
            b'.' => {
                if idx_point.is_some() {
                    panic!("duplicate decimal point");
                }
                idx_point = Some(num_digits);
            }
            b'_' => continue,
            _ => panic!("not a valid decimal"),
        }
    }

    // probably an error
    if num_digits == 0 {
        panic!("no digits");
    }

    let lo = (accum & 0xffff_ffff) as u32;
    let mid = ((accum >> 32) & 0xffff_ffff) as u32;
    let hi = 0;
    let idx_point = match idx_point {
        Some(x) => x,
        None => num_digits,
    };
    let scale = (num_digits - idx_point) as u32;

    Decimal::from_parts(lo, mid, hi, negative, scale)
}

#[cfg(test)]
mod test {
    use proptest::proptest;

    use super::*;

    const MYCONST: Decimal = dec!(132.456);

    #[test]
    fn test_decimal_from_str_const() {
        #[track_caller]
        fn ok(s: &str) {
            let actual = decimal_from_str_const(s);
            let expected = Decimal::from_str_radix(s, 10).unwrap();
            assert_eq!(actual, expected);
        }

        ok("1");
        ok("1.");
        ok(".1");
        ok("-1");
        ok("0.1");
        ok("-0.1");
        ok("2.0");
        ok("-0");

        ok("9223372036854775808");
        ok("-9223372036854775808");

        ok("9.223372036854775808");
        ok("922337203685477580.8");
        ok("9223372036854775808.");

        assert_eq!(MYCONST, Decimal::from_parts(132456, 0, 0, false, 3));

        proptest!(|(x: u64, negative: bool, scale in 0u32..20)| {
            // sample only x < 2**63
            let x = x & 0x7fff_ffff_ffff_ffff;
            let lo = (x & 0xffff_ffff) as u32;
            let mid = ((x >> 32) & 0xffff_ffff) as u32;
            let hi = 0;
            let dec = Decimal::from_parts(lo, mid, hi, negative, scale);
            ok(&dec.to_string());
        })
    }
}