使用Snappy壓縮緩衝區

Question

我想弄清楚在Rust中使用緩衝區和snappy的最佳方式。之前，我正在使用BufWriter寫信給一個文件。但現在我想要添加壓縮。上面那個活潑的箱子的compress函數需要一個&[u8]作爲參數，但BufWriter不會讓我訪問它的緩衝區以傳遞到活動。我已經研究了兩種方法來解決這個問題。

在第一種方式中，我使用一個矢量（with_capacity）而不是BufWriter作爲我的緩衝區，並創建了一個寫入函數，以確保寫入矢量不會導致它重新分配。如果是這樣，我會壓縮緩衝區中的當前內容，然後將其寫入文件並釋放向量（排出函數）。我根據BufWriter所做的來寫這篇文章。缺點是由於它是一個向量，如果緩衝區超出範圍，它不會自動將緩衝區移出到文件。我必須在編寫文件的範圍內手動執行此操作，而我不喜歡這些操作。

另一方面，我或多或少地複製了BufWriter源代碼，並且只是改變了flush函數來在輸出到文件之前壓縮它們的緩衝區（矢量）。這種方式似乎是最好的，但我不喜歡只複製代碼的想法。

什麼是繼續這兩個選項或其他選項的最佳方式？

如果有關，我寫到緩衝區中的對象總是相同的大小和我的緩衝區大小爲對象大小的倍數。

Answer 1

由於它看起來像活潑的需要一次壓縮所有，你只需要緩衝一切，直到結束。然後，您可以刷新，並在年底壓縮：

use std::io::{self, Write, Cursor}; 

fn compress(_data: &[u8]) -> Vec<u8> { 
    // The best compression ever 
    b"compressed".as_ref().into() 
} 

struct SnappyCompressor<W> { 
    inner: W, 
    buffer: Vec<u8>, 
} 

impl<W> SnappyCompressor<W> 
    where W: Write 
{ 
    fn new(inner: W) -> Self { 
     SnappyCompressor { 
      inner: inner, 
      buffer: vec![], 
     } 
    } 
} 

impl<W> Write for SnappyCompressor<W> 
    where W: Write 
{ 
    fn write(&mut self, data: &[u8]) -> io::Result<usize> { 
     self.buffer.extend(data); 
     Ok(data.len()) 
    } 

    fn flush(&mut self) -> io::Result<()> { 
     let compressed = compress(&self.buffer); 
     self.inner.write_all(&compressed) 
    } 
} 

fn main() { 
    let mut output = Cursor::new(vec![]); 
    { 
     let mut compressor = SnappyCompressor::new(output.by_ref()); 
     assert_eq!(5, compressor.write(b"hello").unwrap()); 
     assert_eq!(5, compressor.write(b"world").unwrap()); 
     compressor.flush().unwrap(); 
    } 
    let bytes = output.into_inner(); 
    assert_eq!(&b"compressed"[..], &bytes[..]); 
} 

這個解決方案有一個很大的疑問的方面 - 我們正在使用flush標記流的結束，但是這不是真的那麼方法的意義。使用純流式壓縮機可能會好得多，但有時你必須做你必須做的事情。

還有幾個地雷：

1. 你必須顯式調用flush
2. 你不能叫flush兩次。

要允許用戶簡單地丟棄壓縮機並讓它來完成，可以實現Drop：

impl<W> Drop for SnappyCompressor<W> 
    where W: Write 
{ 
    fn drop(&mut self) { 
     self.flush().unwrap(); 
    } 
} 

爲了防止企圖沖洗兩次，你需要添加一個標誌來跟蹤：

fn write(&mut self, data: &[u8]) -> io::Result<usize> { 
    if self.is_flushed { 
     return Err(Error::new(ErrorKind::Other, "Buffer has already been compressed, cannot add more data")); 
    } 

    self.buffer.extend(data); 
    Ok(data.len()) 
} 

fn flush(&mut self) -> io::Result<()> { 
    if self.is_flushed { 
     return Ok(()) 
    } 

    self.is_flushed = true; 
    let compressed = compress(&self.buffer); 
    self.inner.write_all(&compressed) 
} 

總之，最後的版本是這樣的：

use std::io::{self, Write, Cursor, Error, ErrorKind}; 

fn compress(_data: &[u8]) -> Vec<u8> { 
    // The best compression ever 
    b"compressed".as_ref().into() 
} 

struct SnappyCompressor<W> 
    where W: Write 
{ 
    inner: W, 
    buffer: Vec<u8>, 
    is_flushed: bool, 
} 

impl<W> SnappyCompressor<W> 
    where W: Write 
{ 
    fn new(inner: W) -> Self { 
     SnappyCompressor { 
      inner: inner, 
      buffer: vec![], 
      is_flushed: false, 
     } 
    } 

    // fn into_inner 
} 

impl<W> Write for SnappyCompressor<W> 
    where W: Write 
{ 
    fn write(&mut self, data: &[u8]) -> io::Result<usize> { 
     if self.is_flushed { 
      return Err(Error::new(ErrorKind::Other, "Buffer has already been compressed, cannot add more data")); 
     } 

     self.buffer.extend(data); 
     Ok(data.len()) 
    } 

    fn flush(&mut self) -> io::Result<()> { 
     if self.is_flushed { 
      return Ok(()) 
     } 

     self.is_flushed = true; 
     let compressed = compress(&self.buffer); 
     self.inner.write_all(&compressed) 
    } 
} 

impl<W> Drop for SnappyCompressor<W> 
    where W: Write 
{ 
    fn drop(&mut self) { 
     self.flush().unwrap(); 
    } 
} 

fn main() { 
    let mut output = Cursor::new(vec![]); 
    { 
     let mut compressor = SnappyCompressor::new(output.by_ref()); 
     assert_eq!(5, compressor.write(b"hello").unwrap()); 
     assert_eq!(5, compressor.write(b"world").unwrap()); 
     compressor.flush().unwrap(); 
    } 
    let bytes = output.into_inner(); 
    assert_eq!(&b"compressed"[..], &bytes[..]); 
}