heterovec 0.1.2

In-place vector of dynamically sized type
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165


use std::{
    mem::{
        size_of,
        align_of,
        transmute,
        transmute_copy,
        ManuallyDrop,
    },
    ptr::{
        drop_in_place,
        slice_from_raw_parts_mut,
    },
    marker::Unsize,
};

/// Types that can be pushed onto a `HeteroSizedVec`.
///
/// Not meant to be implemented outside of the `heterovec` crate.
pub unsafe trait HeteroSizedPush<T: ?Sized> {
    unsafe fn elem_size(&self) -> usize;

    unsafe fn elem_align(&self) -> usize;

    unsafe fn elem_ptr(&self) -> *const T;

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize);

    /// Assume that ownership of the pointee has been taken through unsafe
    /// means, but if there is some destructable wrapper around that
    /// (eg. a `Box`), clean that up, but without dropping the inner element.
    unsafe fn outer_drop(&mut self);
}

/// Used to directly push an element onto a `HeteroSizedVec` from the stack.
pub struct InPlace<E>(pub E);

unsafe impl<T: ?Sized, E: Unsize<T>> HeteroSizedPush<T> for InPlace<E> {
    unsafe fn elem_size(&self) -> usize {
        size_of::<E>()
    }

    unsafe fn elem_align(&self) -> usize {
        align_of::<E>()
    }

    unsafe fn elem_ptr(&self) -> *const T {
        &self.0 as &T as *const T
    }

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize) {
        |data, _| {
            drop_in_place(transmute::<
                *mut u8,
                &mut E,
            >(data));
        }
    }

    unsafe fn outer_drop(&mut self) {}
}

unsafe impl<'a, I: Copy> HeteroSizedPush<[I]> for &'a [I] {
    unsafe fn elem_size(&self) -> usize {
        self.len() * size_of::<I>()
    }

    unsafe fn elem_align(&self) -> usize {
        align_of::<I>()
    }

    unsafe fn elem_ptr(&self) -> *const [I] {
        *self as *const [I]
    }

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize) {
        |_, _| () // we are copy, so no need to drop
    }

    unsafe fn outer_drop(&mut self) {}
}

unsafe impl<I> HeteroSizedPush<[I]> for Vec<I> {
    unsafe fn elem_size(&self) -> usize {
        self.len() * size_of::<I>()
    }

    unsafe fn elem_align(&self) -> usize {
        align_of::<I>()
    }

    unsafe fn elem_ptr(&self) -> *const [I] {
        self.as_slice() as *const [I]
    }

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize) {
        // this relies on the fat pointer meta in an array slice being the length in elements
        |start, len| {
            // drop each element
            let elems: &mut [I] = &mut *slice_from_raw_parts_mut(
                start as *mut I,
                len,
            );
            for elem in elems {
                drop_in_place(elem);
            }
        }
    }

    unsafe fn outer_drop(&mut self) {
        // this is similar to how we are handling the box

        drop(transmute_copy::<
            Vec<I>,
            Vec<ManuallyDrop<I>>,
        >);
    }
}

unsafe impl<'a> HeteroSizedPush<str> for &'a str {
    unsafe fn elem_size(&self) -> usize {
        (*self).len()
    }

    unsafe fn elem_align(&self) -> usize {
        1
    }

    unsafe fn elem_ptr(&self) -> *const str {
        *self as *const str
    }

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize) {
        |_, _| () // no destructor needed for str
    }

    unsafe fn outer_drop(&mut self) {}
}

unsafe impl<T: ?Sized> HeteroSizedPush<T> for Box<dyn HeteroSizedPush<T>> {
    unsafe fn elem_size(&self) -> usize {
        Box::as_ref(self).elem_size()
    }

    unsafe fn elem_align(&self) -> usize {
        Box::as_ref(self).elem_align()
    }

    unsafe fn elem_ptr(&self) -> *const T {
        Box::as_ref(self).elem_ptr()
    }

    unsafe fn elem_drop_handler(&self) -> fn(*mut u8, usize) {
        Box::as_ref(self).elem_drop_handler()
    }

    unsafe fn outer_drop(&mut self) {
        // this feels deeply disturbing

        drop(transmute_copy::<
            Box<dyn HeteroSizedPush<T>>,
            Box<ManuallyDrop<dyn HeteroSizedPush<T>>>,
        >(self));
    }
}