ffi_types 0.0.21

C ABI compatible wrappers for cbindgen/bindgen.
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
129
130
131
132

/// A type alias for `std::boxed::Box<T>`.
///
/// `Box` doesn't require a wrapper because it is guaranteed to be layout as a pointer.
pub type Box<T> = alloc::boxed::Box<T>;

/// A type alias for `Option<Box<T>>`.
///
/// `None` value means a null pointer.
#[repr(C)]
pub struct OptionBox<T> {
    pub ptr: *mut T,
}
static_assertions::assert_eq_size!(OptionBox<u8>, *const u8);
static_assertions::assert_eq_size!(OptionBox<u8>, Box<u8>);
static_assertions::assert_eq_size!(OptionBox<u8>, Option<Box<u8>>);

impl<T> core::fmt::Debug for OptionBox<T>
where
    T: 'static + core::fmt::Debug,
{
    #[inline(always)]
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        unsafe { self.ptr.as_ref().fmt(f) }
    }
}

impl<T> Clone for OptionBox<T>
where
    T: 'static + Clone,
{
    #[inline(always)]
    fn clone(&self) -> Self {
        if self.ptr.is_null() {
            return Self::none();
        }
        let borrowed_box = unsafe { Box::from_raw(self.ptr) };
        let cloned = borrowed_box.clone();
        core::mem::forget(borrowed_box);
        cloned.into()
    }
}

impl<T> Drop for OptionBox<T> {
    #[inline(always)]
    fn drop(&mut self) {
        if !self.ptr.is_null() {
            drop(unsafe { Box::from_raw(self.ptr) });
        }
    }
}

impl<T> OptionBox<T> {
    #[inline(always)]
    pub fn new(boxed: Box<T>) -> Self {
        Self {
            ptr: Box::into_raw(boxed),
        }
    }

    #[inline(always)]
    pub fn from_value(value: T) -> Self {
        Self::new(Box::new(value))
    }

    #[inline(always)]
    pub fn into_box(self) -> Option<Box<T>> {
        if self.ptr.is_null() {
            return None;
        }
        Some(unsafe { Box::from_raw(self.ptr) })
    }

    #[inline(always)]
    pub const fn none() -> Self {
        Self {
            ptr: core::ptr::null_mut(),
        }
    }

    #[inline]
    pub fn as_ref(&self) -> Option<&T> {
        unsafe { self.ptr.as_ref() } // SAFETY: `ptr` is a value of a valid Box
    }
}

impl<T> From<Box<T>> for OptionBox<T> {
    #[inline]
    fn from(boxed: Box<T>) -> Self {
        Self::new(boxed)
    }
}

impl<T> From<Option<Box<T>>> for OptionBox<T> {
    #[inline]
    fn from(boxed: Option<Box<T>>) -> Self {
        if let Some(boxed) = boxed {
            Self::new(boxed)
        } else {
            Self::none()
        }
    }
}

impl<T> Default for OptionBox<T> {
    #[inline(always)]
    fn default() -> Self {
        Self::none()
    }
}

// impl<T> core::convert::AsRef<Option<Box<T>>> for OptionBox<T> {
//     #[inline(always)]
//     fn as_ref(&self) -> &Option<Box<T>> {
//         &self.0
//     }
// }

// impl<T> core::borrow::Borrow<Option<Box<T>>> for OptionBox<T> {
//     #[inline(always)]
//     fn borrow(&self) -> &Option<Box<T>> {
//         self.as_ref()
//     }
// }

// impl<T> core::ops::Deref for OptionBox<T> {
//     type Target = Option<Box<T>>;

//     #[inline(always)]
//     fn deref(&self) -> &Self::Target {
//         self.as_ref()
//     }
// }