Struct opendal::io_util::DecompressDecoder

pub struct DecompressDecoder { /* private fields */ }

DecompressDecoder provides blocking decompress support for opendal: decode happen inside a blocking thread (user need to handle the decompress logic)

Note: please handle state carefully!

Examples

use futures::io::Cursor;
use opendal::io_util::DecompressDecoder;
use opendal::io_util::CompressAlgorithm;
use opendal::io_util::DecompressState;

let content = vec![0; 16 * 1024 * 1024];
let mut cr = DecompressDecoder::new(CompressAlgorithm::Gzip);
let mut result = vec![0; 16 * 1024 * 1024];
let mut amt = 0;
let mut cnt = 0;
loop {
    let (_, input) = content.split_at(amt);
    let (_, output) = result.split_at_mut(cnt);

    match cr.state() {
        DecompressState::Reading => {
            let read = cr.fill(&input);
            amt += read;
        }
        DecompressState::Decoding => {
            let written = cr.decode(output)?;
            cnt += written;
        }
        DecompressState::Flushing => {
            let written = cr.finish(output)?;
            cnt += written;
        }
        DecompressState::Done => {
            break;
        }
    }
}
}

Implementations

impl DecompressDecoder

pub fn new(algo: CompressAlgorithm) -> Self

Create a new DecompressDecoder with given CompressAlgorithm

pub fn state(&self) -> DecompressState

Get decompress state

pub fn fill(&mut self, bs: &[u8]) -> usize

Fetch more data from underlying reader.

Notes

For now, we will read all content into internal buffer. But in the future, we may change the implementation to only read part of input data.

So it’s required to check returning read size and advance the reader’s amt.

pub fn decode(&mut self, output: &mut [u8]) -> Result<usize>

Decode data into output. Returns the data that has been written.

pub fn finish(&mut self, output: &mut [u8]) -> Result<usize>

Finish a decompress press, flushing remaining data into output. Return the data that has been written.

Trait Implementations

impl Debug for DecompressDecoder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.