viaptr 0.1.0

An experimental library for packing complex types into pointer-sized fields
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

use alloc::{
    boxed::Box,
    rc,
    rc::Rc,
    sync::{self, Arc},
};
use core::{mem::align_of, sync::atomic::AtomicUsize};

use crate::{max, MaybeOwned, Pointer};


unsafe impl<T> Pointer for Box<T> {
    const NON_NULL: bool = true;
    const ALIGNMENT: usize = align_of::<T>();

    fn into_ptr(value: Self) -> *const () {
        Box::into_raw(value) as *const ()
    }

    unsafe fn from_ptr(ptr: *const ()) -> MaybeOwned<Self> {
        MaybeOwned::new(unsafe { Box::from_raw(ptr as *mut T) })
    }
}


unsafe impl<T> Pointer for Rc<T> {
    const NON_NULL: bool = true;
    const ALIGNMENT: usize = max(align_of::<usize>(), align_of::<T>());
    const CLONE_IN_PLACE: bool = true;

    fn into_ptr(value: Self) -> *const () {
        Rc::into_raw(value).cast()
    }

    unsafe fn from_ptr(ptr: *const ()) -> MaybeOwned<Self> {
        MaybeOwned::new(unsafe { Rc::from_raw(ptr.cast()) })
    }
}


unsafe impl<T> Pointer for rc::Weak<T> {
    const CLONE_IN_PLACE: bool = true;

    fn into_ptr(value: Self) -> *const () {
        rc::Weak::into_raw(value).cast()
    }

    unsafe fn from_ptr(ptr: *const ()) -> MaybeOwned<Self> {
        MaybeOwned::new(unsafe { rc::Weak::from_raw(ptr.cast()) })
    }
}


unsafe impl<T> Pointer for Arc<T> {
    const NON_NULL: bool = true;
    const ALIGNMENT: usize = max(align_of::<AtomicUsize>(), align_of::<T>());
    const CLONE_IN_PLACE: bool = true;

    fn into_ptr(value: Self) -> *const () {
        Arc::into_raw(value).cast()
    }

    unsafe fn from_ptr(ptr: *const ()) -> MaybeOwned<Self> {
        MaybeOwned::new(unsafe { Arc::from_raw(ptr.cast()) })
    }
}


unsafe impl<T> Pointer for sync::Weak<T> {
    const CLONE_IN_PLACE: bool = true;

    fn into_ptr(value: Self) -> *const () {
        sync::Weak::into_raw(value).cast()
    }

    unsafe fn from_ptr(ptr: *const ()) -> MaybeOwned<Self> {
        MaybeOwned::new(unsafe { sync::Weak::from_raw(ptr.cast()) })
    }
}