adler32fast 1.1.0

Fast, SIMD-accelerated Adler-32 checksum computation
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

use cfg_if::cfg_if;

cfg_if! {
    if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
        pub mod avx2;
        pub mod ssse3;

        #[derive(Copy, Clone, Debug)]
        pub enum Arch {
            Avx2(avx2::State),
            Ssse3(ssse3::State),
        }

        #[derive(Copy, Clone, Debug)]
        pub struct State {
            arch: Arch,
        }

        impl State {
            pub fn new(initial: u32) -> Option<Self> {
                avx2::State::new(initial)
                    .map(|a| Self {
                        arch: Arch::Avx2(a),
                    })
                    .or_else(|| {
                        ssse3::State::new(initial).map(|a| Self {
                            arch: Arch::Ssse3(a),
                        })
                    })
            }

            pub fn finalize(self) -> u32 {
                match self.arch {
                    Arch::Avx2(state) => state.finalize(),
                    Arch::Ssse3(state) => state.finalize(),
                }
            }

            pub fn reset(&mut self) {
                match self.arch {
                    Arch::Avx2(ref mut state) => state.reset(),
                    Arch::Ssse3(ref mut state) => state.reset(),
                };
            }

            pub fn update(&mut self, buf: &[u8]) {
                match self.arch {
                    Arch::Avx2(ref mut state) => state.update(buf),
                    Arch::Ssse3(ref mut state) => state.update(buf),
                }
            }
        }
    } else {
        #[derive(Copy, Clone, Debug)]
        pub enum State {}

        impl State {
            pub fn new(_: u32) -> Option<Self> {
                None
            }

            pub fn finalize(self) -> u32 {
                unimplemented!()
            }

            pub fn reset(&mut self) {
                unimplemented!()
            }

            pub fn update(&mut self, _: &[u8]) {
                unimplemented!()
            }
        }
    }
}