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

use crate::crc::Crc;
use crate::model::bitwise::BitwiseModel;
use crate::spec::Spec;
use crate::util::{ones, reverse};

pub struct BytewiseModel {
    model: BitwiseModel,
    // table for byte-wise calculation
    pub table: [u128; 256],
}

impl BytewiseModel {
    pub fn reflect(&self) -> bool {
        self.model.reflect()
    }

    pub fn reverse(&self) -> bool {
        self.model.reverse()
    }

    pub fn width(&self) -> u16 {
        self.model.width()
    }

    pub fn xorout(&self) -> u128 {
        self.model.xorout()
    }

    pub fn init(&self) -> u128 {
        self.model.init()
    }

    fn fill_table(&mut self) {
        for k in 0..256_usize {
            let byte = k as _;
            let mut crc = self.model.add_bytes(0, &[byte][..]);
            if self.model.reverse() {
                crc = reverse(crc, self.model.width());
            }
            if self.model.width() < 8 && !self.model.reflect() {
                crc <<= 8 - self.model.width();
            }
            self.table[k] = crc;
        }
    }

    pub fn from_spec(spec: Spec) -> BytewiseModel {
        let mut me = BytewiseModel {
            model: BitwiseModel::from_spec(spec),
            table: [0; 256],
        };
        me.fill_table();
        me
    }
}

impl Crc for BytewiseModel {
    type Int = u128;

    fn init(&self) -> u128 {
        self.init() as _
    }

    fn add_bytes(&self, mut crc: u128, bytes: &[u8]) -> u128 {
        if bytes.is_empty() {
            return crc;
        }

        if self.model.reverse() {
            crc = reverse(crc, self.model.width());
        }

        if self.model.reflect() {
            crc &= ones(self.model.width());
            for byte in bytes {
                crc = (crc >> 8) ^ self.table[(crc ^ (*byte as u128)) as u8 as usize];
            }
        } else if self.model.width() < 8 {
            let shift = 8 - self.model.width();
            crc <<= shift;
            for byte in bytes {
                crc = self.table[(crc ^ (*byte as u128)) as usize];
            }
            crc >>= shift;
        } else {
            let shift = self.model.width() - 8;
            for byte in bytes {
                crc = (crc << 8) ^ self.table[(((crc >> shift) ^ (*byte as u128)) as u8) as usize];
            }
            crc &= ones(self.model.width());
        }

        if self.model.reverse() {
            crc = reverse(crc, self.model.width());
        }

        crc as _
    }
}