frame_mem_utils 0.1.0

a few stack oriented utileties designed with unsafe in mind
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

use core::ops::Deref;
use core::ops::DerefMut;
use alloc::boxed::Box;
use core::marker::PhantomData;
use core::ptr::NonNull;

#[derive(Debug,PartialEq,Eq,Hash)]
pub struct RefBox<'a,T:?Sized>{
    ptr:NonNull<T>,
    _ph:PhantomData<&'a mut T>,
}

unsafe impl<'m,T> Send for RefBox<'m, T> where Box<T> : Send{}
unsafe impl<'m, T> Sync for RefBox<'m, T> where Box<T> : Sync{}


impl<'a, T:?Sized> RefBox<'a,T>{
    pub unsafe fn new(t:&'a mut T)->Self{
        Self{
            ptr:t.into(),
            _ph:PhantomData
        }
    }

    pub fn leak(self)->&'a mut T{
        let ans = unsafe{
            &mut* self.ptr.as_ptr()
        };
        core::mem::forget(self);
        ans
    }
}

impl<T:?Sized> Drop for RefBox<'_, T>{

fn drop(&mut self) { unsafe{
    core::ptr::drop_in_place(self.ptr.as_ptr())
} }
}

impl<T:?Sized> Deref for RefBox<'_,T>{
type Target = T;
fn deref(&self) -> &T { unsafe{&*self.ptr.as_ptr()}}

}
impl<T:?Sized> DerefMut for RefBox<'_,T>{
fn deref_mut(&mut self) -> &mut T { unsafe{&mut *self.ptr.as_ptr()} }
}