Struct bz_stream 

#[repr(C)]
pub struct bz_stream {
    pub next_in: *const c_char,
    pub avail_in: c_uint,
    pub total_in_lo32: c_uint,
    pub total_in_hi32: c_uint,
    pub next_out: *mut c_char,
    pub avail_out: c_uint,
    pub total_out_lo32: c_uint,
    pub total_out_hi32: c_uint,
    pub state: *mut c_void,
    pub bzalloc: Option<unsafe extern "C" fn(*mut c_void, c_int, c_int) -> *mut c_void>,
    pub bzfree: Option<unsafe extern "C" fn(*mut c_void, *mut c_void)>,
    pub opaque: *mut c_void,
}

The current stream state.

Custom allocators

The low-level API supports passing in a custom allocator as part of the bz_stream:

struct bz_stream {
    // ...
    pub bzalloc: Option<unsafe extern "C" fn(_: *mut c_void, _: c_int, _: c_int) -> *mut c_void>,
    pub bzfree: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void)>,
    pub opaque: *mut c_void,
}

When these fields are None (or NULL in C), the initialization functions will try to put in a default allocator, based on feature flags:

• "rust-allocator" uses the rust global allocator
• "c-allocator" uses an allocator based on malloc and free

When both configured, "rust-allocator" is preferred. When no default allocator is configured, the high-level interface will return a BZ_CONFIG_ERROR. The low-level interface (the functions that take a bz_stream as their argument) return a BZ_PARAM_ERROR, unless the user set the bzalloc and bzfree fields.

When custom bzalloc and bzfree functions are given, they must adhere to the following contract to be safe:

• a call bzalloc(opaque, n, m) must return a pointer p to n * m bytes of memory, or NULL if out of memory
• a call bzfree(opaque, p) must free that memory

The strm.opaque value is passed to as the first argument to all calls to bzalloc and bzfree, but is otherwise ignored by the library.

Fields

next_in: *const c_char

avail_in: c_uint

total_in_lo32: c_uint

total_in_hi32: c_uint

next_out: *mut c_char

avail_out: c_uint

total_out_lo32: c_uint

total_out_hi32: c_uint

state: *mut c_void

bzalloc: Option<unsafe extern "C" fn(*mut c_void, c_int, c_int) -> *mut c_void>

bzfree: Option<unsafe extern "C" fn(*mut c_void, *mut c_void)>

opaque: *mut c_void

Implementations

impl bz_stream

pub const fn zeroed() -> Self