1 /// A wrapper for the output slice used when decompressing. 2 /// 3 /// Using this rather than `Cursor` lets us implement the writing methods directly on 4 /// the buffer and lets us use a usize rather than u64 for the position which helps with 5 /// performance on 32-bit systems. 6 pub struct OutputBuffer<'a> { 7 slice: &'a mut [u8], 8 position: usize, 9 } 10 11 impl<'a> OutputBuffer<'a> { 12 #[inline] 13 pub fn from_slice_and_pos(slice: &'a mut [u8], position: usize) -> OutputBuffer<'a> { 14 OutputBuffer { slice, position } 15 } 16 17 #[inline] 18 pub fn position(&self) -> usize { 19 self.position 20 } 21 22 #[inline] 23 pub fn set_position(&mut self, position: usize) { 24 self.position = position; 25 } 26 27 /// Write a byte to the current position and increment 28 /// 29 /// Assumes that there is space. 30 #[inline] 31 pub fn write_byte(&mut self, byte: u8) { 32 self.slice[self.position] = byte; 33 self.position += 1; 34 } 35 36 /// Write a slice to the current position and increment 37 /// 38 /// Assumes that there is space. 39 #[inline] 40 pub fn write_slice(&mut self, data: &[u8]) { 41 let len = data.len(); 42 self.slice[self.position..self.position + len].copy_from_slice(data); 43 self.position += data.len(); 44 } 45 46 #[inline] 47 pub fn bytes_left(&self) -> usize { 48 self.slice.len() - self.position 49 } 50 51 #[inline] 52 pub fn get_ref(&self) -> &[u8] { 53 self.slice 54 } 55 56 #[inline] 57 pub fn get_mut(&mut self) -> &mut [u8] { 58 self.slice 59 } 60 } 61