smart 0.1.1

dynamically-dispatched smart pointers
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

use std::ops::Deref;
use std::mem;
use std::ptr::NonNull;
use std::rc::Rc;
use std::sync::Arc;

pub(crate) struct Pointer<T: ?Sized> {
    ptr: NonNull<T>,
    // Invariant: This NonNull must always be a &'static
    vtable: NonNull<VTable<T>>,
}

struct VTable<T: ?Sized> {
    clone: unsafe fn(&T) -> NonNull<T>,
    drop: unsafe fn(NonNull<T>),
    sync: bool,
}

impl<T: ?Sized> Pointer<T> {
    #[inline(always)]
    pub(crate) fn sync(&self) -> bool {
        // Safe because vtable must always be a &'static
        unsafe { self.vtable.as_ref().sync }
    }
}


impl<T: ?Sized> Deref for Pointer<T> {
    type Target = T;
    fn deref(&self) -> &T {
        unsafe { self.ptr.as_ref() }
    }
}

impl<T: ?Sized> From<Rc<T>> for Pointer<T> {
    fn from(ptr: Rc<T>) -> Pointer<T> {
        unsafe fn clone<T: ?Sized>(arg: &T) -> NonNull<T> {
            let arg = Rc::from_raw(arg);
            let rc = arg.clone();
            mem::forget(arg);
            rc_into_raw_non_null(rc)
        }
        unsafe fn drop<T: ?Sized>(ptr: NonNull<T>) {
            mem::drop(Rc::from_raw(ptr.as_ptr()));
        }
        Pointer {
            ptr: rc_into_raw_non_null(ptr),
            vtable: NonNull::from(&VTable {
                clone,
                drop,
                sync: false,
            })
        }
    }
}

impl<T: ?Sized> From<Arc<T>> for Pointer<T> {
    fn from(ptr: Arc<T>) -> Pointer<T> {
        unsafe fn clone<T: ?Sized>(arg: &T) -> NonNull<T> {
            let arg = Arc::from_raw(arg);
            let rc = arg.clone();
            mem::forget(arg);
            arc_into_raw_non_null(rc)
        }
        unsafe fn drop<T: ?Sized>(ptr: NonNull<T>) {
            mem::drop(Arc::from_raw(ptr.as_ptr()));
        }
        Pointer {
            ptr: arc_into_raw_non_null(ptr),
            vtable: NonNull::from(&VTable {
                clone,
                drop,
                sync: true,
            })
        }
    }
}

impl<T: ?Sized> From<&'static T> for Pointer<T> {
    fn from(ptr: &'static T) -> Pointer<T> {
        fn clone<T: ?Sized>(arg: &T) -> NonNull<T> {
            NonNull::from(arg)
        }
        fn drop<T: ?Sized>(_ptr: NonNull<T>) { }
        Pointer {
            ptr: NonNull::from(ptr),
            vtable: NonNull::from(&VTable {
                clone,
                drop,
                sync: true,
            })
        }
    }
}

impl<T: ?Sized> Clone for Pointer<T> {
    fn clone(&self) -> Pointer<T> {
        Pointer {
            // Safe because vtable must always be a &'static
            ptr: unsafe { (self.vtable.as_ref().clone)(self.ptr.as_ref()) },
            vtable: self.vtable,
        }
    }
}

impl<T: ?Sized> Drop for Pointer<T> {
    fn drop(&mut self) {
        // Safe because vtable must always be a &'static
        unsafe { (self.vtable.as_ref().drop)(self.ptr) }
    }
}

#[cfg(feature = "nightly")]
fn rc_into_raw_non_null<T: ?Sized>(rc: Rc<T>) -> NonNull<T> {
    Rc::into_raw_non_null(rc)
}
#[cfg(feature = "nightly")]
fn arc_into_raw_non_null<T: ?Sized>(arc: Arc<T>) -> NonNull<T> {
    Arc::into_raw_non_null(arc)
}
#[cfg(not(feature = "nightly"))]
fn rc_into_raw_non_null<T: ?Sized>(rc: Rc<T>) -> NonNull<T> {
    unsafe { NonNull::new_unchecked(Rc::into_raw(rc) as *mut _) }
}
#[cfg(not(feature = "nightly"))]
fn arc_into_raw_non_null<T: ?Sized>(arc: Arc<T>) -> NonNull<T> {
    unsafe { NonNull::new_unchecked(Arc::into_raw(arc) as *mut _) }
}