multindex 0.1.3

Index slices with multiple const indices/ranges.
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::marker::PhantomData;

////////////////////////////////////////////////////////////////////////////////

// Used to get a `&T` from both a `T` and a `&T`
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub trait BorrowSelf {
    fn _11748397628858797803_borrow_self(&self) -> &Self;
    fn _11748397628858797803_borrow_self_mut(&mut self) -> &mut Self;
}

impl<T> BorrowSelf for T
where
    T: ?Sized,
{
    #[inline(always)]
    fn _11748397628858797803_borrow_self(&self) -> &Self {
        self
    }

    #[inline(always)]
    fn _11748397628858797803_borrow_self_mut(&mut self) -> &mut Self {
        self
    }
}

////////////////////////////////////////////////////////////////////////////////

/// Used to emulate inherent associated types
pub trait AssocType {
    type Assoc: ?Sized;
}

////////////////////////////////////////////////////////////////////////////////

/// Used to decompose a slice into its parts
///
/// The `lifetime` field can be used to create references with the same lifetime.
pub struct SliceParts<'a, T> {
    pub ptr: *const T,
    pub len: usize,
    pub lifetime: PhantomData<&'a T>,
}

impl<'a, T> SliceParts<'a, T> {
    #[inline(always)]
    pub const fn new(slice: &'a [T]) -> Self {
        Self {
            ptr: slice.as_ptr(),
            len: slice.len(),
            lifetime: PhantomData,
        }
    }
}

////////////////////////////////////////////////////////////////////////////////

/// Used to decompose a slice into its parts
///
/// The `lifetime` field can be used to create references with the same lifetime.
pub struct SlicePartsMut<'a, T> {
    pub ptr: *mut T,
    pub len: usize,
    pub lifetime: PhantomData<&'a mut T>,
}

impl<'a, T> SlicePartsMut<'a, T> {
    #[inline(always)]
    pub fn new(slice: &'a mut [T]) -> Self {
        Self {
            ptr: slice.as_mut_ptr(),
            len: slice.len(),
            lifetime: PhantomData,
        }
    }
}

////////////////////////////////////////////////////////////////////////////////

/// Error message when the maximum exclusive end is outside the bounds of the slice.
#[cold]
#[inline(never)]
pub fn panic_on_oob_max_index(maximum_index: usize, slice_len: usize) -> ! {
    panic!(
        "Maximum index is {}, but slice length is {}",
        maximum_index, slice_len,
    );
}