qrcode-generator 6.0.0

Generates ISO/IEC 18004 QR Code and Micro QR Code symbols and ISO/IEC 23941 rMQR symbols in pure Rust, then renders them as grayscale, PNG and SVG images.
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

use alloc::vec::Vec;

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct BitBuffer {
    bytes: Vec<u8>,
    len:   usize,
}

impl BitBuffer {
    #[inline]
    pub(crate) fn with_capacity(bits: usize) -> Self {
        Self {
            bytes: Vec::with_capacity(bits.div_ceil(8)), len: 0
        }
    }

    #[inline]
    pub(crate) fn from_bytes(bytes: Vec<u8>) -> Self {
        let len = bytes.len() * 8;

        Self {
            bytes,
            len,
        }
    }

    #[cfg(any(feature = "qr", feature = "micro-qr", feature = "rmqr"))]
    #[inline]
    pub(crate) const fn len(&self) -> usize {
        self.len
    }

    #[inline]
    pub(crate) fn append(&mut self, value: u32, count: u8) {
        debug_assert!(count <= 32);
        debug_assert!(count == 32 || value >> count == 0);

        // QR Code fields are appended from the most significant selected bit.
        let mut remaining = usize::from(count);
        let used = self.len & 7;

        // The partially filled final byte takes as many leading bits as it can hold.
        if used != 0 {
            let take = (8 - used).min(remaining);

            remaining -= take;

            let bits = ((value >> remaining) as u8) & ((1 << take) - 1);
            let index = self.bytes.len() - 1;

            self.bytes[index] |= bits << (8 - used - take);
        }

        while remaining >= 8 {
            remaining -= 8;
            self.bytes.push((value >> remaining) as u8);
        }

        if remaining > 0 {
            self.bytes.push((value as u8 & ((1 << remaining) - 1)) << (8 - remaining));
        }

        self.len += usize::from(count);
    }

    #[cfg(any(feature = "qr", feature = "micro-qr", feature = "rmqr"))]
    pub(crate) fn extend(&mut self, other: &Self) {
        let whole_bytes = other.len >> 3;
        let trailing = (other.len & 7) as u8;

        if self.len & 7 == 0 {
            // A byte-aligned destination copies the whole source bytes directly.
            self.bytes.extend_from_slice(&other.bytes[..whole_bytes]);
            self.len += whole_bytes * 8;
        } else {
            for &byte in &other.bytes[..whole_bytes] {
                self.append(u32::from(byte), 8);
            }
        }

        if trailing != 0 {
            self.append(u32::from(other.bytes[whole_bytes]) >> (8 - trailing), trailing);
        }
    }

    #[cfg(any(feature = "qr", feature = "micro-qr", feature = "rmqr"))]
    #[inline]
    pub(crate) fn push(&mut self, bit: bool) {
        if self.len & 7 == 0 {
            self.bytes.push(0);
        }

        if bit {
            let index = self.bytes.len() - 1;
            self.bytes[index] |= 1 << (7 - (self.len & 7));
        }

        self.len += 1;
    }

    #[cfg(any(feature = "micro-qr", feature = "rmqr"))]
    #[inline]
    pub(crate) fn bit(&self, index: usize) -> bool {
        debug_assert!(index < self.len);

        self.bytes[index >> 3] >> (7 - (index & 7)) & 1 != 0
    }

    #[cfg(any(feature = "qr", feature = "rmqr"))]
    #[inline]
    pub(crate) fn into_bytes(self) -> Vec<u8> {
        debug_assert_eq!(self.len & 7, 0);

        self.bytes
    }

    #[cfg(any(feature = "qr", feature = "rmqr"))]
    #[inline]
    pub(crate) fn as_bytes(&self) -> &[u8] {
        debug_assert_eq!(self.len & 7, 0);

        &self.bytes
    }

    #[cfg(feature = "micro-qr")]
    #[inline]
    pub(crate) fn into_padded_bytes(self) -> Vec<u8> {
        self.bytes
    }
}