Manual bindings (Windows and Clang aren't very good friends), and getting rid of anyhow

[?]

Dec 6, 2020, 9:38 PM

HELRYMZKHZW4S2IEYXA4IE7VOYYL7FH6TVHGFHJ4J3KRBBLHPQPAC

Dependencies

[2] UPRY2FEL Remove bindgen dependency
[3] IH334Q5A Reboot

Change contents

replacement in src/lib.rs at line 11

[3.241472]→[2.32:72](∅→∅)

pub fn out_size() -> bindings::size_t {

[3.241472]

[3.241502]

pub fn out_size() -> size_t {
replacement in src/lib.rs at line 17

[3.241609]→[3.241609:241646](∅→∅)

p: *mut ZSTD_seekable_CStream_s,

[3.241609]

[3.241646]

p: *mut ZSTD_seekable_CStream,
replacement in src/lib.rs at line 47

[3.242230]→[2.73:101](∅→∅)

ZSTD(bindings::size_t),

[3.242230]

[3.242248]

ZSTD(size_t),
Io(#[from] std::io::Error),
edit in src/lib.rs at line 55

[3.242425]

[3.242425]

Error::Io(ref e) => e.fmt(fmt),
replacement in src/lib.rs at line 127

[3.244220]→[2.102:127](∅→∅)

n: bindings::size_t,

[3.244220]

[3.244235]

n: size_t,
replacement in src/lib.rs at line 175

[3.246285]→[2.128:183](∅→∅)

size: input.len() as bindings::size_t,

[3.246285]

[3.246330]

size: input.len() as size_t,
replacement in src/lib.rs at line 180

[3.246472]→[2.184:240](∅→∅)

size: output.len() as bindings::size_t,

[3.246472]

[3.246518]

size: output.len() as size_t,
replacement in src/lib.rs at line 196

[3.247100]→[2.241:297](∅→∅)

size: output.len() as bindings::size_t,

[3.247100]

[3.247146]

size: output.len() as size_t,
replacement in src/lib.rs at line 240

[3.248653]→[2.298:353](∅→∅)

size: input.len() as bindings::size_t,

[3.248653]

[3.248698]

size: input.len() as size_t,
replacement in src/lib.rs at line 245

[3.248840]→[2.354:410](∅→∅)

size: output.len() as bindings::size_t,

[3.248840]

[3.248886]

size: output.len() as size_t,
replacement in src/lib.rs at line 262

[3.249375]→[2.411:466](∅→∅)

size: input.len() as bindings::size_t,

[3.249375]

[3.249420]

size: input.len() as size_t,
replacement in src/lib.rs at line 267

[3.249562]→[2.467:523](∅→∅)

size: output.len() as bindings::size_t,

[3.249562]

[3.249608]

size: output.len() as size_t,
replacement in src/lib.rs at line 270

[3.249647]→[2.524:620](∅→∅)

let result = ZSTD_compressStream2(self.p, &mut output, &mut input, op as EnumType);

[3.249647]

[3.249741]

let result = ZSTD_compressStream2(self.p, &mut output, &mut input, op as ZSTD_EndDirective);
replacement in src/lib.rs at line 279

[3.250035]→[2.621:677](∅→∅)

size: output.len() as bindings::size_t,

[3.250035]

[3.250081]

size: output.len() as size_t,
replacement in src/lib.rs at line 292

[3.250523]→[2.678:734](∅→∅)

size: output.len() as bindings::size_t,

[3.250523]

[3.250569]

size: output.len() as size_t,
edit in src/lib.rs at line 304

[2.736]→[2.736:815](∅→∅),[2.815]→[3.250830:250831](∅→∅),[3.250830]→[3.250830:250831](∅→∅)

#[cfg(windows)]
type EnumType = i32;
#[cfg(not(windows))]
type EnumType = u32;
replacement in src/lib.rs at line 342

[3.251583]→[2.969:1024](∅→∅)

size: input.len() as bindings::size_t,

[3.251583]

[3.251628]

size: input.len() as size_t,
replacement in src/lib.rs at line 347

[3.251770]→[2.1025:1081](∅→∅)

size: output.len() as bindings::size_t,

[3.251770]

[3.251816]

size: output.len() as size_t,
replacement in src/lib.rs at line 365

[3.252330]→[2.1082:1191](∅→∅)

ZSTD_seekable_initBuff(p, input.as_ptr() as *const c_void, input.len() as bindings::size_t);

[3.252330]

[3.252429]

ZSTD_seekable_initBuff(p, input.as_ptr() as *const c_void, input.len() as size_t);
replacement in src/lib.rs at line 447

[3.255331]→[2.1192:1239](∅→∅)

out.len() as bindings::size_t,

[3.255331]

[3.255368]

out.len() as size_t,
replacement in src/lib.rs at line 462

[3.255768]→[2.1240:1328](∅→∅)

pub fn get_frame_compressed_offset(&self, frame_index: usize) -> bindings::size_t {

[3.255768]

[3.255846]

pub fn get_frame_compressed_offset(&self, frame_index: usize) -> c_ulonglong {
replacement in src/lib.rs at line 483

[3.256985]→[2.1329:1377](∅→∅)

dest.len() as bindings::size_t,

[3.256985]

[3.257023]

dest.len() as size_t,
replacement in src/lib.rs at line 573

[3.259089]→[2.1378:1442](∅→∅)

src_size: bindings::size_t,
dst_size: bindings::size_t,

[3.259089]

[3.259133]

src_size: size_t,
dst_size: size_t,
replacement in src/lib.rs at line 591

[3.259421]→[2.1443:1474](∅→∅)

src_len: bindings::size_t,

[3.259421]

[3.259442]

src_len: size_t,
replacement in src/lib.rs at line 599

[3.259681]→[2.1475:1518](∅→∅)

dst.len() as bindings::size_t,

[3.259681]

[3.259714]

dst.len() as size_t,
replacement in src/lib.rs at line 655

[3.261169]→[2.1519:1546](∅→∅)

len: bindings::size_t,

[3.261169]

[3.261186]

len: size_t,
replacement in src/lib.rs at line 665

[3.261353]→[3.261353:261386](∅→∅)

) -> Result<(), anyhow::Error> {

[3.261353]

[3.261386]

) -> Result<(), Error> {
replacement in src/lib.rs at line 678

[3.261774]→[2.1547:1597](∅→∅)

len: chunk.len() as bindings::size_t,

[3.261774]

[3.261814]

len: chunk.len() as size_t,
replacement in src/bindings.rs at line 1

[2.1612]→[2.1613:1666](∅→∅)

/* automatically generated by rust-bindgen 0.55.1 */

[2.1612]

[2.1666]

use libc::{c_void, size_t, c_int, c_uint, c_char, c_ulonglong};
edit in src/bindings.rs at line 3

[2.1667]→[2.1667:1798](∅→∅)

pub type size_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
replacement in src/bindings.rs at line 5

[2.1839]→[2.1839:1863](∅→∅)

pub struct _IO_marker {

[2.1839]

[2.1863]

pub struct ZSTD_seekable_CStream {
edit in src/bindings.rs at line 8

[2.1887]

[2.1887]
replacement in src/bindings.rs at line 11

[2.1928]→[2.1928:1953](∅→∅)

pub struct _IO_codecvt {

[2.1928]

[2.1953]

pub struct ZSTD_CStream {
edit in src/bindings.rs at line 14

[2.1977]

[2.1977]
replacement in src/bindings.rs at line 17

[2.2018]→[2.2018:2045](∅→∅)

pub struct _IO_wide_data {

[2.2018]

[2.2045]

pub struct ZSTD_frameLog {
edit in src/bindings.rs at line 19

[2.2067]→[2.2067:2947](∅→∅)

}
pub type _IO_lock_t = ::std::os::raw::c_void;
extern "C" {
#[doc = " Simple API"]
#[doc = " Compresses `src` content as a single zstd compressed frame into already allocated `dst`."]
#[doc = " Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`."]
#[doc = " @return : compressed size written into `dst` (<= `dstCapacity),"]
#[doc = " or an error code if it fails (which can be tested using ZSTD_isError())."]
pub fn ZSTD_compress(
dst: *mut ::std::os::raw::c_void,
dstCapacity: size_t,
src: *const ::std::os::raw::c_void,
srcSize: size_t,
compressionLevel: ::std::os::raw::c_int,
) -> size_t;
}
extern "C" {
pub fn ZSTD_isError(code: size_t) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn ZSTD_getErrorName(code: size_t) -> *const ::std::os::raw::c_char;
edit in src/bindings.rs at line 20

[2.2949]

[2.2949]
replacement in src/bindings.rs at line 23

[2.2990]→[2.2990:3015](∅→∅)

pub struct ZSTD_CCtx_s {

[2.2990]

[2.3015]

pub struct ZSTD_seekable {
replacement in src/bindings.rs at line 26

[2.3039]→[2.3039:3103](∅→∅)

#[doc = " Explicit context"]
pub type ZSTD_CCtx = ZSTD_CCtx_s;

[2.3039]

[2.3103]
replacement in src/bindings.rs at line 29

[2.3144]→[2.3144:3441](∅→∅)

pub struct ZSTD_DCtx_s {
_unused: [u8; 0],
}
pub type ZSTD_DCtx = ZSTD_DCtx_s;
#[doc = " Streaming"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_inBuffer_s {
#[doc = "< start of input buffer"]
pub src: *const ::std::os::raw::c_void,
#[doc = "< size of input buffer"]

[2.3144]

[2.3441]

pub struct ZSTD_inBuffer {
pub src: *const c_void,
edit in src/bindings.rs at line 32

[2.3463]→[2.3463:3558](∅→∅)

#[doc = "< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size"]
replacement in src/bindings.rs at line 34

[2.3581]→[2.3581:3623](∅→∅)

pub type ZSTD_inBuffer = ZSTD_inBuffer_s;

[2.3581]

[2.3623]
replacement in src/bindings.rs at line 37

[2.3664]→[2.3664:3815](∅→∅)

pub struct ZSTD_outBuffer_s {
#[doc = "< start of output buffer"]
pub dst: *mut ::std::os::raw::c_void,
#[doc = "< size of output buffer"]

[2.3664]

[2.3815]

pub struct ZSTD_outBuffer {
pub dst: *mut c_void,
edit in src/bindings.rs at line 40

[2.3837]→[2.3837:3932](∅→∅)

#[doc = "< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size"]
edit in src/bindings.rs at line 41

[2.3953]→[2.3953:7350](∅→∅)

}
pub type ZSTD_outBuffer = ZSTD_outBuffer_s;
pub type ZSTD_CStream = ZSTD_CCtx;
extern "C" {
pub fn ZSTD_createCStream() -> *mut ZSTD_CStream;
}
extern "C" {
pub fn ZSTD_freeCStream(zcs: *mut ZSTD_CStream) -> size_t;
}
pub type ZSTD_EndDirective = ::std::os::raw::c_uint;
extern "C" {
#[doc = " ZSTD_compressStream2() :"]
#[doc = " Behaves about the same as ZSTD_compressStream, with additional control on end directive."]
#[doc = " - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()"]
#[doc = " - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)"]
#[doc = " - output->pos must be <= dstCapacity, input->pos must be <= srcSize"]
#[doc = " - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit."]
#[doc = " - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller."]
#[doc = " - When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush whatever is available,"]
#[doc = " and then immediately returns, just indicating that there is some data remaining to be flushed."]
#[doc = " The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte."]
#[doc = " - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking."]
#[doc = " - @return provides a minimum amount of data remaining to be flushed from internal buffers"]
#[doc = " or an error code, which can be tested using ZSTD_isError()."]
#[doc = " if @return != 0, flush is not fully completed, there is still some data left within internal buffers."]
#[doc = " This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers."]
#[doc = " For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed."]
#[doc = " - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),"]
#[doc = " only ZSTD_e_end or ZSTD_e_flush operations are allowed."]
#[doc = " Before starting a new compression job, or changing compression parameters,"]
#[doc = " it is required to fully flush internal buffers."]
pub fn ZSTD_compressStream2(
cctx: *mut ZSTD_CCtx,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
endOp: ZSTD_EndDirective,
) -> size_t;
}
extern "C" {
pub fn ZSTD_CStreamInSize() -> size_t;
}
extern "C" {
pub fn ZSTD_CStreamOutSize() -> size_t;
}
extern "C" {
#[doc = " Equivalent to:"]
#[doc = ""]
#[doc = " ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);"]
#[doc = " ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)"]
#[doc = " ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);"]
pub fn ZSTD_initCStream(
zcs: *mut ZSTD_CStream,
compressionLevel: ::std::os::raw::c_int,
) -> size_t;
replacement in src/bindings.rs at line 42

[2.7352]→[2.7352:8772](∅→∅)

extern "C" {
#[doc = " Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue)."]
#[doc = " NOTE: The return value is different. ZSTD_compressStream() returns a hint for"]
#[doc = " the next read size (if non-zero and not an error). ZSTD_compressStream2()"]
#[doc = " returns the minimum nb of bytes left to flush (if non-zero and not an error)."]
pub fn ZSTD_compressStream(
zcs: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
}
extern "C" {
#[doc = " Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush)."]
pub fn ZSTD_flushStream(zcs: *mut ZSTD_CStream, output: *mut ZSTD_outBuffer) -> size_t;
}
extern "C" {
#[doc = " Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end)."]
pub fn ZSTD_endStream(zcs: *mut ZSTD_CStream, output: *mut ZSTD_outBuffer) -> size_t;
}
pub type ZSTD_DStream = ZSTD_DCtx;
extern "C" {
pub fn ZSTD_createDStream() -> *mut ZSTD_DStream;
}
extern "C" {
pub fn ZSTD_freeDStream(zds: *mut ZSTD_DStream) -> size_t;
}
extern "C" {
pub fn ZSTD_initDStream(zds: *mut ZSTD_DStream) -> size_t;
}
extern "C" {
pub fn ZSTD_decompressStream(
zds: *mut ZSTD_DStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
}
extern "C" {
pub fn ZSTD_DStreamOutSize() -> size_t;
}

[2.7352]

[2.8772]
replacement in src/bindings.rs at line 45

[2.8813]→[2.8813:8850](∅→∅)

pub struct ZSTD_seekable_CStream_s {

[2.8813]

[2.8850]

pub struct ZSTD_DStream {
replacement in src/bindings.rs at line 48

[2.8874]→[2.8874:8932](∅→∅)

pub type ZSTD_seekable_CStream = ZSTD_seekable_CStream_s;

[2.8874]

[2.8932]

pub type ZSTD_seekable_read = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_void,
n: size_t,
) -> ::std::os::raw::c_int,
>;
pub type ZSTD_seekable_seek = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
offset: ::std::os::raw::c_longlong,
origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
replacement in src/bindings.rs at line 65

[2.8973]→[2.8973:9024](∅→∅)

pub struct ZSTD_seekable_s {
_unused: [u8; 0],

[2.8973]

[2.9024]

pub struct ZSTD_seekable_customFile {
pub opaque: *mut ::std::os::raw::c_void,
pub read: ZSTD_seekable_read,
pub seek: ZSTD_seekable_seek,
replacement in src/bindings.rs at line 70

[2.9026]→[2.9026:9068](∅→∅)

pub type ZSTD_seekable = ZSTD_seekable_s;

[2.9026]

[2.9068]

pub type ZSTD_EndDirective = c_uint;
edit in src/bindings.rs at line 74

[2.9081]

[2.9081]

pub fn ZSTD_compress(
dst: *mut c_void,
dstCapacity: size_t,
src: *const c_void,
srcSize: size_t,
compressionLevel: c_int,
) -> size_t;
pub fn ZSTD_isError(code: size_t) -> c_uint;
pub fn ZSTD_getErrorName(code: size_t) -> *const c_char;
pub fn ZSTD_DStreamOutSize() -> size_t;
pub fn ZSTD_createCStream() -> *mut ZSTD_CStream;
pub fn ZSTD_freeCStream(zcs: *mut ZSTD_CStream) -> size_t;
edit in src/bindings.rs at line 87

[2.9153]→[2.9153:9168](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 88

[2.9249]→[2.9249:9264](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 90

[2.9343]→[2.9343:9483](∅→∅)

compressionLevel: ::std::os::raw::c_int,
checksumFlag: ::std::os::raw::c_int,
maxFrameSize: ::std::os::raw::c_uint,

[2.9343]

[2.9483]

compressionLevel: c_int,
checksumFlag: c_int,
maxFrameSize: c_uint,
edit in src/bindings.rs at line 94

[2.9500]→[2.9500:9515](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 99

[2.9686]→[2.9686:9701](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 103

[2.9832]→[2.9832:10098](∅→∅)

}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_frameLog_s {
_unused: [u8; 0],
}
pub type ZSTD_frameLog = ZSTD_frameLog_s;
extern "C" {
pub fn ZSTD_seekable_createFrameLog(checksumFlag: ::std::os::raw::c_int) -> *mut ZSTD_frameLog;
}
extern "C" {

[2.9832]

[2.10098]

pub fn ZSTD_seekable_createFrameLog(checksumFlag: c_int) -> *mut ZSTD_frameLog;
edit in src/bindings.rs at line 105

[2.10171]→[2.10171:10186](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 107

[2.10253]→[2.10253:10393](∅→∅)

compressedSize: ::std::os::raw::c_uint,
decompressedSize: ::std::os::raw::c_uint,
checksum: ::std::os::raw::c_uint,

[2.10253]

[2.10393]

compressedSize: c_uint,
decompressedSize: c_uint,
checksum: c_uint,
edit in src/bindings.rs at line 111

[2.10410]→[2.10410:10425](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 115

[2.10552]→[2.10552:10567](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 116

[2.10624]→[2.10624:10639](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 117

[2.10704]→[2.10704:10719](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 119

[2.10786]→[2.10786:10830](∅→∅)

src: *const ::std::os::raw::c_void,

[2.10786]

[2.10830]

src: *const c_void,
edit in src/bindings.rs at line 122

[2.10872]→[2.10872:10887](∅→∅)

}
extern "C" {
edit in src/bindings.rs at line 123

[2.10978]→[2.10978:10993](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 125

[2.11062]→[2.11062:11104](∅→∅)

dst: *mut ::std::os::raw::c_void,

[2.11062]

[2.11104]

dst: *mut c_void,
replacement in src/bindings.rs at line 127

[2.11129]→[2.11129:11174](∅→∅)

offset: ::std::os::raw::c_ulonglong,

[2.11129]

[2.11174]

offset: c_ulonglong,
edit in src/bindings.rs at line 129

[2.11191]→[2.11191:11206](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 131

[2.11280]→[2.11280:11322](∅→∅)

dst: *mut ::std::os::raw::c_void,

[2.11280]

[2.11322]

dst: *mut c_void,
replacement in src/bindings.rs at line 133

[2.11347]→[2.11347:11391](∅→∅)

frameIndex: ::std::os::raw::c_uint,

[2.11347]

[2.11391]

frameIndex: c_uint,
replacement in src/bindings.rs at line 135

[2.11408]→[2.11408:11527](∅→∅)

}
extern "C" {
pub fn ZSTD_seekable_getNumFrames(zs: *mut ZSTD_seekable) -> ::std::os::raw::c_uint;
}
extern "C" {

[2.11408]

[2.11527]

pub fn ZSTD_seekable_getNumFrames(zs: *mut ZSTD_seekable) -> c_uint;
replacement in src/bindings.rs at line 138

[2.11610]→[2.11610:11707](∅→∅)

frameIndex: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {

[2.11610]

[2.11707]

frameIndex: c_uint,
) -> c_ulonglong;
replacement in src/bindings.rs at line 142

[2.11792]→[2.11792:11889](∅→∅)

frameIndex: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {

[2.11792]

[2.11889]

frameIndex: c_uint,
) -> c_ulonglong;
replacement in src/bindings.rs at line 146

[2.11970]→[2.11970:12014](∅→∅)

frameIndex: ::std::os::raw::c_uint,

[2.11970]

[2.12014]

frameIndex: c_uint,
edit in src/bindings.rs at line 148

[2.12031]→[2.12031:12046](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 150

[2.12129]→[2.12129:12173](∅→∅)

frameIndex: ::std::os::raw::c_uint,

[2.12129]

[2.12173]

frameIndex: c_uint,
edit in src/bindings.rs at line 152

[2.12190]→[2.12190:12205](∅→∅)

}
extern "C" {
replacement in src/bindings.rs at line 154

[2.12282]→[2.12282:12360](∅→∅)

offset: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_uint;

[2.12282]

[2.12360]

offset: c_ulonglong,
) -> c_uint;
pub fn ZSTD_compressStream2(
cctx: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
endOp: ZSTD_EndDirective,
) -> size_t;
pub fn ZSTD_CStreamInSize() -> size_t;
pub fn ZSTD_CStreamOutSize() -> size_t;
pub fn ZSTD_compressStream(
zcs: *mut ZSTD_CStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
pub fn ZSTD_flushStream(zcs: *mut ZSTD_CStream, output: *mut ZSTD_outBuffer) -> size_t;
pub fn ZSTD_endStream(zcs: *mut ZSTD_CStream, output: *mut ZSTD_outBuffer) -> size_t;

pub fn ZSTD_createDStream() -> *mut ZSTD_DStream;
pub fn ZSTD_freeDStream(zds: *mut ZSTD_DStream) -> size_t;
pub fn ZSTD_initDStream(zds: *mut ZSTD_DStream) -> size_t;
pub fn ZSTD_decompressStream(
zds: *mut ZSTD_DStream,
output: *mut ZSTD_outBuffer,
input: *mut ZSTD_inBuffer,
) -> size_t;
pub fn ZSTD_seekable_initAdvanced(
zs: *mut ZSTD_seekable,
src: ZSTD_seekable_customFile,
) -> size_t;
pub fn ZSTD_initCStream(
zcs: *mut ZSTD_CStream,
compressionLevel: c_int,
) -> size_t;
replacement in src/bindings.rs at line 189

[2.12362]→[2.12362:12827](∅→∅)

pub type ZSTD_seekable_read = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_void,
n: size_t,
) -> ::std::os::raw::c_int,
>;
pub type ZSTD_seekable_seek = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
offset: ::std::os::raw::c_longlong,
origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;

[2.12362]

[2.12827]

/*
#[doc = " Explicit context"]
pub type ZSTD_CCtx = ZSTD_CCtx_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ZSTD_DCtx_s {
_unused: [u8; 0],
}
pub type ZSTD_DCtx = ZSTD_DCtx_s;
#[doc = " Streaming"]
pub type ZSTD_outBuffer = ZSTD_outBuffer_s;
pub type ZSTD_CStream = ZSTD_CCtx;
extern "C" {
}
pub type ZSTD_DStream = ZSTD_DCtx;
extern "C" {
}
extern "C" {
}
replacement in src/bindings.rs at line 210

[2.12868]→[2.12868:13019](∅→∅)

pub struct ZSTD_seekable_customFile {
pub opaque: *mut ::std::os::raw::c_void,
pub read: ZSTD_seekable_read,
pub seek: ZSTD_seekable_seek,

[2.12868]

[2.13019]

pub type ZSTD_seekable = ZSTD_seekable_s;
extern "C" {
replacement in src/bindings.rs at line 214

[2.13034]→[2.13034:13161](∅→∅)

pub fn ZSTD_seekable_initAdvanced(
zs: *mut ZSTD_seekable,
src: ZSTD_seekable_customFile,
) -> size_t;

[2.13034]

[2.13161]

}
extern "C" {
edit in src/bindings.rs at line 217

[2.13163]

*/
replacement in Cargo.toml at line 4

[3.269755]→[2.13301:13319](∅→∅)

version = "0.1.3"

[3.269755]

[3.269773]

version = "0.1.5"
edit in Cargo.toml at line 28

[3.270405]→[3.270405:270420](∅→∅)

anyhow = "1.0"