#![deny(missing_docs)]
#![cfg_attr(feature = "doc-cfg", feature(doc_cfg))]
pub use zstd_safe;
pub mod bulk;
pub mod dict;
#[macro_use]
pub mod stream;
use std::io;
pub use zstd_safe::CLEVEL_DEFAULT as DEFAULT_COMPRESSION_LEVEL;
pub fn compression_level_range(
) -> std::ops::RangeInclusive<zstd_safe::CompressionLevel> {
zstd_safe::min_c_level()..=zstd_safe::max_c_level()
}
pub use zstd_safe::compress_bound;
#[doc(no_inline)]
pub use crate::stream::{
compress_file, compress_file_into, compress_sized, compress_sized_into,
decode_all, decompressed_size, encode_all, Decoder, Encoder,
};
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Error {
code: zstd_safe::ErrorCode,
}
impl Error {
pub fn is(&self, kind: zstd_safe::zstd_sys::ZSTD_ErrorCode) -> bool {
zstd_safe::is_error_kind(self.code, kind)
}
}
impl std::fmt::Debug for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_tuple("Error")
.field(&zstd_safe::get_error_name(self.code))
.finish()
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(zstd_safe::get_error_name(self.code))
}
}
impl std::error::Error for Error {}
fn map_error_code(code: usize) -> io::Error {
io::Error::new(io::ErrorKind::Other, Error { code })
}
fn vec_with_capacity(capacity: usize) -> io::Result<Vec<u8>> {
let mut vec = Vec::new();
vec.try_reserve_exact(capacity).map_err(|_| {
io::Error::new(
io::ErrorKind::OutOfMemory,
format!("could not allocate a buffer of {} bytes", capacity),
)
})?;
Ok(vec)
}
#[cfg(test)]
fn test_cycle<F, G>(data: &[u8], f: F, g: G)
where
F: Fn(&[u8]) -> Vec<u8>,
G: Fn(&[u8]) -> Vec<u8>,
{
let mid = f(data);
let end = g(&mid);
assert_eq!(data, &end[..]);
}
#[cfg(test)]
fn test_cycle_unwrap<F, G>(data: &[u8], f: F, g: G)
where
F: Fn(&[u8]) -> io::Result<Vec<u8>>,
G: Fn(&[u8]) -> io::Result<Vec<u8>>,
{
test_cycle(data, |data| f(data).unwrap(), |data| g(data).unwrap())
}
#[cfg(all(test, feature = "zstdmt"))]
fn test_words(len: usize, seed: u64) -> Vec<u8> {
let words: [&[u8]; 6] =
[b"lorem ", b"ipsum ", b"dolor ", b"sit ", b"amet ", b"elit "];
let mut x = seed | 1;
let mut data = Vec::with_capacity(len + 8);
while data.len() < len {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
data.extend_from_slice(words[(x % 6) as usize]);
}
data.truncate(len);
data
}
#[test]
fn default_compression_level_in_range() {
assert!(compression_level_range().contains(&DEFAULT_COMPRESSION_LEVEL));
}