trident 0.2.1

A struct that stores a `T`, either inline or, if `T` is larger than 3 words, allocated
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

/**
 * A struct that stores a type-erased `T`, either inline or, if `T` is larger than 3 words, allocated.
 */
use std::{mem, ptr};

use crate::into;
use crate::limits::{self, NWORDS};
use crate::Trident;

#[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
compile_error!("Not a 32- or 64-bit machine");

#[cfg_attr(target_pointer_width = "64", repr(C, align(8)))]
#[cfg_attr(target_pointer_width = "32", repr(C, align(4)))]
pub struct Erased {
    words: [usize; NWORDS],
}

impl Erased {
    /**
     * Create an `Erased` from a `T`
     *
     * `T`'s destructor cannot be run, as the type is erased.
     */
    pub fn new<T>(t: T) -> Self {
        if limits::should_inline::<T>() {
            let mut ret = Self { words: [0; NWORDS] };

            unsafe {
                ptr::copy_nonoverlapping(&t, ret.as_mut_ref(), 1);
            }
            mem::forget(t);

            ret
        } else {
            let alloc = Box::new(t);

            Self {
                words: [Box::into_raw(alloc) as usize, 0, 0],
            }
        }
    }

    /**
     * Get a pointer to the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn as_ptr<T>(&self) -> *const T {
        if limits::should_inline::<T>() {
            &self.words as *const _ as usize as *const T
        } else {
            self.words[0] as *const T
        }
    }

    /**
     * Get a reference to the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn as_ref<T>(&self) -> &T {
        &*self.as_ptr()
    }

    /**
     * Get a mutable pointer to the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn as_mut_ptr<T>(&mut self) -> *mut T {
        if limits::should_inline::<T>() {
            &mut self.words as *mut _ as usize as *mut T
        } else {
            self.words[0] as *mut T
        }
    }

    /**
     * Get a mutable reference to the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn as_mut_ref<T>(&mut self) -> &mut T {
        &mut *self.as_mut_ptr()
    }

    /**
     * Copy the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn get<T: Copy>(&self) -> T {
        *self.as_ref()
    }

    /**
     * Get the contained `T`.
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn into_inner<T>(mut self) -> T {
        into::into_inner(self.as_mut_ptr(), self)
    }

    /**
     * Convert to a `Trident<T>`
     * Unsafe because we don't know that this is the same `T` that this `Erased` was created with.
     */
    pub unsafe fn into_trident<T>(self) -> Trident<T> {
        Trident::from_erased(self)
    }
}