wry_bindgen/encode/
primitives.rs

1//! Primitive and string binary protocol implementations.
2
3use alloc::string::{String, ToString};
4use alloc::vec::Vec;
5
6use crate::batch::Runtime;
7use crate::ipc::{DecodeError, DecodedData, EncodedData};
8
9use super::{BatchableResult, BinaryDecode, BinaryEncode, EncodeTypeDef, TypeTag};
10
11// Unit type implementations
12
13impl BatchableResult for () {
14    fn try_placeholder(_: &mut Runtime) -> Option<Self> {
15        Some(())
16    }
17}
18
19impl EncodeTypeDef for () {
20    fn encode_type_def(buf: &mut Vec<u8>) {
21        buf.push(TypeTag::Null as u8);
22    }
23}
24
25impl BinaryEncode for () {
26    fn encode(self, _encoder: &mut EncodedData) {
27        // Unit type encodes as nothing
28    }
29}
30
31impl BinaryDecode for () {
32    fn decode(_decoder: &mut DecodedData) -> Result<Self, DecodeError> {
33        Ok(())
34    }
35}
36
37impl EncodeTypeDef for bool {
38    fn encode_type_def(buf: &mut Vec<u8>) {
39        buf.push(TypeTag::Bool as u8);
40    }
41}
42
43impl BinaryEncode for bool {
44    fn encode(self, encoder: &mut EncodedData) {
45        encoder.push_u8(if self { 1 } else { 0 });
46    }
47}
48
49impl BinaryDecode for bool {
50    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
51        Ok(decoder.take_u8()? != 0)
52    }
53}
54
55impl EncodeTypeDef for char {
56    fn encode_type_def(buf: &mut Vec<u8>) {
57        buf.push(TypeTag::U32 as u8);
58    }
59}
60
61impl BinaryEncode for char {
62    fn encode(self, encoder: &mut EncodedData) {
63        encoder.push_u32(self as u32);
64    }
65}
66
67impl BinaryDecode for char {
68    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
69        char::from_u32(decoder.take_u32()?)
70            .ok_or_else(|| DecodeError::Custom("invalid char scalar value".to_string()))
71    }
72}
73
74impl EncodeTypeDef for u8 {
75    fn encode_type_def(buf: &mut Vec<u8>) {
76        buf.push(TypeTag::U8 as u8);
77    }
78}
79
80impl BinaryEncode for u8 {
81    fn encode(self, encoder: &mut EncodedData) {
82        encoder.push_u8(self);
83    }
84}
85
86impl BinaryDecode for u8 {
87    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
88        decoder.take_u8()
89    }
90}
91
92impl EncodeTypeDef for u16 {
93    fn encode_type_def(buf: &mut Vec<u8>) {
94        buf.push(TypeTag::U16 as u8);
95    }
96}
97
98impl BinaryEncode for u16 {
99    fn encode(self, encoder: &mut EncodedData) {
100        encoder.push_u16(self);
101    }
102}
103
104impl BinaryDecode for u16 {
105    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
106        decoder.take_u16()
107    }
108}
109
110impl EncodeTypeDef for u32 {
111    fn encode_type_def(buf: &mut Vec<u8>) {
112        buf.push(TypeTag::U32 as u8);
113    }
114}
115
116impl BinaryEncode for u32 {
117    fn encode(self, encoder: &mut EncodedData) {
118        encoder.push_u32(self);
119    }
120}
121
122impl BinaryDecode for u32 {
123    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
124        decoder.take_u32()
125    }
126}
127
128impl EncodeTypeDef for u64 {
129    fn encode_type_def(buf: &mut Vec<u8>) {
130        buf.push(TypeTag::U64 as u8);
131    }
132}
133
134impl BinaryEncode for u64 {
135    fn encode(self, encoder: &mut EncodedData) {
136        encoder.push_u64(self);
137    }
138}
139
140impl BinaryDecode for u64 {
141    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
142        decoder.take_u64()
143    }
144}
145
146impl EncodeTypeDef for u128 {
147    fn encode_type_def(buf: &mut Vec<u8>) {
148        buf.push(TypeTag::U128 as u8);
149    }
150}
151
152impl BinaryEncode for u128 {
153    fn encode(self, encoder: &mut EncodedData) {
154        encoder.push_u128(self);
155    }
156}
157
158impl BinaryDecode for u128 {
159    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
160        decoder.take_u128()
161    }
162}
163
164impl EncodeTypeDef for i8 {
165    fn encode_type_def(buf: &mut Vec<u8>) {
166        buf.push(TypeTag::I8 as u8);
167    }
168}
169
170impl BinaryEncode for i8 {
171    fn encode(self, encoder: &mut EncodedData) {
172        encoder.push_u8(self as u8);
173    }
174}
175
176impl BinaryDecode for i8 {
177    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
178        Ok(decoder.take_u8()? as i8)
179    }
180}
181
182impl EncodeTypeDef for i16 {
183    fn encode_type_def(buf: &mut Vec<u8>) {
184        buf.push(TypeTag::I16 as u8);
185    }
186}
187
188impl BinaryEncode for i16 {
189    fn encode(self, encoder: &mut EncodedData) {
190        encoder.push_u16(self as u16);
191    }
192}
193
194impl BinaryDecode for i16 {
195    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
196        Ok(decoder.take_u16()? as i16)
197    }
198}
199
200impl EncodeTypeDef for i32 {
201    fn encode_type_def(buf: &mut Vec<u8>) {
202        buf.push(TypeTag::I32 as u8);
203    }
204}
205
206impl BinaryEncode for i32 {
207    fn encode(self, encoder: &mut EncodedData) {
208        encoder.push_u32(self as u32);
209    }
210}
211
212impl BinaryDecode for i32 {
213    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
214        Ok(decoder.take_u32()? as i32)
215    }
216}
217
218impl EncodeTypeDef for i64 {
219    fn encode_type_def(buf: &mut Vec<u8>) {
220        buf.push(TypeTag::I64 as u8);
221    }
222}
223
224impl BinaryEncode for i64 {
225    fn encode(self, encoder: &mut EncodedData) {
226        encoder.push_u64(self as u64);
227    }
228}
229
230impl BinaryDecode for i64 {
231    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
232        Ok(decoder.take_u64()? as i64)
233    }
234}
235
236impl EncodeTypeDef for i128 {
237    fn encode_type_def(buf: &mut Vec<u8>) {
238        buf.push(TypeTag::I128 as u8);
239    }
240}
241
242impl BinaryEncode for i128 {
243    fn encode(self, encoder: &mut EncodedData) {
244        encoder.push_u128(self as u128);
245    }
246}
247
248impl BinaryDecode for i128 {
249    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
250        Ok(decoder.take_u128()? as i128)
251    }
252}
253
254impl EncodeTypeDef for f32 {
255    fn encode_type_def(buf: &mut Vec<u8>) {
256        buf.push(TypeTag::F32 as u8);
257    }
258}
259
260impl BinaryEncode for f32 {
261    fn encode(self, encoder: &mut EncodedData) {
262        encoder.push_u32(self.to_bits());
263    }
264}
265
266impl BinaryDecode for f32 {
267    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
268        Ok(f32::from_bits(decoder.take_u32()?))
269    }
270}
271
272impl EncodeTypeDef for f64 {
273    fn encode_type_def(buf: &mut Vec<u8>) {
274        buf.push(TypeTag::F64 as u8);
275    }
276}
277
278impl BinaryEncode for f64 {
279    fn encode(self, encoder: &mut EncodedData) {
280        encoder.push_u64(self.to_bits());
281    }
282}
283
284impl BinaryDecode for f64 {
285    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
286        Ok(f64::from_bits(decoder.take_u64()?))
287    }
288}
289
290// usize implementations (uses u64 for portability)
291
292impl EncodeTypeDef for usize {
293    fn encode_type_def(buf: &mut Vec<u8>) {
294        buf.push(TypeTag::Usize as u8);
295    }
296}
297
298impl BinaryEncode for usize {
299    fn encode(self, encoder: &mut EncodedData) {
300        encoder.push_u64(self as u64);
301    }
302}
303
304impl BinaryDecode for usize {
305    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
306        Ok(decoder.take_u64()? as usize)
307    }
308}
309
310// isize implementations (uses i64 for portability)
311
312impl EncodeTypeDef for isize {
313    fn encode_type_def(buf: &mut Vec<u8>) {
314        buf.push(TypeTag::Isize as u8);
315    }
316}
317
318impl BinaryEncode for isize {
319    fn encode(self, encoder: &mut EncodedData) {
320        encoder.push_u64(self as u64);
321    }
322}
323
324impl BinaryDecode for isize {
325    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
326        Ok(decoder.take_u64()? as isize)
327    }
328}
329
330// String/str implementations
331
332impl EncodeTypeDef for str {
333    fn encode_type_def(buf: &mut Vec<u8>) {
334        buf.push(TypeTag::String as u8);
335    }
336}
337
338// Explicit impl for &str since str is not Sized and blanket impl doesn't apply
339impl EncodeTypeDef for &str {
340    fn encode_type_def(buf: &mut Vec<u8>) {
341        <str as EncodeTypeDef>::encode_type_def(buf);
342    }
343}
344
345// Blanket impl for &T references
346impl<T: EncodeTypeDef> EncodeTypeDef for &T {
347    fn encode_type_def(buf: &mut Vec<u8>) {
348        T::encode_type_def(buf);
349    }
350}
351
352impl BinaryEncode for &str {
353    fn encode(self, encoder: &mut EncodedData) {
354        encode_str(self, encoder);
355    }
356}
357
358impl EncodeTypeDef for String {
359    fn encode_type_def(buf: &mut Vec<u8>) {
360        buf.push(TypeTag::String as u8);
361    }
362}
363
364impl BinaryEncode for String {
365    fn encode(self, encoder: &mut EncodedData) {
366        encode_str(&self, encoder);
367    }
368}
369
370impl BinaryDecode for String {
371    fn decode(decoder: &mut DecodedData) -> Result<Self, DecodeError> {
372        Ok(decoder.take_str()?.to_string())
373    }
374}
375
376fn encode_str(value: &str, encoder: &mut EncodedData) {
377    #[cfg(feature = "enable-interning")]
378    if let Some(id) = crate::intern::unsafe_get_str(value) {
379        encoder.push_u32(crate::ipc::CACHED_STRING_SENTINEL);
380        encoder.push_u64(id);
381        return;
382    }
383
384    encoder.push_str(value);
385}
wry_bindgen/encode/primitives.rs

wry_bindgen/encode/
primitives.rs
