sliceable-ring-buffer 0.1.0

A double-ended queue that Deref's into a slice.
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

use std::{mem::MaybeUninit, ptr};
pub type Size = usize;
pub trait SizeCompact {
    unsafe fn new_unchecked(value: usize) -> Self;
    fn as_inner(&self) -> usize;
}
impl SizeCompact for Size {
    unsafe fn new_unchecked(value: usize) -> Self {
        value
    }

    fn as_inner(&self) -> usize {
        *self
    }
}

pub trait MaybeUninitCompact<T> {
    unsafe fn assume_init_ref(&self) -> &[T];
    unsafe fn assume_init_mut(&mut self) -> &mut [T];
}

impl<T> MaybeUninitCompact<T> for [MaybeUninit<T>] {
    unsafe fn assume_init_ref(&self) -> &[T] {
        unsafe { &*(ptr::from_ref::<Self>(self) as *const [T]) }
    }

    unsafe fn assume_init_mut(&mut self) -> &mut [T] {
        unsafe { &mut *(std::ptr::from_mut::<Self>(self) as *mut [T]) }
    }
}

#[allow(unused)]
pub trait UsizeCompact {
    fn strict_mul(self, rhs: Self) -> Self;
    fn strict_sub_signed(self, rhs: isize) -> Self;
    fn strict_sub(self, rhs: Self) -> Self;
    fn overflowing_sub_signed(self, rhs: isize) -> (usize, bool);
}

impl UsizeCompact for usize {
    fn strict_mul(self, rhs: Self) -> Self {
        let (a, b) = self.overflowing_mul(rhs);
        if b { panic!("attempt to multiply with overflow") } else { a }
    }

    fn overflowing_sub_signed(self, rhs: isize) -> (Self, bool) {
        let (r, overflow) = self.overflowing_sub(rhs.cast_unsigned());
        (r, overflow ^ (rhs < 0))
    }

    fn strict_sub_signed(self, rhs: isize) -> Self {
        let (a, b) = self.overflowing_sub_signed(rhs);
        if b { panic!("sub signed overflow") } else { a }
    }

    fn strict_sub(self, rhs: Self) -> Self {
        let (a, b) = self.overflowing_sub(rhs);
        if b { panic!("sub overflow") } else { a }
    }
}