Struct Context

pub struct Context { /* private fields */ }

Holds basic settings for compress operations.

Implementations

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 const 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 const 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 const fn shuffle(self, shuffle_mode: ShuffleMode) -> Self

Select which Shuffle filter to apply before compression.

pub const 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 Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Context

fn eq(&self, other: &Context) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Context

impl Eq for Context

impl StructuralPartialEq for Context