lzfse_rust 0.2.1

A pure Rust LZFSE 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

pub trait PackBits {
    fn get_bits(&self, offset: u32, nbits: u32) -> Self;

    fn set_bits(&mut self, offset: u32, nbits: u32, value: Self);
}

impl PackBits for u64 {
    #[inline(always)]
    fn get_bits(&self, offset: u32, nbits: u32) -> Self {
        debug_assert!(offset + nbits <= 64);
        debug_assert!(nbits <= 64);
        (self >> offset) & mask_u64(nbits)
    }

    #[inline(always)]
    fn set_bits(&mut self, offset: u32, nbits: u32, value: u64) {
        debug_assert!(offset + nbits <= 64);
        debug_assert!(nbits <= 64);
        debug_assert!(mask_u64(nbits) & value == value);
        *self |= value << offset;
    }
}

impl PackBits for u32 {
    #[inline(always)]
    fn get_bits(&self, offset: u32, nbits: u32) -> Self {
        debug_assert!(offset + nbits <= 32);
        debug_assert!(nbits <= 32);
        (self >> offset) & mask_u32(nbits)
    }

    #[inline(always)]
    fn set_bits(&mut self, offset: u32, nbits: u32, value: u32) {
        debug_assert!(offset + nbits <= 32);
        debug_assert!(nbits <= 32);
        debug_assert!(mask_u32(nbits) & value == value);
        *self |= value << offset;
    }
}

impl PackBits for u16 {
    #[inline(always)]
    fn get_bits(&self, offset: u32, nbits: u32) -> Self {
        debug_assert!(offset + nbits <= 16);
        debug_assert!(nbits <= 16);
        (self >> offset) & mask_u16(nbits)
    }

    #[inline(always)]
    fn set_bits(&mut self, offset: u32, nbits: u32, value: u16) {
        debug_assert!(offset + nbits <= 16);
        debug_assert!(nbits <= 16);
        debug_assert!(mask_u16(nbits) & value == value);
        *self |= value << offset;
    }
}

impl PackBits for u8 {
    #[inline(always)]
    fn get_bits(&self, offset: u32, nbits: u32) -> Self {
        debug_assert!(offset + nbits <= 8);
        debug_assert!(nbits <= 8);
        (self >> offset) & mask_u8(nbits)
    }

    #[inline(always)]
    fn set_bits(&mut self, offset: u32, nbits: u32, value: u8) {
        debug_assert!(offset + nbits <= 8);
        debug_assert!(nbits <= 8);
        debug_assert!(mask_u8(nbits) & value == value);
        *self |= value << offset;
    }
}

#[inline(always)]
pub fn mask_u64(nbits: u32) -> u64 {
    debug_assert!(nbits < 64);
    (1 << nbits) - 1
}

#[inline(always)]
pub fn mask_u32(nbits: u32) -> u32 {
    debug_assert!(nbits <= 31);
    (1 << nbits) - 1
}

#[inline(always)]
pub fn mask_u16(nbits: u32) -> u16 {
    debug_assert!(nbits <= 15);
    (1 << nbits) - 1
}

#[inline(always)]
pub fn mask_u8(nbits: u32) -> u8 {
    debug_assert!(nbits <= 7);
    (1 << nbits) - 1
}