mid-compression 1.0.0

Compression utilities for the `middleware` protocol
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

use std::ptr;

use zstd_sys::{
    ZSTD_DCtx,
    ZSTD_createDCtx,
    ZSTD_decompressDCtx,
    ZSTD_freeDCtx,
    ZSTD_getDecompressedSize,
    ZSTD_isError,
};

use crate::{
    error,
    interface::IDecompressor,
};

/// ZStandard decompression context
pub struct ZStdDctx {
    ptr: ptr::NonNull<ZSTD_DCtx>,
}

// TODO: Implement precise error handling
impl IDecompressor for ZStdDctx {
    fn try_decompress(
        &mut self,
        buffer: &[u8],
        to: &mut Vec<u8>,
    ) -> Result<usize, error::DecompressError> {
        let result = unsafe {
            ZSTD_decompressDCtx(
                self.ptr.as_ptr(),
                to.as_ptr() as *mut _,
                to.capacity(),
                buffer.as_ptr() as *const _,
                buffer.len(),
            )
        };

        if unsafe { ZSTD_isError(result) } == 1 {
            crate::cold();
            Err(error::DecompressError::InsufficientBuffer)
        } else {
            unsafe { to.set_len(result) };
            Ok(result)
        }
    }

    fn try_decompressed_size(
        &self,
        of: &[u8],
    ) -> Result<usize, error::SizeRetrievalError> {
        let Ok(result) = unsafe {
            ZSTD_getDecompressedSize(of.as_ptr() as *const _, of.len())
        }.try_into() else {
            return Err(error::SizeRetrievalError::InvalidData);
        };

        if unsafe { ZSTD_isError(result) } == 1 {
            // TODO: see trait todo
            Err(error::SizeRetrievalError::InvalidData)
        } else {
            Ok(result)
        }
    }
}

impl ZStdDctx {
    /// Create ZStandard decompression context.
    ///
    /// # Panics
    ///
    /// - if underlying call to the `ZSTD_createDCtx()`
    ///   fails (returns NULL pointer)
    pub fn new() -> Self {
        Self::default()
    }
}

impl Default for ZStdDctx {
    fn default() -> Self {
        Self {
            ptr: ptr::NonNull::new(unsafe { ZSTD_createDCtx() })
                .expect("Failed to create ZStd decompression context"),
        }
    }
}

unsafe impl Send for ZStdDctx {}

impl Drop for ZStdDctx {
    fn drop(&mut self) {
        if unsafe { ZSTD_isError(ZSTD_freeDCtx(self.ptr.as_ptr())) } == 1 {
            panic!("Failed to deallocate ZStd decompression context");
        }
    }
}