wit_bindgen/rt/async_support/
unit_stream.rs

1use crate::rt::async_support::raw_stream_new;
2use crate::{RawStreamReader, RawStreamWriter, StreamOps};
3use std::alloc::Layout;
4
5/// Operations for `stream<()>`.
6///
7/// Can be combined with [`RawStreamWriter`] and [`RawStreamReader`] as created
8/// through [`UnitStreamOps::new`]
9#[derive(Copy, Clone)]
10pub struct UnitStreamOps;
11
12extern_wasm! {
13    #[link(wasm_import_module = "$root")]
14    extern "C" {
15        #[link_name = "[stream-new-unit]"]
16        fn unit_new() -> u64;
17        #[link_name = "[async-lower][stream-write-unit]"]
18        fn unit_write(stream: u32, val: *const u8, amt: usize) -> u32;
19        #[link_name = "[async-lower][stream-read-unit]"]
20        fn unit_read(stream: u32, val: *mut u8, amt: usize) -> u32;
21        #[link_name = "[stream-cancel-read-unit]"]
22        fn unit_cancel_read(stream: u32) -> u32;
23        #[link_name = "[stream-cancel-write-unit]"]
24        fn unit_cancel_write(stream: u32) -> u32;
25        #[link_name = "[stream-drop-readable-unit]"]
26        fn unit_drop_readable(stream: u32) ;
27        #[link_name = "[stream-drop-writable-unit]"]
28        fn unit_drop_writable(stream: u32) ;
29    }
30}
31
32impl UnitStreamOps {
33    /// Creates a new unit stream read/write pair.
34    pub fn new() -> (RawStreamWriter<Self>, RawStreamReader<Self>) {
35        unsafe { raw_stream_new(UnitStreamOps) }
36    }
37}
38
39unsafe impl StreamOps for UnitStreamOps {
40    type Payload = ();
41
42    fn new(&mut self) -> u64 {
43        unsafe { unit_new() }
44    }
45    fn elem_layout(&self) -> Layout {
46        Layout::new::<()>()
47    }
48    fn native_abi_matches_canonical_abi(&self) -> bool {
49        true
50    }
51    fn contains_lists(&self) -> bool {
52        false
53    }
54    unsafe fn lower(&mut self, (): (), _dst: *mut u8) {
55        unreachable!()
56    }
57    unsafe fn dealloc_lists(&mut self, _dst: *mut u8) {
58        unreachable!()
59    }
60    unsafe fn lift(&mut self, _dst: *mut u8) -> Self::Payload {
61        unreachable!()
62    }
63    unsafe fn start_write(&mut self, stream: u32, val: *const u8, amt: usize) -> u32 {
64        unsafe { unit_write(stream, val, amt) }
65    }
66    unsafe fn start_read(&mut self, stream: u32, val: *mut u8, amt: usize) -> u32 {
67        unsafe { unit_read(stream, val, amt) }
68    }
69    unsafe fn cancel_read(&mut self, stream: u32) -> u32 {
70        unsafe { unit_cancel_read(stream) }
71    }
72    unsafe fn cancel_write(&mut self, stream: u32) -> u32 {
73        unsafe { unit_cancel_write(stream) }
74    }
75    unsafe fn drop_readable(&mut self, stream: u32) {
76        unsafe { unit_drop_readable(stream) }
77    }
78    unsafe fn drop_writable(&mut self, stream: u32) {
79        unsafe { unit_drop_writable(stream) }
80    }
81}