Struct blosc::Context

pub struct Context { /* fields omitted */ }

Holds basic settings for compress operations.

Methods

impl Context

pub fn blocksize(self, blocksize: Option<usize>) -> Self

Select the Context's blocksize.

Blocksize is the amount of data the compressor will work on at one time. Limiting it can improve the CPU's cache hit rate. Increasing it can improve compression. Generally this should be None, in which case Blosc will choose a sensible value.

pub fn clevel(self, clevel: Clevel) -> Self

Select the Context's compression level.

Higher values will give better compression at the expense of speed.

pub fn compressor(self, compressor: Compressor) -> Result<Self, ()>

Select the Context's compression algorithm.

Returns an error if the compressor is not enabled in this build of C-Blosc.

pub fn compress<T>(&self, src: &[T]) -> Buffer<T>

Compress an array and return a newly allocated compressed buffer.

pub fn new() -> Self

Build a default compression context.

Example

let ctx = Context::new()
    .blocksize(Some(262144))
    .compressor(Compressor::Zstd).unwrap()
    .clevel(Clevel::L9)
    .shuffle(ShuffleMode::Bit);

pub fn shuffle(self, shuffle_mode: ShuffleMode) -> Self

Select which Shuffle filter to apply before compression.

pub fn typesize(self, typesize: Option<usize>) -> Self

Manually set the size in bytes to assume for each uncompressed array element.

The typesize is used for Blosc's shuffle operation. When compressing arrays, the typesize should be the size of each array element. If None or unspecified, it will be autodetected. However, manually setting typesize can be useful when compressing preserialized buffers or single structures that contain arrays.

Examples

Set the typesize when compressing an array-containing struct

#[derive(Default)]
struct Foo {
    x: usize,
    y: [u32; 32]
}
let foo = [Foo::default()];
let ctx = Context::new().typesize(Some(mem::size_of_val(&foo[0].y[0])));
ctx.compress(&foo[..]);

Set the typesize when compressing preserialized data.

let raw: Vec<i16> = vec![0, 1, 2, 3, 4, 5];
let serialized = bincode::serialize(&raw).unwrap();
let ctx = Context::new().typesize(Some(mem::size_of::<i16>()));
ctx.compress(&serialized[..]);

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Context

impl Debug for Context

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

Formats the value using the given formatter.