ctcore 0.2.0

Precision tools for the CTfile family of file formats.
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

use super::{NonZeroDigit, Printable};

#[derive(Debug, PartialEq, Clone, Copy)]
pub enum Digit {
    Zero,
    NonZero(NonZeroDigit),
}

impl Digit {
    pub fn d0() -> Self {
        Self::Zero
    }

    pub fn d1() -> Self {
        Self::NonZero(NonZeroDigit::D1)
    }

    pub fn d2() -> Self {
        Self::NonZero(NonZeroDigit::D2)
    }

    pub fn d3() -> Self {
        Self::NonZero(NonZeroDigit::D3)
    }

    pub fn d4() -> Self {
        Self::NonZero(NonZeroDigit::D4)
    }

    pub fn d5() -> Self {
        Self::NonZero(NonZeroDigit::D5)
    }

    pub fn d6() -> Self {
        Self::NonZero(NonZeroDigit::D6)
    }

    pub fn d7() -> Self {
        Self::NonZero(NonZeroDigit::D7)
    }

    pub fn d8() -> Self {
        Self::NonZero(NonZeroDigit::D8)
    }

    pub fn d9() -> Self {
        Self::NonZero(NonZeroDigit::D9)
    }

    pub fn from_printable(printable: Printable) -> Option<Self> {
        match printable {
            Printable::D0 => Some(Self::Zero),
            Printable::D1 => Some(Self::NonZero(NonZeroDigit::D1)),
            Printable::D2 => Some(Self::NonZero(NonZeroDigit::D2)),
            Printable::D3 => Some(Self::NonZero(NonZeroDigit::D3)),
            Printable::D4 => Some(Self::NonZero(NonZeroDigit::D4)),
            Printable::D5 => Some(Self::NonZero(NonZeroDigit::D5)),
            Printable::D6 => Some(Self::NonZero(NonZeroDigit::D6)),
            Printable::D7 => Some(Self::NonZero(NonZeroDigit::D7)),
            Printable::D8 => Some(Self::NonZero(NonZeroDigit::D8)),
            Printable::D9 => Some(Self::NonZero(NonZeroDigit::D9)),
            _ => None,
        }
    }

    pub fn split(mut int: u32) -> Vec<Self> {
        if int == 0 {
            return vec![Digit::Zero];
        }

        let mut digits = Vec::new();

        while int > 0 {
            digits.push(match int % 10 {
                0 => Digit::Zero,
                1 => Digit::NonZero(NonZeroDigit::D1),
                2 => Digit::NonZero(NonZeroDigit::D2),
                3 => Digit::NonZero(NonZeroDigit::D3),
                4 => Digit::NonZero(NonZeroDigit::D4),
                5 => Digit::NonZero(NonZeroDigit::D5),
                6 => Digit::NonZero(NonZeroDigit::D6),
                7 => Digit::NonZero(NonZeroDigit::D7),
                8 => Digit::NonZero(NonZeroDigit::D8),
                9 => Digit::NonZero(NonZeroDigit::D9),
                _ => unreachable!(),
            });

            int /= 10;
        }

        digits.reverse();

        digits
    }
}

#[cfg(test)]
mod split {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn zero() {
        assert_eq!(Digit::split(0), vec![Digit::Zero])
    }

    #[test]
    fn one() {
        assert_eq!(Digit::split(1), vec![Digit::NonZero(NonZeroDigit::D1)])
    }

    #[test]
    fn forty_two() {
        assert_eq!(Digit::split(42), vec![Digit::d4(), Digit::d2()])
    }
}