wit-bindgen-cli 0.61.1

CLI tool to generate bindings for WIT documents and the component model. 
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
133
134
135
136
137
138
139
140
141
142
143
144

include!(env!("BINDINGS"));

use crate::exports::my::test::leaf_interface::{
    Body, Fields, Guest, GuestBody, GuestFields, GuestLeafThing, GuestResponse,
};
use std::cell::RefCell;
use std::sync::atomic::{AtomicU32, Ordering};
use wit_bindgen::{FutureReader, StreamReader};

struct Component;

export!(Component);

static LEAF_DROP_COUNT: AtomicU32 = AtomicU32::new(0);
static LEAF_LIVE_COUNT: AtomicU32 = AtomicU32::new(0);
static FIELDS_LIVE_COUNT: AtomicU32 = AtomicU32::new(0);
static BODY_LIVE_COUNT: AtomicU32 = AtomicU32::new(0);
static RESPONSE_LIVE_COUNT: AtomicU32 = AtomicU32::new(0);

struct MyLeafThing {
    value: String,
}

struct MyFields {
    value: String,
}

struct MyBody {
    contents: RefCell<Option<StreamReader<u8>>>,
    trailers: RefCell<Option<FutureReader<Fields>>>,
}

struct MyResponse {
    body: RefCell<Option<Body>>,
}

impl Guest for Component {
    type LeafThing = MyLeafThing;
    type Fields = MyFields;
    type Body = MyBody;
    type Response = MyResponse;

    fn leaf_drop_count() -> u32 {
        LEAF_DROP_COUNT.load(Ordering::SeqCst)
    }

    fn leaf_live_count() -> u32 {
        LEAF_LIVE_COUNT.load(Ordering::SeqCst)
    }

    fn fields_live_count() -> u32 {
        FIELDS_LIVE_COUNT.load(Ordering::SeqCst)
    }

    fn body_live_count() -> u32 {
        BODY_LIVE_COUNT.load(Ordering::SeqCst)
    }

    fn response_live_count() -> u32 {
        RESPONSE_LIVE_COUNT.load(Ordering::SeqCst)
    }
}

impl GuestLeafThing for MyLeafThing {
    fn new(s: String) -> Self {
        LEAF_LIVE_COUNT.fetch_add(1, Ordering::SeqCst);
        Self { value: s }
    }

    fn get(&self) -> String {
        self.value.clone()
    }
}

impl Drop for MyLeafThing {
    fn drop(&mut self) {
        LEAF_DROP_COUNT.fetch_add(1, Ordering::SeqCst);
        LEAF_LIVE_COUNT.fetch_sub(1, Ordering::SeqCst);
    }
}

impl GuestFields for MyFields {
    fn new(s: String) -> Self {
        FIELDS_LIVE_COUNT.fetch_add(1, Ordering::SeqCst);
        Self { value: s }
    }

    fn get(&self) -> String {
        self.value.clone()
    }
}

impl Drop for MyFields {
    fn drop(&mut self) {
        FIELDS_LIVE_COUNT.fetch_sub(1, Ordering::SeqCst);
    }
}

impl GuestBody for MyBody {
    fn new(contents: StreamReader<u8>, trailers: Option<FutureReader<Fields>>) -> Self {
        BODY_LIVE_COUNT.fetch_add(1, Ordering::SeqCst);
        Self {
            contents: RefCell::new(Some(contents)),
            trailers: RefCell::new(trailers),
        }
    }

    async fn collect(&self) -> (String, Option<String>) {
        let contents = self.contents.borrow_mut().take().unwrap();
        let bytes = contents.collect().await;
        let body = String::from_utf8(bytes).unwrap();
        let trailers = match self.trailers.borrow_mut().take() {
            Some(trailers) => Some(trailers.await.get::<MyFields>().get()),
            None => None,
        };
        (body, trailers)
    }
}

impl Drop for MyBody {
    fn drop(&mut self) {
        BODY_LIVE_COUNT.fetch_sub(1, Ordering::SeqCst);
    }
}

impl GuestResponse for MyResponse {
    fn new(body: Body) -> Self {
        RESPONSE_LIVE_COUNT.fetch_add(1, Ordering::SeqCst);
        Self {
            body: RefCell::new(Some(body)),
        }
    }

    async fn collect(&self) -> (String, Option<String>) {
        let body = self.body.borrow_mut().take().unwrap();
        body.get::<MyBody>().collect().await
    }
}

impl Drop for MyResponse {
    fn drop(&mut self) {
        RESPONSE_LIVE_COUNT.fetch_sub(1, Ordering::SeqCst);
    }
}