diplomat 0.10.0

The diplomat FFI generation macro
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

---
source: macro/src/lib.rs
assertion_line: 1069
expression: "rustfmt_code(&gen_bridge(parse_quote! {\n                            mod ffi\n                            {\n                                pub struct TestingStruct { x: i32, y: i32, } pub trait\n                                TesterTrait: std::marker::Send\n                                {\n                                    fn test_trait_fn(&self, x: i32) -> i32; fn\n                                    test_void_trait_fn(&self); fn\n                                    test_struct_trait_fn(&self, s: TestingStruct) -> i32; fn\n                                    test_slice_trait_fn(&self, s: &[u8]) -> i32;\n                                } pub struct Wrapper { cant_be_empty: bool, } impl Wrapper\n                                {\n                                    pub fn test_with_trait(t: impl TesterTrait, x: i32) -> i32\n                                    { t.test_void_trait_fn(); t.test_trait_fn(x) } pub fn\n                                    test_trait_with_struct(t: impl TesterTrait) -> i32\n                                    {\n                                        let arg = TestingStruct { x: 1, y: 5, };\n                                        t.test_struct_trait_fn(arg)\n                                    }\n                                }\n                            }\n                        }).to_token_stream().to_string())"
---
mod ffi {
    #[repr(C)]
    pub struct TestingStruct {
        x: i32,
        y: i32,
    }
    pub trait TesterTrait: std::marker::Send {
        fn test_trait_fn(&self, x: i32) -> i32;
        fn test_void_trait_fn(&self);
        fn test_struct_trait_fn(&self, s: TestingStruct) -> i32;
        fn test_slice_trait_fn(&self, s: &[u8]) -> i32;
    }
    #[repr(C)]
    pub struct Wrapper {
        cant_be_empty: bool,
    }
    impl Wrapper {
        pub fn test_with_trait(t: impl TesterTrait, x: i32) -> i32 {
            t.test_void_trait_fn();
            t.test_trait_fn(x)
        }
        pub fn test_trait_with_struct(t: impl TesterTrait) -> i32 {
            let arg = TestingStruct { x: 1, y: 5 };
            t.test_struct_trait_fn(arg)
        }
    }
    use core::ffi::c_void;
    use diplomat_runtime::*;
    #[no_mangle]
    extern "C" fn Wrapper_test_with_trait(t: DiplomatTraitStruct_TesterTrait, x: i32) -> i32 {
        Wrapper::test_with_trait(t, x)
    }
    #[no_mangle]
    extern "C" fn Wrapper_test_trait_with_struct(t: DiplomatTraitStruct_TesterTrait) -> i32 {
        Wrapper::test_trait_with_struct(t)
    }
    #[repr(C)]
    pub struct TesterTrait_VTable {
        pub destructor: Option<unsafe extern "C" fn(*const c_void)>,
        pub size: usize,
        pub alignment: usize,
        pub run_test_trait_fn_callback: unsafe extern "C" fn(*const c_void, i32) -> i32,
        pub run_test_void_trait_fn_callback: unsafe extern "C" fn(*const c_void),
        pub run_test_struct_trait_fn_callback:
            unsafe extern "C" fn(*const c_void, TestingStruct) -> i32,
        pub run_test_slice_trait_fn_callback:
            unsafe extern "C" fn(*const c_void, diplomat_runtime::DiplomatSlice<u8>) -> i32,
    }
    #[repr(C)]
    pub struct DiplomatTraitStruct_TesterTrait {
        data: *const c_void,
        pub vtable: TesterTrait_VTable,
    }
    unsafe impl std::marker::Send for DiplomatTraitStruct_TesterTrait {}
    impl TesterTrait for DiplomatTraitStruct_TesterTrait {
        fn test_trait_fn(&self, x: i32) -> i32 {
            unsafe { ((self.vtable).run_test_trait_fn_callback)(self.data, x) }
        }
        fn test_void_trait_fn(&self) {
            unsafe {
                ((self.vtable).run_test_void_trait_fn_callback)(self.data);
            }
        }
        fn test_struct_trait_fn(&self, s: TestingStruct) -> i32 {
            unsafe { ((self.vtable).run_test_struct_trait_fn_callback)(self.data, s) }
        }
        fn test_slice_trait_fn(&self, s: &[u8]) -> i32 {
            unsafe {
                let s: diplomat_runtime::DiplomatSlice<u8> = s.into();
                ((self.vtable).run_test_slice_trait_fn_callback)(self.data, s)
            }
        }
    }
    impl Drop for DiplomatTraitStruct_TesterTrait {
        fn drop(&mut self) {
            if let Some(destructor) = self.vtable.destructor {
                unsafe {
                    (destructor)(self.data);
                }
            }
        }
    }
}