hicc 0.2.3

Safe, efficient, full-featured FFI between Rust and C++
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

use std::convert::From;
use std::fmt;
use std::mem::ManuallyDrop;
use std::str;

/// 保存`c++`异常信息
#[repr(transparent)]
#[derive(Copy, Clone)]
pub struct ExceptionInfo([u8; 64]);

impl ExceptionInfo {
    fn new(info: &str) -> Self {
        let mut this = Self([0_u8; 64]);
        let len = info.len().min(this.0.len());
        this.0[..len].copy_from_slice(&info.as_bytes()[..len]);
        this.0[63] = 0;
        this
    }
    pub fn what(&self) -> &str {
        if let Some(slice) = self.0.splitn(2, |num| *num == 0).next() {
            let mut size = slice.len();
            while size > 0 {
                if let Ok(err) = str::from_utf8(&slice[..size]) {
                    return err;
                }
                size -= 1;
            }
        }
        "unknown exception"
    }
}
impl fmt::Debug for ExceptionInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.what().fmt(f)
    }
}

#[repr(C)]
union ExceptionValue<T> {
    except: ExceptionInfo,
    value: ManuallyDrop<T>,
}

/// 对应`c++`接口抛出的异常
///
/// 需要和`c++`侧的`EXPORT_EXCEPT_METHOD/EXPORT_EXCEPT_MEMBER_METHOD`配套使用.
///
/// 可转换为`Result<T, ExceptionInfo>`.
///
#[repr(C)]
#[must_use]
pub struct Exception<T> {
    value: ExceptionValue<T>,
    has_except: bool,
}

impl<T> Exception<T> {
    fn new_value(value: T) -> Self {
        Self {
            has_except: false,
            value: ExceptionValue {
                value: ManuallyDrop::new(value),
            },
        }
    }

    fn new_except(info: &str) -> Self {
        Self {
            has_except: true,
            value: ExceptionValue {
                except: ExceptionInfo::new(info),
            },
        }
    }

    pub fn ok(self) -> Result<T, ExceptionInfo> {
        if !self.has_except {
            let mut this = ManuallyDrop::new(self);
            Ok(unsafe { ManuallyDrop::take(&mut this.value.value) })
        } else {
            Err(unsafe { self.value.except })
        }
    }
}

impl<T> Drop for Exception<T> {
    fn drop(&mut self) {
        if !self.has_except {
            unsafe { ManuallyDrop::drop(&mut self.value.value) };
        }
    }
}

impl<T: fmt::Debug> fmt::Debug for Exception<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.has_except {
            unsafe { write!(f, "Err({:?})", self.value.except) }
        } else {
            unsafe { write!(f, "Ok({:?})", &*self.value.value) }
        }
    }
}

impl<T, E: fmt::Debug> From<Result<T, E>> for Exception<T> {
    fn from(val: Result<T, E>) -> Self {
        match val {
            Ok(val) => Self::new_value(val),
            Err(e) => {
                let s = format!("{e:?}");
                Self::new_except(&s)
            }
        }
    }
}