lzzzz 2.0.0

Full-featured liblz4 binding for Rust.
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

use super::{FrameInfo, Preferences};
use std::os::raw::{c_uint, c_void};

#[allow(non_camel_case_types)]
type size_t = usize;

#[repr(C)]
pub struct LZ4FCompressionCtx {
    _private: [u8; 0],
}

#[repr(C)]
pub struct LZ4FDecompressionCtx {
    _private: [u8; 0],
}

#[repr(C)]
pub struct LZ4FCompressionDict {
    _private: [u8; 0],
}

#[derive(Debug, Default, Copy, Clone)]
#[repr(C)]
pub struct LZ4FCompressionOptions {
    pub stable_src: c_uint,
    pub _reserved: [c_uint; 3],
}

impl LZ4FCompressionOptions {
    pub fn stable(stable: bool) -> Self {
        Self {
            stable_src: u32::from(stable),
            ..Default::default()
        }
    }
}

#[derive(Debug, Default, Copy, Clone)]
#[repr(C)]
pub struct LZ4FDecompressionOptions {
    pub stable_dst: c_uint,
    pub _reserved: [c_uint; 3],
}

impl LZ4FDecompressionOptions {
    pub fn stable(stable: bool) -> Self {
        Self {
            stable_dst: u32::from(stable),
            ..Default::default()
        }
    }
}

extern "C" {
    pub fn LZ4F_getVersion() -> c_uint;
    pub fn LZ4F_compressBound(src_size: size_t, prefs: *const Preferences) -> size_t;
    pub fn LZ4F_compressFrameBound(src_size: size_t, prefs: *const Preferences) -> size_t;
    pub fn LZ4F_compressFrame(
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        src_buffer: *const c_void,
        src_size: size_t,
        prefs: *const Preferences,
    ) -> size_t;
    pub fn LZ4F_decompress_usingDict(
        ctx: *mut LZ4FDecompressionCtx,
        dst_buffer: *mut c_void,
        dst_size_ptr: *mut size_t,
        src_buffer: *const c_void,
        src_size_ptr: *mut size_t,
        dict: *const c_void,
        dict_size: size_t,
        opt: *const LZ4FDecompressionOptions,
    ) -> size_t;
    pub fn LZ4F_createCDict(
        dict_buffer: *const c_void,
        dict_size: size_t,
    ) -> *mut LZ4FCompressionDict;
    pub fn LZ4F_freeCDict(dict: *mut LZ4FCompressionDict);

    pub fn LZ4F_createCompressionContext(
        ctx: *mut *mut LZ4FCompressionCtx,
        version: c_uint,
    ) -> size_t;
    pub fn LZ4F_freeCompressionContext(ctx: *mut LZ4FCompressionCtx);
    pub fn LZ4F_compressBegin(
        ctx: *mut LZ4FCompressionCtx,
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        prefs: *const Preferences,
    ) -> size_t;
    pub fn LZ4F_compressBegin_usingCDict(
        ctx: *mut LZ4FCompressionCtx,
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        dist: *const LZ4FCompressionDict,
        prefs: *const Preferences,
    ) -> size_t;
    pub fn LZ4F_compressUpdate(
        ctx: *mut LZ4FCompressionCtx,
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        src_buffer: *const c_void,
        src_size: size_t,
        opt: *const LZ4FCompressionOptions,
    ) -> size_t;
    pub fn LZ4F_flush(
        ctx: *mut LZ4FCompressionCtx,
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        opt: *const LZ4FCompressionOptions,
    ) -> size_t;
    pub fn LZ4F_compressEnd(
        ctx: *mut LZ4FCompressionCtx,
        dst_buffer: *mut c_void,
        dst_capacity: size_t,
        opt: *const LZ4FCompressionOptions,
    ) -> size_t;
    pub fn LZ4F_createDecompressionContext(
        ctx: *mut *mut LZ4FDecompressionCtx,
        version: c_uint,
    ) -> size_t;
    pub fn LZ4F_freeDecompressionContext(ctx: *mut LZ4FDecompressionCtx) -> size_t;
    pub fn LZ4F_resetDecompressionContext(ctx: *mut LZ4FDecompressionCtx);
    pub fn LZ4F_headerSize(src: *const c_void, src_size: size_t) -> size_t;
    pub fn LZ4F_getFrameInfo(
        ctx: *mut LZ4FDecompressionCtx,
        frame_info_ptr: *mut FrameInfo,
        src_buffer: *const c_void,
        src_size_ptr: *mut size_t,
    ) -> size_t;
}