minfac 0.1.4

Lightweight Inversion Of Control
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

use alloc::boxed::Box;

use super::super::AnyPtr;

#[repr(C)]
#[cfg_attr(feature = "stable_abi", derive(abi_stable::StableAbi))]
pub struct AutoFreePointer {
    dropper: extern "C" fn(outer_context: AnyPtr),
    context: AnyPtr,
}
unsafe impl Send for AutoFreePointer {}
unsafe impl Sync for AutoFreePointer {}

impl AutoFreePointer {
    pub fn new<T: Send + Sync>(
        context: *const T,
        dropper: extern "C" fn(outer_context: AnyPtr),
    ) -> Self {
        Self {
            context: context as AnyPtr,
            dropper,
        }
    }

    pub fn no_alloc(context: AnyPtr) -> Self {
        extern "C" fn dropper(_: AnyPtr) {}
        Self { dropper, context }
    }
    pub fn boxed<T>(input: T) -> Self {
        extern "C" fn dropper<T>(u: AnyPtr) {
            if !u.is_null() {
                drop(unsafe { Box::from_raw(u as *mut T) })
            }
        }
        Self {
            dropper: dropper::<T>,
            context: Box::into_raw(Box::new(input)) as AnyPtr,
        }
    }
    pub fn get_pointer(&self) -> AnyPtr {
        self.context
    }
}

impl Drop for AutoFreePointer {
    fn drop(&mut self) {
        (self.dropper)(self.context)
    }
}