bointer 0.2.0

Assorted pointer-related utilities
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use core::ptr;

pub trait AsRawPtr {
    type Pointee;
    fn as_raw_ptr(&self) -> *const Self::Pointee;
}

pub trait AsRawMutPtr {
    type Pointee;
    fn as_raw_mut_ptr(&mut self) -> *mut Self::Pointee;
}

impl<'a, T> AsRawPtr for Option<&'a T> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_ptr(&self) -> *const Self::Pointee {
        unsafe { ptr::read::<*const T>(self as *const _ as *const _) }
    }
}

impl<'a, T> AsRawPtr for Option<&'a mut T> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_ptr(&self) -> *const Self::Pointee {
        unsafe { ptr::read::<*const T>(self as *const _ as *const _) }
    }
}

impl<'a, T> AsRawMutPtr for Option<&'a mut T> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_mut_ptr(&mut self) -> *mut Self::Pointee {
        unsafe { ptr::read::<*mut T>(self as *const _ as *const _) }
    }
}

#[cfg(feature = "alloc")]
impl<T> AsRawPtr for Option<alloc::boxed::Box<T>> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_ptr(&self) -> *const Self::Pointee {
        unsafe { ptr::read::<*const T>(self as *const _ as *const _) }
    }
}

#[cfg(feature = "alloc")]
impl<T> AsRawMutPtr for Option<alloc::boxed::Box<T>> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_mut_ptr(&mut self) -> *mut Self::Pointee {
        unsafe { ptr::read::<*mut T>(self as *const _ as *const _) }
    }
}

impl<T> AsRawPtr for Option<ptr::NonNull<T>> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_ptr(&self) -> *const Self::Pointee {
        unsafe { ptr::read::<*const T>(self as *const _ as *const _) }
    }
}

impl<T> AsRawMutPtr for Option<ptr::NonNull<T>> {
    type Pointee = T;

    #[inline(always)]
    fn as_raw_mut_ptr(&mut self) -> *mut Self::Pointee {
        unsafe { ptr::read::<*mut T>(self as *const _ as *const _) }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ref() {
        let num = 1usize;
        let opt = Some(&num);

        let ptr = opt.as_raw_ptr();
        unsafe {
            assert_eq!(*ptr, 1);
        }
    }

    #[test]
    fn test_ref_none() {
        let num = Option::<&usize>::None;

        let ptr = num.as_raw_ptr();

        assert!(ptr.is_null());
    }

    #[test]
    fn test_mut_ref() {
        let mut num = 1usize;
        let mut opt = Some(&mut num);

        let ptr = opt.as_raw_mut_ptr();
        unsafe {
            *ptr = 2;
        }

        assert_eq!(num, 2);
    }

    #[test]
    fn test_mut_ref_none() {
        let mut num = Option::<&mut usize>::None;

        let ptr = num.as_raw_mut_ptr();

        assert!(ptr.is_null());
    }

    #[test]
    fn test_box() {
        let mut num = Some(alloc::boxed::Box::new(1usize));

        let ptr = num.as_raw_mut_ptr();
        unsafe {
            *ptr = 2;
        }

        assert!(matches!(num, Some(b) if *b == 2));
    }

    #[test]
    fn test_box_none() {
        let mut num = Option::<alloc::boxed::Box<usize>>::None;

        let ptr = num.as_raw_mut_ptr();

        assert!(ptr.is_null());
    }
}