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

//!Custom malloc implementation which uses Rust's allocator and provides common interface required by compression libraries
use core::ffi::{c_uint, c_void};

extern crate alloc;

use alloc::alloc::Layout;
pub use alloc::boxed::Box;
use core::{mem, ptr};

//Linux & win 32 bit are 8
#[cfg(not(any(target_os = "macos", all(windows, target_pointer_width = "64"))))]
const MIN_ALIGN: usize = 8;
//Mac and  win 64 bit are 16
#[cfg(any(target_os = "macos", all(windows, target_pointer_width = "64")))]
const MIN_ALIGN: usize = 16;

const LAYOUT_OFFSET: usize = mem::size_of::<usize>();

#[cold]
#[inline(never)]
fn unlikely_null() -> *mut c_void {
    ptr::null_mut()
}

#[inline]
///`malloc` impl with Rust allocator
pub unsafe extern "C" fn compu_malloc(size: usize) -> *mut c_void {
    if let Ok(layout) = Layout::from_size_align(size + LAYOUT_OFFSET, MIN_ALIGN) {
        let mem = alloc::alloc::alloc(layout);
        if !mem.is_null() {
            ptr::write(mem as *mut usize, size);
            return mem.add(LAYOUT_OFFSET) as _;
        }
    }

    unlikely_null()
}

#[inline]
///`free` impl with Rust allocator
pub unsafe extern "C" fn compu_free(mem: *mut c_void) {
    if !mem.is_null() {
        let mem = (mem as *mut u8).offset(-(LAYOUT_OFFSET as isize));
        let size = ptr::read(mem as *const usize);
        let layout = Layout::from_size_align_unchecked(size + LAYOUT_OFFSET, MIN_ALIGN);
        alloc::alloc::dealloc(mem, layout);
    }
}

#[allow(unused)]
///`malloc` alternative with Rust allocator
pub(crate) unsafe extern "C" fn compu_malloc_with_state(
    _: *mut c_void,
    size: usize,
) -> *mut c_void {
    compu_malloc(size)
}

#[allow(unused)]
///`alloc` alternative with Rust allocator
pub(crate) unsafe extern "C" fn compu_alloc(
    _: *mut c_void,
    items: c_uint,
    size: c_uint,
) -> *mut c_void {
    let size = match (items as usize).checked_mul(size as usize) {
        Some(0) | None => return unlikely_null(),
        Some(size) => size,
    };
    compu_malloc(size)
}

#[allow(unused)]
pub(crate) unsafe extern "C" fn compu_free_with_state(_: *mut c_void, mem: *mut c_void) {
    compu_free(mem)
}

#[cfg(feature = "brotli-rust")]
///Allocator implementation using Rust's global allocator
pub mod brotli_rust {
    extern crate alloc;

    use super::Box;
    use alloc::vec::Vec;

    ///Boxed slice wrapper
    pub struct BoxedSlice<T>(Box<[T]>);

    impl<T> Default for BoxedSlice<T> {
        #[inline(always)]
        fn default() -> Self {
            Self(Vec::new().into_boxed_slice())
        }
    }
    impl<T> brotli::SliceWrapper<T> for BoxedSlice<T> {
        #[inline(always)]
        fn slice(&self) -> &[T] {
            &self.0
        }
    }

    impl<T> brotli::SliceWrapperMut<T> for BoxedSlice<T> {
        #[inline(always)]
        fn slice_mut(&mut self) -> &mut [T] {
            &mut self.0
        }
    }

    #[derive(Copy, Clone, Default)]
    ///Default allocator
    pub struct BrotliAllocator;

    impl<T: Default> brotli::Allocator<T> for BrotliAllocator {
        type AllocatedMemory = BoxedSlice<T>;
        fn alloc_cell(&mut self, len: usize) -> Self::AllocatedMemory {
            let mut vec = Vec::with_capacity(len);
            for _ in 0..len {
                vec.push(Default::default());
            }
            BoxedSlice(vec.into_boxed_slice())
        }

        fn free_cell(&mut self, _data: Self::AllocatedMemory) {}
    }

    impl brotli::enc::BrotliAlloc for BrotliAllocator {}
}