plonk_wasm/wasm_ocaml_serde/
de.rs

1use super::{Error, Result};
2use js_sys::{Array, ArrayBuffer, Number, Uint8Array};
3use serde::de::{self, value::SeqDeserializer, Error as _, IntoDeserializer};
4use wasm_bindgen::{JsCast, JsValue, UnwrapThrowExt};
5
6struct ObjectAccess {
7    data: Array,
8    fields: core::slice::Iter<'static, &'static str>,
9    idx: u32,
10    next_value: Option<Deserializer>,
11}
12
13impl ObjectAccess {
14    fn new(data: Array, fields: &'static [&'static str]) -> Self {
15        // We start the index at 1, due to some js-of-ocaml expecting the first element to be 0
16        // this is due to OCaml implementation details.
17        Self {
18            data,
19            idx: 1,
20            fields: fields.iter(),
21            next_value: None,
22        }
23    }
24}
25
26fn str_deserializer(s: &str) -> de::value::StrDeserializer<Error> {
27    de::IntoDeserializer::into_deserializer(s)
28}
29
30impl<'de> de::MapAccess<'de> for ObjectAccess {
31    type Error = Error;
32
33    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
34        debug_assert!(self.next_value.is_none());
35
36        match self.fields.next() {
37            None => Ok(None),
38            Some(field) => {
39                self.next_value = Some(Deserializer::from(self.data.get(self.idx)));
40                self.idx += 1;
41                Ok(Some(seed.deserialize(str_deserializer(field))?))
42            }
43        }
44    }
45
46    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
47        seed.deserialize(self.next_value.take().unwrap_throw())
48    }
49}
50
51pub struct Deserializer(JsValue);
52
53// Can't use `serde_wasm_bindgen::de::Deserializer`, its `value` field is private.
54impl From<JsValue> for Deserializer {
55    fn from(value: JsValue) -> Self {
56        Self(value)
57    }
58}
59
60// Ideally this would be implemented for `JsValue` instead, but we can't because
61// of the orphan rule.
62impl<'de> IntoDeserializer<'de, Error> for Deserializer {
63    type Deserializer = Self;
64
65    fn into_deserializer(self) -> Self::Deserializer {
66        self
67    }
68}
69
70impl Deserializer {
71    fn as_bytes(&self) -> Option<Vec<u8>> {
72        if let Some(v) = self.0.dyn_ref::<Uint8Array>() {
73            Some(v.to_vec())
74        } else {
75            /* We can hit this case when the values have come from the non-serde conversions. */
76            self.0
77                .dyn_ref::<ArrayBuffer>()
78                .map(|v| Uint8Array::new(v).to_vec())
79        }
80    }
81}
82
83impl<'de> de::Deserializer<'de> for Deserializer {
84    type Error = Error;
85
86    fn deserialize_any<V: de::Visitor<'de>>(self, _: V) -> Result<V::Value> {
87        Err(Error::custom(
88            "Inferring the serialized type is not implemented",
89        ))
90    }
91
92    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
93        visitor.visit_unit()
94    }
95
96    fn deserialize_unit_struct<V: de::Visitor<'de>>(
97        self,
98        _: &'static str,
99        _: V,
100    ) -> Result<V::Value> {
101        Err(Error::custom(
102            "Deserializing unit structs is not implemented",
103        ))
104    }
105
106    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
107        let x = self.0.unchecked_into::<Number>().as_f64().unwrap() as u32;
108        visitor.visit_bool(x != 0)
109    }
110
111    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
112        visitor.visit_f32(self.0.unchecked_into::<Number>().as_f64().unwrap() as f32)
113    }
114
115    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
116        visitor.visit_f64(self.0.unchecked_into::<Number>().as_f64().unwrap())
117    }
118
119    fn deserialize_identifier<V: de::Visitor<'de>>(self, _: V) -> Result<V::Value> {
120        Err(Error::custom("Deserializing strings is not implemented"))
121    }
122
123    fn deserialize_str<V: de::Visitor<'de>>(self, _: V) -> Result<V::Value> {
124        Err(Error::custom("Deserializing strings is not implemented"))
125    }
126
127    fn deserialize_string<V: de::Visitor<'de>>(self, _: V) -> Result<V::Value> {
128        Err(Error::custom("Deserializing strings is not implemented"))
129    }
130
131    fn deserialize_i8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
132        visitor.visit_i8(self.0.unchecked_into::<Number>().as_f64().unwrap() as i8)
133    }
134
135    fn deserialize_i16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
136        visitor.visit_i16(self.0.unchecked_into::<Number>().as_f64().unwrap() as i16)
137    }
138
139    fn deserialize_i32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
140        visitor.visit_i32(self.0.unchecked_into::<Number>().as_f64().unwrap() as i32)
141    }
142
143    fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
144        visitor.visit_u8(self.0.unchecked_into::<Number>().as_f64().unwrap() as u8)
145    }
146
147    fn deserialize_u16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
148        visitor.visit_u16(self.0.unchecked_into::<Number>().as_f64().unwrap() as u16)
149    }
150
151    fn deserialize_u32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
152        visitor.visit_u32(self.0.unchecked_into::<Number>().as_f64().unwrap() as u32)
153    }
154
155    fn deserialize_i64<V: de::Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
156        Err(Error::custom("Deserializing i64 is not implemented"))
157    }
158
159    fn deserialize_u64<V: de::Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
160        Err(Error::custom("Deserializing u64 is not implemented"))
161    }
162
163    fn deserialize_i128<V: de::Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
164        Err(Error::custom("Deserializing i128 is not implemented"))
165    }
166
167    fn deserialize_u128<V: de::Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
168        Err(Error::custom("Deserializing u128 is not implemented"))
169    }
170
171    fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
172        visitor.visit_char((self.0.unchecked_into::<Number>().as_f64().unwrap() as u8) as char)
173    }
174
175    // Serde can deserialize `visit_unit` into `None`, but can't deserialize arbitrary value
176    // as `Some`, so we need to provide own simple implementation.
177    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
178        if let Ok(arr) = self.0.dyn_into::<Array>() {
179            visitor.visit_some(Into::<Deserializer>::into(arr.get(1)))
180        } else {
181            visitor.visit_none()
182        }
183    }
184
185    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
186        self,
187        _name: &'static str,
188        _visitor: V,
189    ) -> Result<V::Value> {
190        Err(Error::custom(
191            "Deserializing newtype structus is not implemented",
192        ))
193    }
194
195    fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
196        let arr = self.0.unchecked_into::<Array>();
197        visitor.visit_seq(SeqDeserializer::new(
198            arr.iter().skip(1).map(Deserializer::from),
199        ))
200    }
201
202    fn deserialize_tuple<V: de::Visitor<'de>>(self, _len: usize, visitor: V) -> Result<V::Value> {
203        self.deserialize_seq(visitor)
204    }
205
206    fn deserialize_tuple_struct<V: de::Visitor<'de>>(
207        self,
208        _name: &'static str,
209        _len: usize,
210        _visitor: V,
211    ) -> Result<V::Value> {
212        Err(Error::custom(
213            "Deserializing tuple structs is not implemented",
214        ))
215    }
216
217    fn deserialize_map<V: de::Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
218        Err(Error::custom("Deserializing maps is not implemented"))
219    }
220
221    fn deserialize_struct<V: de::Visitor<'de>>(
222        self,
223        _name: &'static str,
224        fields: &'static [&'static str],
225        visitor: V,
226    ) -> Result<V::Value> {
227        let arr = self.0.unchecked_into::<Array>();
228        visitor.visit_map(ObjectAccess::new(arr, fields))
229    }
230
231    fn deserialize_enum<V: de::Visitor<'de>>(
232        self,
233        _: &'static str,
234        _: &'static [&'static str],
235        _: V,
236    ) -> Result<V::Value> {
237        Err(Error::custom("Deserializing enums is not implemented"))
238    }
239
240    fn deserialize_ignored_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
241        visitor.visit_unit()
242    }
243
244    fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
245        self.deserialize_byte_buf(visitor)
246    }
247
248    fn deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
249        if let Some(bytes) = self.as_bytes() {
250            visitor.visit_byte_buf(bytes)
251        } else {
252            Err(Error::custom("Type error while deserializing bytes"))
253        }
254    }
255
256    #[inline]
257    fn is_human_readable(&self) -> bool {
258        false
259    }
260}
261
262impl<'de> de::VariantAccess<'de> for Deserializer {
263    type Error = Error;
264
265    fn unit_variant(self) -> Result<()> {
266        Err(Error::custom("Deserializing variants is not implemented"))
267    }
268
269    fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, _: T) -> Result<T::Value> {
270        Err(Error::custom("Deserializing variants is not implemented"))
271    }
272
273    fn tuple_variant<V: de::Visitor<'de>>(self, _: usize, _: V) -> Result<V::Value> {
274        Err(Error::custom("Deserializing variants is not implemented"))
275    }
276
277    fn struct_variant<V: de::Visitor<'de>>(
278        self,
279        _: &'static [&'static str],
280        _: V,
281    ) -> Result<V::Value> {
282        Err(Error::custom("Deserializing variants is not implemented"))
283    }
284}
plonk_wasm/wasm_ocaml_serde/de.rs

plonk_wasm/wasm_ocaml_serde/
de.rs
