xref: /xiu/library/bytesio/src/bits_reader.rs (revision ccd9a1fa) 
1 use {
2     super::bits_errors::{BitError, BitErrorValue},
3     super::bytes_reader::BytesReader,
4     bytes::BytesMut,
5 };
6 
7 pub struct BitsReader {
8     reader: BytesReader,
9     cur_byte: u8,
10     cur_bit_left: u8,
11 }
12 
13 impl BitsReader {
new(reader: BytesReader) -> Self14     pub fn new(reader: BytesReader) -> Self {
15         Self {
16             reader,
17             cur_byte: 0,
18             cur_bit_left: 0,
19         }
20     }
21 
extend_data(&mut self, bytes: BytesMut)22     pub fn extend_data(&mut self, bytes: BytesMut) {
23         self.reader.extend_from_slice(&bytes[..]);
24     }
25 
len(&self) -> usize26     pub fn len(&self) -> usize {
27         self.reader.len() * 8 + self.cur_bit_left as usize
28     }
29 
is_empty(&self) -> bool30     pub fn is_empty(&self) -> bool {
31         self.len() == 0
32     }
33 
read_byte(&mut self) -> Result<u8, BitError>34     pub fn read_byte(&mut self) -> Result<u8, BitError> {
35         if self.cur_bit_left != 0 {
36             return Err(BitError {
37                 value: BitErrorValue::CannotReadByte,
38             });
39         }
40 
41         let byte = self.reader.read_u8()?;
42         Ok(byte)
43     }
44 
read_bit(&mut self) -> Result<u8, BitError>45     pub fn read_bit(&mut self) -> Result<u8, BitError> {
46         if self.cur_bit_left == 0 {
47             self.cur_byte = self.reader.read_u8()?;
48             self.cur_bit_left = 8;
49         }
50         self.cur_bit_left -= 1;
51         Ok((self.cur_byte >> self.cur_bit_left) & 0x01)
52     }
53 
read_n_bits(&mut self, n: usize) -> Result<u64, BitError>54     pub fn read_n_bits(&mut self, n: usize) -> Result<u64, BitError> {
55         let mut result: u64 = 0;
56         for _ in 0..n {
57             result <<= 1;
58             let cur_bit = self.read_bit()?;
59             result |= cur_bit as u64;
60         }
61         Ok(result)
62     }
63 
bits_aligment_8(&mut self)64     pub fn bits_aligment_8(&mut self) {
65         self.cur_bit_left = 0;
66     }
67 }
68 
69 #[cfg(test)]
70 mod tests {
71 
72     use super::BitsReader;
73     use super::BytesReader;
74     use bytes::BytesMut;
75 
76     #[test]
test_read_bit()77     fn test_read_bit() {
78         let mut bytes_reader = BytesReader::new(BytesMut::new());
79 
80         let data_0 = 2u8;
81         bytes_reader.extend_from_slice(&[data_0]);
82         let data_1 = 7u8;
83         bytes_reader.extend_from_slice(&[data_1]);
84 
85         let mut bit_reader = BitsReader::new(bytes_reader);
86 
87         assert!(bit_reader.read_bit().unwrap() == 0);
88         assert!(bit_reader.read_bit().unwrap() == 0);
89         assert!(bit_reader.read_bit().unwrap() == 0);
90         assert!(bit_reader.read_bit().unwrap() == 0);
91 
92         assert!(bit_reader.read_bit().unwrap() == 0);
93         assert!(bit_reader.read_bit().unwrap() == 0);
94         assert!(bit_reader.read_bit().unwrap() == 1);
95         assert!(bit_reader.read_bit().unwrap() == 0);
96 
97         assert!(bit_reader.read_bit().unwrap() == 0);
98         assert!(bit_reader.read_bit().unwrap() == 0);
99         assert!(bit_reader.read_bit().unwrap() == 0);
100         assert!(bit_reader.read_bit().unwrap() == 0);
101 
102         assert!(bit_reader.read_bit().unwrap() == 0);
103         assert!(bit_reader.read_bit().unwrap() == 1);
104         assert!(bit_reader.read_bit().unwrap() == 1);
105         assert!(bit_reader.read_bit().unwrap() == 1);
106     }
107     #[test]
test_read_n_bits()108     fn test_read_n_bits() {
109         let mut bytes_reader = BytesReader::new(BytesMut::new());
110 
111         let data_0 = 2u8;
112         bytes_reader.extend_from_slice(&[data_0]);
113         let data_1 = 7u8;
114         bytes_reader.extend_from_slice(&[data_1]);
115         bytes_reader.extend_from_slice(&[0b00000010]);
116 
117         let mut bit_reader = BitsReader::new(bytes_reader);
118         assert!(bit_reader.read_n_bits(16).unwrap() == 0x207);
119 
120         assert!(bit_reader.read_n_bits(5).unwrap() == 0);
121 
122         assert!(bit_reader.read_n_bits(3).unwrap() == 2);
123     }
124 
125     #[test]
test_bits_aligment_8()126     fn test_bits_aligment_8() {
127         let mut bytes_reader = BytesReader::new(BytesMut::new());
128         let data_0 = 2u8;
129         bytes_reader.extend_from_slice(&[data_0]);
130         let data_1 = 7u8;
131         bytes_reader.extend_from_slice(&[data_1]);
132 
133         let mut bit_reader = BitsReader::new(bytes_reader);
134 
135         assert!(bit_reader.read_bit().unwrap() == 0);
136         assert!(bit_reader.read_bit().unwrap() == 0);
137         assert!(bit_reader.read_bit().unwrap() == 0);
138         assert!(bit_reader.read_bit().unwrap() == 0);
139 
140         bit_reader.bits_aligment_8();
141 
142         assert!(bit_reader.read_bit().unwrap() == 0);
143         assert!(bit_reader.read_bit().unwrap() == 0);
144         assert!(bit_reader.read_bit().unwrap() == 0);
145         assert!(bit_reader.read_bit().unwrap() == 0);
146 
147         assert!(bit_reader.read_bit().unwrap() == 0);
148         assert!(bit_reader.read_bit().unwrap() == 1);
149         assert!(bit_reader.read_bit().unwrap() == 1);
150         assert!(bit_reader.read_bit().unwrap() == 1);
151     }
152 }
153