libmhash 0.2.1

A file hashing library that can do multiple hashes for multile files at the same time.
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

use std::mem::size_of;

use crate::{paranoid_hash::Hasher, Error, Result};

#[derive(Clone, Debug, Default)]
pub struct CRC32 {
    state: crc32fast::Hasher,
    is_done: bool,
    digest: [u8; 4],
}

#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct CRC32C {
    state: u32,
    is_done: bool,
    digest: [u8; 4],
}

impl CRC32 {
    pub const BLOCK_SIZE: usize = 1;
    pub const DIGEST_SIZE: usize = size_of::<u32>();

    pub fn new() -> Self {
        Self {
            state: crc32fast::Hasher::new(),
            digest: [0; 4],
            is_done: false,
        }
    }
}

impl Hasher for CRC32 {
    fn update(&mut self, data: &[u8]) -> Result<()> {
        if self.is_done {
            return Err(Error::UpdatingAfterFinished);
        }

        self.state.update(data);

        Ok(())
    }

    fn update_last(&mut self, data: &[u8]) -> Result<()> {
        self.update(data)?;

        self.digest = self.state.clone().finalize().to_be_bytes();

        self.is_done = true;

        Ok(())
    }

    fn digest(&self) -> Result<&[u8]> {
        if !self.is_done {
            return Err(Error::NotFinished);
        }

        Ok(&self.digest)
    }

    fn reset(&mut self) {
        *self = Self::new();
    }

    fn block_size(&self) -> usize {
        Self::BLOCK_SIZE
    }

    fn digest_size(&self) -> usize {
        Self::DIGEST_SIZE
    }
}

impl CRC32C {
    pub const BLOCK_SIZE: usize = 1;
    pub const DIGEST_SIZE: usize = size_of::<u32>();

    pub const fn new() -> Self {
        Self {
            state: 0,
            digest: [0; 4],
            is_done: false,
        }
    }
}

impl Hasher for CRC32C {
    fn update(&mut self, data: &[u8]) -> Result<()> {
        if self.is_done {
            return Err(Error::UpdatingAfterFinished);
        }

        self.state = crc32c::crc32c_append(self.state, data);

        Ok(())
    }

    fn update_last(&mut self, data: &[u8]) -> Result<()> {
        self.update(data)?;

        self.digest = self.state.to_be_bytes();

        self.is_done = true;

        Ok(())
    }

    fn digest(&self) -> Result<&[u8]> {
        if !self.is_done {
            return Err(Error::NotFinished);
        }

        Ok(&self.digest)
    }

    fn reset(&mut self) {
        *self = Self::new();
    }

    fn block_size(&self) -> usize {
        Self::BLOCK_SIZE
    }

    fn digest_size(&self) -> usize {
        Self::DIGEST_SIZE
    }
}