compu 1.4.1

Rust Compression library with generic interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! `zlib-rs` wrapper

extern crate alloc;

use alloc::boxed::Box;

use core::{mem, ptr};

use super::zlib_common::ZlibMode;
use super::{Decode, Decoder, Interface};

mod sys {
    pub use zlib_rs::c_api::z_stream;
    pub use zlib_rs::InflateFlush;
    pub use zlib_rs::inflate::*;
    pub use zlib_rs::ReturnCode;
    pub use zlib_rs::ReturnCode::Ok as Z_OK;
    pub use zlib_rs::ReturnCode::StreamEnd as Z_STREAM_END;
    pub use zlib_rs::ReturnCode::BufError as Z_BUF_ERROR;
}

const DEFAULT_INFLATE: sys::InflateFlush = sys::InflateFlush::NoFlush;

static ZLIB_RUST: Interface = Interface {
    drop_fn,
    reset_fn,
    decode_fn,
    describe_error_fn,
};

#[repr(transparent)]
struct State {
    inner: sys::z_stream,
}

impl State {
    #[inline(always)]
    pub fn new() -> Self {
        let mut this = Self {
            inner: sys::z_stream {
                next_in: ptr::null_mut(),
                avail_in: 0,
                total_in: 0,
                next_out: ptr::null_mut(),
                avail_out: 0,
                total_out: 0,
                msg: ptr::null_mut(),
                state: ptr::null_mut(),
                zalloc: None,
                zfree: None,
                opaque: ptr::null_mut(),
                data_type: 0,
                adler: 0,
                reserved: 0,
            }
        };
        this.inner.configure_default_rust_allocator();
        this
    }

    #[inline(always)]
    pub fn reset(&mut self) -> bool {
        sys::reset(self.as_mut()) == sys::Z_OK
    }

    //z_stream has the same layout as DeflateStream,
    //but for some reason guy is doing some bullshit requiring to transmute it
    #[inline(always)]
    fn as_mut(&mut self) -> &mut sys::InflateStream<'_> {
        unsafe {
            mem::transmute(&mut self.inner)
        }
    }
}

impl Drop for State {
    #[inline(always)]
    fn drop(&mut self) {
        let _ = sys::end(self.as_mut());
    }
}

impl Interface {
    ///Creates decoder with `zlib-rust` interface
    ///
    ///Returns `None` if unable to initialize it (likely due to lack of memory)
    pub fn zlib_rust(mode: ZlibMode) -> Option<Decoder> {
        let mut instance = Box::new(State::new());
        let config = sys::InflateConfig {
            window_bits: mode.max_bits(),
        };
        let result = sys::init(&mut instance.inner, config);

        if result == sys::ReturnCode::Ok {
            let instance = ptr::NonNull::from(Box::leak(instance)).cast();
            Some(ZLIB_RUST.inner_decoder(instance))
        } else {
            None
        }
    }
}
#[inline]
unsafe fn decode_fn(state: ptr::NonNull<u8>, input: *const u8, input_remain: usize, output: *mut u8, output_remain: usize) -> Decode {
    internal_zlib_impl_decode!(state, input, input_remain, output, output_remain)
}

#[inline]
fn reset_fn(state: ptr::NonNull<u8>) -> Option<ptr::NonNull<u8>> {
    let result = unsafe {
        (*(state.as_ptr() as *mut State)).reset()
    };
    if result {
        Some(state)
    } else {
        None
    }
}

#[inline]
fn drop_fn(data: ptr::NonNull<u8>) {
    unsafe {
        drop(Box::from_raw(data.as_ptr() as *mut State));
    }
}

#[inline]
fn describe_error_fn(code: i32) -> Option<&'static str> {
    match sys::ReturnCode::try_from_c_int(code as _) {
        Some(sys::ReturnCode::Ok) => Some("ok"),
        Some(sys::ReturnCode::StreamEnd) => Some("stream end"),
        Some(sys::ReturnCode::NeedDict) => Some("need dictionary"),
        Some(sys::ReturnCode::ErrNo) => Some("file error"),
        Some(sys::ReturnCode::StreamError) => Some("stream error"),
        Some(sys::ReturnCode::DataError) => Some("data error"),
        Some(sys::ReturnCode::MemError) => Some("insufficient memory"),
        Some(sys::ReturnCode::BufError) => Some("buffer error"),
        Some(sys::ReturnCode::VersionError) => Some("incompatible version"),
        _ => Some("impossible error"),
    }
}