vendor/miniz_oxide-0.4.0/src/inflate/output_buffer.rs

   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 }