cds 0.10.0

Collection of Optimized Data Structures
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

use crate::mem::{errors::ReservationError, SpareMemoryPolicy};
use ::alloc::alloc::{self, Layout};
use core::{mem, ptr};

pub const DOHAE: bool = true; // call `handle_allocation_error`
pub const NOHAE: bool = false; // do not call `handle_allocation_error`

#[inline]
pub fn alloc_buffer<T, const HAE: bool>(cap: usize) -> Result<*mut T, ReservationError> {
    unsafe {
        let new_layout = Layout::array::<T>(cap).map_err(|_| ReservationError::CapacityOverflow)?;
        if new_layout.size() > isize::MAX as usize {
            return Err(ReservationError::CapacityOverflow);
        }

        let tmp: *mut T = alloc::alloc(new_layout).cast();
        if tmp.is_null() {
            if HAE {
                alloc::handle_alloc_error(new_layout);
            }
            return Err(ReservationError::AllocError { layout: new_layout });
        }

        Ok(tmp)
    }
}

#[inline]
pub fn realloc_buffer<T, SM: SpareMemoryPolicy<T>, const HAE: bool>(
    p: *mut T,
    old_len: usize,
    old_cap: usize,
    new_cap: usize,
) -> Result<*mut T, ReservationError> {
    debug_assert!(new_cap > old_cap);

    let old_layout = unsafe {
        Layout::from_size_align_unchecked(mem::size_of::<T>() * old_cap, mem::align_of::<T>())
    };

    let new_layout = Layout::array::<T>(new_cap).map_err(|_| ReservationError::CapacityOverflow)?;

    if new_layout.size() > isize::MAX as usize {
        return Err(ReservationError::CapacityOverflow);
    }

    unsafe {
        if SM::NOOP {
            let tmp: *mut T = alloc::realloc(p.cast(), old_layout, new_layout.size()).cast();
            if tmp.is_null() {
                if HAE {
                    alloc::handle_alloc_error(new_layout);
                }
                return Err(ReservationError::AllocError { layout: new_layout });
            }
            Ok(tmp)
        } else {
            let tmp: *mut T = alloc::alloc(new_layout).cast();
            if tmp.is_null() {
                if HAE {
                    alloc::handle_alloc_error(new_layout);
                }
                return Err(ReservationError::AllocError { layout: new_layout });
            }
            // copy the old buffer including its spare memory
            ptr::copy_nonoverlapping(p, tmp, old_cap);
            SM::init(p, old_len);
            alloc::dealloc(p.cast(), old_layout);
            Ok(tmp)
        }
    }
}

#[inline]
pub fn dealloc_buffer<T>(p: *mut T, cap: usize) {
    unsafe {
        let layout =
            Layout::from_size_align_unchecked(mem::size_of::<T>() * cap, mem::align_of::<T>());
        alloc::dealloc(p.cast(), layout);
    }
}