sentinel 0.5.4

A sentinel-terminated slice library.
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

use core::ops::{Range, RangeTo, RangeToInclusive};

use crate::{SSlice, Sentinel};

/// Describes how to index into a `SSlice<T, S>`.
pub trait SliceIndex<T: Sentinel> {
    /// The output of the index operation.
    type Output: ?Sized;

    /// Indexes into `slice` without checking the bounds.
    ///
    /// # Safety
    ///
    /// `self` must be in bounds.
    unsafe fn index_unchecked(self, slice: &SSlice<T>) -> &Self::Output;

    /// Indexes into `slice` without checking the bounds.
    ///
    /// # Safety
    ///
    /// `self` must be in bounds.
    unsafe fn index_unchecked_mut(self, slice: &mut SSlice<T>) -> &mut Self::Output;
}

impl<T: Sentinel> SliceIndex<T> for usize {
    type Output = T;

    #[inline(always)]
    unsafe fn index_unchecked(self, slice: &SSlice<T>) -> &Self::Output {
        unsafe { &*slice.as_ptr().add(self) }
    }

    #[inline(always)]
    unsafe fn index_unchecked_mut(self, slice: &mut SSlice<T>) -> &mut Self::Output {
        unsafe { &mut *slice.as_mut_ptr().add(self) }
    }
}

impl<T: Sentinel> SliceIndex<T> for Range<usize> {
    type Output = [T];

    #[inline(always)]
    unsafe fn index_unchecked(self, slice: &SSlice<T>) -> &Self::Output {
        unsafe {
            core::slice::from_raw_parts(
                slice.as_ptr().add(self.start),
                self.end.wrapping_sub(self.start),
            )
        }
    }

    #[inline(always)]
    unsafe fn index_unchecked_mut(self, slice: &mut SSlice<T>) -> &mut Self::Output {
        unsafe {
            core::slice::from_raw_parts_mut(
                slice.as_mut_ptr().add(self.start),
                self.end.wrapping_sub(self.start),
            )
        }
    }
}

impl<T: Sentinel> SliceIndex<T> for RangeTo<usize> {
    type Output = [T];

    #[inline(always)]
    unsafe fn index_unchecked(self, slice: &SSlice<T>) -> &Self::Output {
        unsafe { core::slice::from_raw_parts(slice.as_ptr(), self.end) }
    }

    #[inline(always)]
    unsafe fn index_unchecked_mut(self, slice: &mut SSlice<T>) -> &mut Self::Output {
        unsafe { core::slice::from_raw_parts_mut(slice.as_mut_ptr(), self.end) }
    }
}

impl<T: Sentinel> SliceIndex<T> for RangeToInclusive<usize> {
    type Output = [T];

    #[inline(always)]
    unsafe fn index_unchecked(self, slice: &SSlice<T>) -> &Self::Output {
        unsafe { core::slice::from_raw_parts(slice.as_ptr(), self.end.wrapping_add(1)) }
    }

    #[inline(always)]
    unsafe fn index_unchecked_mut(self, slice: &mut SSlice<T>) -> &mut Self::Output {
        unsafe { core::slice::from_raw_parts_mut(slice.as_mut_ptr(), self.end.wrapping_add(1)) }
    }
}