yaml-edit 0.3.5

A lossless parser and editor for YAML files
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

//! Arbitrary-precision conversion of digit strings to decimal.

/// Convert `digits`, already checked to be valid in `radix`, to decimal
/// without an upper bound on their value.
pub(crate) fn digits_to_decimal(digits: &str, radix: u32) -> String {
    places_to_decimal(
        digits
            .chars()
            .map(|c| (radix, c.to_digit(radix).expect("digits checked by caller"))),
    )
}

/// Like [`digits_to_decimal`], with a `-` in front when `negative` unless
/// the value is zero.
pub(crate) fn signed_digits_to_decimal(digits: &str, radix: u32, negative: bool) -> String {
    let magnitude = digits_to_decimal(digits, radix);
    if negative && magnitude != "0" {
        format!("-{magnitude}")
    } else {
        magnitude
    }
}

/// Convert a number given as `(radix, digit)` places, most significant
/// first, to decimal without an upper bound on its value. Each place has
/// its own radix, so mixed-radix numbers such as base 60 `1:30` work too.
pub(crate) fn places_to_decimal(places: impl IntoIterator<Item = (u32, u32)>) -> String {
    const LIMB: u64 = 1_000_000_000;
    // Little-endian base 10^9 limbs.
    let mut limbs: Vec<u64> = Vec::new();
    for (radix, digit) in places {
        debug_assert!(digit < radix);
        let mut carry = u64::from(digit);
        for limb in &mut limbs {
            let v = *limb * u64::from(radix) + carry;
            *limb = v % LIMB;
            carry = v / LIMB;
        }
        if carry > 0 {
            limbs.push(carry);
        }
    }
    let Some((most, rest)) = limbs.split_last() else {
        return "0".to_string();
    };
    let mut out = most.to_string();
    for limb in rest.iter().rev() {
        out.push_str(&format!("{limb:09}"));
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_digits_to_decimal() {
        for (digits, radix, expected) in [
            ("", 10, "0"),
            ("000", 8, "0"),
            ("0755", 8, "493"),
            ("1000000000", 10, "1000000000"),
            ("1000000000000000000", 10, "1000000000000000000"),
            ("ffffffffffffffff", 16, "18446744073709551615"),
            (
                "100000000000000000000000000000000",
                16,
                "340282366920938463463374607431768211456",
            ),
        ] {
            assert_eq!(digits_to_decimal(digits, radix), expected, "{digits}");
        }
    }

    #[test]
    fn test_places_to_decimal() {
        assert_eq!(places_to_decimal([(10, 1), (60, 30)]), "90");
        assert_eq!(
            places_to_decimal([
                (10, 1),
                (60, 0),
                (60, 0),
                (60, 0),
                (60, 0),
                (60, 0),
                (60, 0)
            ]),
            "46656000000"
        );
    }
}