devela 0.28.0

A development substrate of coherence.
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

// devela::sys::mem::arena::arena::internals
//
//! Defines [`__Arena`].
//!
//! This module groups all the arena-related safety feature-gates.
//

use crate::{MaybeByte, Slice};

#[doc(hidden)]
/// Internal arena methods.
///
/// Abstracts away over safe `u8` or unsafe `MaybeUninit<u8>` representations.
///
/// # Features
/// Uses the `unsafe_array` and `unsafe_slice` features.
#[derive(Debug)]
pub struct __Arena<const CAP: usize>;

#[rustfmt::skip]
impl<const CAP: usize> __Arena<CAP> {
    ///
    #[inline(always)]
    pub const fn new_array<const N: usize>() -> [MaybeByte; N] {
        cfg_select! { all(feature = "unsafe_array", not(feature = "safe_mem")) => {
            [MaybeByte::uninit(); N]
        } _ => {
            [0_u8; N]
        }}
    }
    ///
    #[inline(always)]
    pub const fn read_byte(data: &[MaybeByte], i: usize) -> u8 {
        cfg_select! { all(feature = "unsafe_array", not(feature = "safe_mem")) => {
            unsafe { data[i].assume_init_read() }
        } _ => {
            data[i]
        }}
    }
    ///
    #[inline(always)]
    pub const fn read_byte_mut(data: &mut [MaybeByte], i: usize) -> &mut u8 {
        cfg_select! { all(feature = "unsafe_array", not(feature = "safe_mem")) => {
            unsafe { data[i].assume_init_mut() }
        } _ => {
            &mut data[i]
        }}
    }
    ///
    #[inline(always)]
    pub const fn write_byte(data: &mut [MaybeByte], i: usize, b: u8) {
        cfg_select! { all(feature = "unsafe_array", not(feature = "safe_mem")) => {
            data[i].write(b);
        } _ => {
            data[i] = b;
        }}
    }
    ///
    #[inline(always)]
    pub const fn slice_bytes(data: &[MaybeByte], start: usize, end: usize) -> &[u8] {
        cfg_select! { // unsafest, unsafe, safe:
            all(feature = "unsafe_array", feature = "unsafe_slice", not(feature = "safe_mem")) => {
                unsafe { Slice::range_unchecked(
                    Slice::from_raw_parts(data.as_ptr().cast::<u8>(), CAP), start, end)
            }} all(feature = "unsafe_array", not(feature = "safe_mem")) => {
                unsafe { Slice::range(Slice::from_raw_parts(
                    data.as_ptr().cast::<u8>(), CAP), start, end)
            }}
            _ => { Slice::range(data, start, end) }}
    }
    ///
    #[inline(always)]
    pub const fn slice_bytes_mut(data: &mut [MaybeByte], start: usize, end: usize) -> &mut [u8] {
        cfg_select! { // unsafest, unsafe, safe:
            all(feature = "unsafe_array", feature = "unsafe_slice", not(feature = "safe_mem")) => {
                unsafe { Slice::range_mut_unchecked(
                    Slice::from_raw_parts_mut(data.as_mut_ptr().cast::<u8>(), CAP), start, end)
            }} all(feature = "unsafe_array", not(feature = "safe_mem")) => {
                unsafe { Slice::range_mut(Slice::from_raw_parts_mut(
                    data.as_mut_ptr().cast::<u8>(), CAP), start, end)
            }}
            _ => { Slice::range_mut(data, start, end) }}
    }
}