crcany-core 0.0.2

Core implementation of crcany library.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use crate::util::reverse;

mod parse;

#[derive(Clone)]
pub struct Spec {
    /// number of bits in the CRC (the degree of the polynomial)
    pub width: u16,
    /// polynomial representation (sans x^width)
    pub poly: u128,
    /// register initial value before first message bit
    pub init: u128,
    /// if true, reflect input (read bits LSB first)
    pub refin: bool,
    /// if true, reflect output
    pub refout: bool,
    /// final CRC is exclusive-or'ed with this
    pub xorout: u128,
    /// CRC of the nine ASCII bytes "123456789"
    pub check: u128,
    /// residue of the CRC
    pub residue: u128,
    /// text description of this CRC
    pub name: String,
}

impl Spec {
    pub fn reflect(&self) -> bool {
        self.refin
    }

    pub fn reverse(&self) -> bool {
        self.refin ^ self.refout
    }

    pub fn init(&self) -> u128 {
        let maybe_reversed = if self.refout {
            reverse(self.init, self.width)
        } else {
            self.init
        };

        maybe_reversed ^ self.xorout
    }

    pub fn poly(&self) -> u128 {
        if self.refin {
            reverse(self.poly, self.width)
        } else {
            self.poly
        }
    }
}

impl core::str::FromStr for Spec {
    type Err = parse::SpecParseError;

    fn from_str(s: &str) -> Result<Spec, parse::SpecParseError> {
        parse::read_spec(s)
    }
}

impl core::fmt::Display for Spec {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        if f.alternate() {
            write!(
                f,
                "w={width} p={poly}{init} r={refin}{refout}{xorout} c={check}{residue} n={name}",
                width = self.width,
                poly = self.poly,
                init = if self.init == 0 {
                    "".into()
                } else {
                    format!("i={}", self.init)
                },
                refin = if self.refin { "t" } else { "f" },
                refout = if self.refout == self.refin {
                    "".into()
                } else {
                    format!("refo={}", if self.refout { "t" } else { "f" })
                },
                xorout = if self.xorout == 0 {
                    "".into()
                } else {
                    format!("x={}", self.xorout)
                },
                check = self.check,
                residue = if self.residue == 0 {
                    "".into()
                } else {
                    format!("res={}", self.residue)
                },
                name = self.name,
            )
        } else {
            write!(
                f,
                "width={width} poly={poly:#06x} init={init:#06x} refin={refin} refout={refout} xorout={xorout:#06x} check={check:#06x} residue={residue:#06x} name={name:?}",
                width = self.width,
                poly = self.poly,
                init = self.init,
                refin = self.refin,
                refout = self.refout,
                xorout = self.xorout,
                check = self.check,
                residue = self.residue,
                name = self.name,
            )
        }
    }
}

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

    const KERMIT_FULL: &str = "width=16 poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189 residue=0x0000 name=\"KERMIT\"";
    const KERMIT_ABBR: &str = "w=16 p=4129 r=t c=8585 n=KERMIT";

    #[test]
    fn kermit_full() {
        let model = KERMIT_FULL.parse::<Spec>().unwrap();

        assert_eq!(KERMIT_FULL, format!("{}", model));
        assert_eq!(KERMIT_ABBR, format!("{:#}", model));
        assert_eq!(16, model.width);
        assert_eq!(0x1021, model.poly);
        assert_eq!(0, model.init);
        assert!(model.refin);
        assert!(model.refout);
        assert_eq!(0, model.xorout);
        assert_eq!(0x2189, model.check);
        assert_eq!(0, model.residue);
        assert_eq!("KERMIT", model.name);
    }

    #[test]
    fn kermit_abbr() {
        let model = KERMIT_ABBR.parse::<Spec>().unwrap();

        assert_eq!(KERMIT_FULL, format!("{}", model));
        assert_eq!(KERMIT_ABBR, format!("{:#}", model));
        assert_eq!(16, model.width);
        assert_eq!(0x1021, model.poly);
        assert_eq!(0, model.init);
        assert!(model.refin);
        assert!(model.refout);
        assert_eq!(0, model.xorout);
        assert_eq!(0x2189, model.check);
        assert_eq!(0, model.residue);
        assert_eq!("KERMIT", model.name);
    }
}