mun_memory 0.2.0

Memory management functionality for Mun
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

/// A `GcPtr` is what you interact with outside of the allocator. It is a pointer to a piece of
/// memory that points to the actual data stored in memory.
///
/// This creates an indirection that must be followed to get to the actual data of the object. Note
/// that the `GcPtr` must therefore be pinned in memory whereas the contained memory pointer may
/// change.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(transparent)]
pub struct GcPtr(RawGcPtr);

/// A `GcPtr` is thread safe.
unsafe impl Send for GcPtr {}
unsafe impl Sync for GcPtr {}

/// A `RawGcPtr` is an unsafe version of a `GcPtr`. It represents the raw internal pointer
/// semantics used by the runtime.
pub type RawGcPtr = *const *mut std::ffi::c_void;

pub trait HasIndirectionPtr {
    /// Returns a pointer to the referenced memory.
    ///
    /// # Safety
    ///
    /// This is an unsafe method because derefencing could result in an access violation.
    unsafe fn deref<T: Sized>(&self) -> *const T;

    /// Returns a mutable pointer to the referenced memory.
    ///
    /// # Safety
    ///
    /// This is an unsafe method because derefencing could result in an access violation.
    unsafe fn deref_mut<T: Sized>(&mut self) -> *mut T {
        self.deref::<T>() as *mut _
    }
}

impl HasIndirectionPtr for GcPtr {
    unsafe fn deref<T: Sized>(&self) -> *const T {
        (*self.0).cast()
    }
}

impl Into<RawGcPtr> for GcPtr {
    fn into(self) -> RawGcPtr {
        self.0
    }
}

impl Into<GcPtr> for RawGcPtr {
    fn into(self) -> GcPtr {
        GcPtr(self)
    }
}

impl GcPtr {
    pub(crate) fn as_ptr(self) -> RawGcPtr {
        self.0
    }
}