wit-bindgen 0.46.0

Rust bindings generator and runtime support for WIT and the component model. Used when compiling Rust programs to the component model.
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

//! Low-level FFI-like bindings around `waitable-set` in the canonical ABI.

use std::num::NonZeroU32;

pub struct WaitableSet(NonZeroU32);

impl WaitableSet {
    pub fn new() -> WaitableSet {
        let ret = WaitableSet(NonZeroU32::new(unsafe { new() }).unwrap());
        rtdebug!("waitable-set.new() = {}", ret.0.get());
        ret
    }

    pub fn join(&self, waitable: u32) {
        rtdebug!("waitable-set.join({waitable}, {})", self.0.get());
        unsafe { join(waitable, self.0.get()) }
    }

    pub fn remove_waitable_from_all_sets(waitable: u32) {
        rtdebug!("waitable-set.join({waitable}, 0)");
        unsafe { join(waitable, 0) }
    }

    pub fn wait(&self) -> (u32, u32, u32) {
        unsafe {
            let mut payload = [0; 2];
            let event0 = wait(self.0.get(), &mut payload);
            rtdebug!(
                "waitable-set.wait({}) = ({event0}, {:#x}, {:#x})",
                self.0.get(),
                payload[0],
                payload[1],
            );
            (event0, payload[0], payload[1])
        }
    }

    pub fn poll(&self) -> (u32, u32, u32) {
        unsafe {
            let mut payload = [0; 2];
            let event0 = poll(self.0.get(), &mut payload);
            rtdebug!(
                "waitable-set.poll({}) = ({event0}, {:#x}, {:#x})",
                self.0.get(),
                payload[0],
                payload[1],
            );
            (event0, payload[0], payload[1])
        }
    }

    pub fn as_raw(&self) -> u32 {
        self.0.get()
    }
}

impl Drop for WaitableSet {
    fn drop(&mut self) {
        unsafe {
            rtdebug!("waitable-set.drop({})", self.0.get());
            drop(self.0.get());
        }
    }
}

#[cfg(not(target_arch = "wasm32"))]
unsafe fn new() -> u32 {
    unreachable!()
}
#[cfg(not(target_arch = "wasm32"))]
unsafe fn drop(_: u32) {
    unreachable!()
}
#[cfg(not(target_arch = "wasm32"))]
unsafe fn join(_: u32, _: u32) {
    unreachable!()
}
#[cfg(not(target_arch = "wasm32"))]
unsafe fn wait(_: u32, _: *mut [u32; 2]) -> u32 {
    unreachable!();
}
#[cfg(not(target_arch = "wasm32"))]
unsafe fn poll(_: u32, _: *mut [u32; 2]) -> u32 {
    unreachable!();
}

#[cfg(target_arch = "wasm32")]
#[link(wasm_import_module = "$root")]
extern "C" {
    #[link_name = "[waitable-set-new]"]
    fn new() -> u32;
    #[link_name = "[waitable-set-drop]"]
    fn drop(set: u32);
    #[link_name = "[waitable-join]"]
    fn join(waitable: u32, set: u32);
    #[link_name = "[waitable-set-wait]"]
    fn wait(_: u32, _: *mut [u32; 2]) -> u32;
    #[link_name = "[waitable-set-poll]"]
    fn poll(_: u32, _: *mut [u32; 2]) -> u32;
}