dairy 0.2.2

A more compact, user friendly clone-on-write smart pointer.
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

//! Implements a compact storage for length and capacity.

use core::ptr::NonNull;

#[cfg(not(target_pointer_width = "64"))]
pub use medium::Extent;
#[cfg(target_pointer_width = "64")]
pub use small::Extent;

#[cfg(target_pointer_width = "64")]
mod small {
    use super::*;

    const SHIFT: u32 = usize::BITS / 2;
    const LOWER: usize = usize::MAX >> SHIFT;
    const UPPER: usize = !LOWER;

    #[derive(Clone, Copy, Default)]
    pub struct Extent(usize);

    impl Extent {
        #[inline]
        pub unsafe fn borrowed<T>(ptr: *const T, len: usize) -> (NonNull<T>, Self) {
            let ptr = unsafe { NonNull::new_unchecked(ptr as *mut T) };
            (ptr, Self(len))
        }

        #[inline]
        pub unsafe fn owned<T>(ptr: *mut T, len: usize, cap: usize) -> (NonNull<T>, Self) {
            assert!(cap & LOWER == cap, "capacity out of bounds: {}", cap);
            let extra = (cap << SHIFT) | len;
            let ptr = unsafe { NonNull::new_unchecked(ptr) };
            (ptr, Self(extra))
        }

        #[inline]
        pub const fn len(&self) -> usize {
            self.0 & LOWER
        }

        #[inline]
        pub const fn capacity(&self) -> usize {
            (self.0 & UPPER) >> SHIFT
        }
    }
}

#[cfg(not(target_pointer_width = "64"))]
mod medium {
    use super::*;

    #[derive(Clone, Copy, Default)]
    pub struct Extent {
        len: usize,
        cap: usize,
    }

    impl Extent {
        #[inline]
        pub unsafe fn borrowed<T>(ptr: *const T, len: usize) -> (NonNull<T>, Self) {
            let ptr = unsafe { NonNull::new_unchecked(ptr as *mut T) };
            (ptr, Self { len, cap: 0 })
        }

        #[inline]
        pub unsafe fn owned<T>(ptr: *mut T, len: usize, cap: usize) -> (NonNull<T>, Self) {
            let ptr = unsafe { NonNull::new_unchecked(ptr) };
            (ptr, Self { len, cap })
        }

        #[inline]
        pub const fn len(&self) -> usize {
            self.len
        }

        #[inline]
        pub const fn capacity(&self) -> usize {
            self.cap
        }
    }
}