sector 0.1.21

A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines.
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

use core::{alloc::Layout, ptr::NonNull};

#[cfg(feature = "std")]
use std::alloc;

#[cfg(not(feature = "std"))]
extern crate alloc as no_std_alloc;
#[cfg(not(feature = "std"))]
use no_std_alloc::alloc;

use super::{Cap, Ptr};

/// **Trait `Resize<T>`**
///
/// Resizes the allocation to a specified capacity directly.
///
/// - `__resize` - Changes capacity to a given number of elements.
#[allow(dead_code)]
pub trait Resize<T>: Cap + Ptr<T> {
    /// Resizes the allocation to the specified capacity.
    ///
    /// # Arguments
    ///
    /// * `new_cap` - The desired new capacity.
    ///
    /// # Panics
    ///
    /// - Panics if the allocation size exceeds `isize::MAX`.
    fn __resize(&mut self, new_cap: usize) {
        let new_layout = Layout::array::<T>(new_cap).unwrap();
        assert!(
            new_layout.size() <= isize::MAX as usize,
            "Capacity overflow"
        );

        let new_ptr = if self.__cap() == 0 {
            unsafe { alloc::alloc(new_layout) }
        } else {
            let old_layout = Layout::array::<T>(self.__cap()).unwrap();
            let old_ptr = self.__ptr().as_ptr() as *mut u8;

            unsafe { alloc::realloc(old_ptr, old_layout, new_layout.size()) }
        };

        let new_ptr = match NonNull::new(new_ptr as *mut T) {
            Some(ptr) => ptr,
            None => alloc::handle_alloc_error(new_layout),
        };

        self.__cap_set(new_cap);
        self.__ptr_set(new_ptr);
    }
}