serde_buf/
de.rs

1use core::{fmt, marker::PhantomData};
2
3use alloc::{boxed::Box, string::ToString, vec};
4use serde::de::{self, Error as _, IntoDeserializer, Unexpected, Visitor};
5
6use crate::{Error, Owned, Ref, Value};
7
8impl de::Error for Error {
9    fn custom<T>(msg: T) -> Self
10    where
11        T: fmt::Display,
12    {
13        Error(msg.to_string())
14    }
15}
16
17/**
18A deserializer that produces values from buffers.
19
20This is the result of calling `into_deserializer` on [`Owned`] or [`Ref`].
21*/
22pub struct Deserializer<'de>(Value<'de>);
23
24impl<'de> de::Deserializer<'de> for Deserializer<'de> {
25    type Error = Error;
26
27    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
28    where
29        V: de::Visitor<'de>,
30    {
31        match self.0 {
32            Value::U8(v) => visitor.visit_u8(v),
33            Value::U16(v) => visitor.visit_u16(v),
34            Value::U32(v) => visitor.visit_u32(v),
35            Value::U64(v) => visitor.visit_u64(v),
36            Value::U128(v) => visitor.visit_u128(v),
37            Value::I8(v) => visitor.visit_i8(v),
38            Value::I16(v) => visitor.visit_i16(v),
39            Value::I32(v) => visitor.visit_i32(v),
40            Value::I64(v) => visitor.visit_i64(v),
41            Value::I128(v) => visitor.visit_i128(v),
42            Value::F32(v) => visitor.visit_f32(v),
43            Value::F64(v) => visitor.visit_f64(v),
44            Value::Bool(v) => visitor.visit_bool(v),
45            Value::Char(v) => visitor.visit_char(v),
46            Value::Str(v) => visitor.visit_string(v.into()),
47            Value::BorrowedStr(v) => visitor.visit_borrowed_str(v),
48            Value::Bytes(v) => visitor.visit_byte_buf(v.into_vec()),
49            Value::BorrowedBytes(v) => visitor.visit_borrowed_bytes(v),
50            Value::None => visitor.visit_none(),
51            Value::Some(v) => visitor.visit_some((*v).into_deserializer()),
52            Value::Unit => visitor.visit_unit(),
53            Value::UnitStruct { name: _ } => visitor.visit_unit(),
54            Value::NewtypeStruct { name: _, value } => {
55                visitor.visit_newtype_struct(Deserializer(*value))
56            }
57            Value::Struct { fields, name: _ } => visitor.visit_map(Map::new_str_key(fields)),
58            Value::TupleStruct { fields, name: _ } => visitor.visit_seq(Seq::new(fields)),
59            Value::Tuple(v) => visitor.visit_seq(Seq::new(v)),
60            Value::UnitVariant {
61                name: _,
62                variant_index,
63                variant,
64            } => visitor.visit_enum(Enum {
65                variant_index,
66                variant,
67                value: Variant::Value(Value::Unit),
68            }),
69            Value::NewtypeVariant {
70                name: _,
71                variant_index,
72                variant,
73                value,
74            } => visitor.visit_enum(Enum {
75                variant_index,
76                variant,
77                value: Variant::Value(*value),
78            }),
79            Value::TupleVariant {
80                name: _,
81                variant_index,
82                variant,
83                fields,
84            } => visitor.visit_enum(Enum {
85                variant_index,
86                variant,
87                value: Variant::Tuple(fields),
88            }),
89            Value::StructVariant {
90                name: _,
91                variant_index,
92                variant,
93                fields,
94            } => visitor.visit_enum(Enum {
95                variant_index,
96                variant,
97                value: Variant::Struct(fields),
98            }),
99            Value::Seq(v) => visitor.visit_seq(Seq::new(v)),
100            Value::Map(v) => visitor.visit_map(Map::new(v)),
101        }
102    }
103
104    serde::forward_to_deserialize_any! {
105        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
106        bytes byte_buf option unit unit_struct newtype_struct seq tuple
107        tuple_struct map struct enum identifier ignored_any
108    }
109}
110
111impl<'de> IntoDeserializer<'de, Error> for Owned {
112    type Deserializer = Deserializer<'de>;
113
114    fn into_deserializer(self) -> Self::Deserializer {
115        self.0.into_deserializer()
116    }
117}
118
119impl<'de> IntoDeserializer<'de, Error> for Ref<'de> {
120    type Deserializer = Deserializer<'de>;
121
122    fn into_deserializer(self) -> Self::Deserializer {
123        self.0.into_deserializer()
124    }
125}
126
127impl<'de> IntoDeserializer<'de, Error> for Value<'de> {
128    type Deserializer = Deserializer<'de>;
129
130    fn into_deserializer(self) -> Self::Deserializer {
131        Deserializer(self)
132    }
133}
134
135struct Seq<'de>(vec::IntoIter<Value<'de>>);
136
137impl<'de> Seq<'de> {
138    fn new(fields: Box<[Value<'de>]>) -> Self {
139        Seq(fields.into_vec().into_iter())
140    }
141}
142
143impl<'de> de::SeqAccess<'de> for Seq<'de> {
144    type Error = Error;
145
146    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
147    where
148        T: de::DeserializeSeed<'de>,
149    {
150        self.0
151            .next()
152            .map(|field| seed.deserialize(Deserializer(field)))
153            .transpose()
154    }
155}
156
157struct Map<'de, K: IntoDeserializer<'de, E>, E: de::Error> {
158    remaining: vec::IntoIter<(K, Value<'de>)>,
159    value: Option<Value<'de>>,
160    _m: PhantomData<E>,
161}
162
163impl<'de> Map<'de, &'de str, de::value::Error> {
164    fn new_str_key(fields: Box<[(&'de str, Value<'de>)]>) -> Self {
165        Map::new(fields)
166    }
167}
168
169impl<'de, K: IntoDeserializer<'de, E>, E: de::Error> Map<'de, K, E> {
170    fn new(fields: Box<[(K, Value<'de>)]>) -> Self {
171        Map {
172            remaining: fields.into_vec().into_iter(),
173            value: None,
174            _m: PhantomData,
175        }
176    }
177}
178
179impl<'de, K: IntoDeserializer<'de, E>, E: de::Error> de::MapAccess<'de> for Map<'de, K, E> {
180    type Error = Error;
181
182    fn next_key_seed<D>(&mut self, seed: D) -> Result<Option<D::Value>, Self::Error>
183    where
184        D: de::DeserializeSeed<'de>,
185    {
186        if let Some((k, v)) = self.remaining.next() {
187            self.value = Some(v);
188
189            Ok(Some(
190                seed.deserialize(k.into_deserializer())
191                    .map_err(Error::custom)?,
192            ))
193        } else {
194            Ok(None)
195        }
196    }
197
198    fn next_value_seed<D>(&mut self, seed: D) -> Result<D::Value, Self::Error>
199    where
200        D: de::DeserializeSeed<'de>,
201    {
202        seed.deserialize(Deserializer(
203            self.value
204                .take()
205                .ok_or_else(|| Error::custom("missing map value"))?,
206        ))
207    }
208}
209
210struct Enum<'de> {
211    variant_index: u32,
212    variant: &'static str,
213    value: Variant<'de>,
214}
215
216enum Variant<'de> {
217    Value(Value<'de>),
218    Tuple(Box<[Value<'de>]>),
219    Struct(Box<[(&'static str, Value<'de>)]>),
220}
221
222impl<'de> de::EnumAccess<'de> for Enum<'de> {
223    type Error = Error;
224
225    type Variant = Self;
226
227    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
228    where
229        V: de::DeserializeSeed<'de>,
230    {
231        Ok((
232            seed.deserialize(Deserializer(Value::U32(self.variant_index)))?,
233            self,
234        ))
235    }
236}
237
238impl<'de> de::VariantAccess<'de> for Enum<'de> {
239    type Error = Error;
240
241    fn unit_variant(self) -> Result<(), Self::Error> {
242        match self.value {
243            Variant::Value(Value::Unit) => Ok(()),
244            Variant::Value(_) => Err(Error::invalid_type(
245                Unexpected::UnitVariant,
246                &"newtype variant",
247            )),
248            Variant::Tuple(_) => Err(Error::invalid_type(
249                Unexpected::UnitVariant,
250                &"tuple variant",
251            )),
252            Variant::Struct(_) => Err(Error::invalid_type(
253                Unexpected::UnitVariant,
254                &"struct variant",
255            )),
256        }
257    }
258
259    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
260    where
261        T: de::DeserializeSeed<'de>,
262    {
263        let value = match self.value {
264            Variant::Value(v) => v,
265            Variant::Tuple(v) => Value::Tuple(v),
266            Variant::Struct(v) => Value::Struct {
267                name: self.variant,
268                fields: v,
269            },
270        };
271
272        seed.deserialize(Deserializer(value))
273    }
274
275    fn tuple_variant<V>(self, _: usize, visitor: V) -> Result<V::Value, Self::Error>
276    where
277        V: Visitor<'de>,
278    {
279        match self.value {
280            Variant::Tuple(v) => visitor.visit_seq(Seq::new(v)),
281            Variant::Value(Value::Unit) => Err(Error::invalid_type(
282                Unexpected::UnitVariant,
283                &"tuple variant",
284            )),
285            Variant::Value(_) => Err(Error::invalid_type(
286                Unexpected::NewtypeVariant,
287                &"tuple variant",
288            )),
289            Variant::Struct(_) => Err(Error::invalid_type(
290                Unexpected::StructVariant,
291                &"tuple variant",
292            )),
293        }
294    }
295
296    fn struct_variant<V>(
297        self,
298        _: &'static [&'static str],
299        visitor: V,
300    ) -> Result<V::Value, Self::Error>
301    where
302        V: Visitor<'de>,
303    {
304        match self.value {
305            Variant::Struct(v) => visitor.visit_map(Map::new_str_key(v)),
306            Variant::Value(Value::Unit) => Err(Error::invalid_type(
307                Unexpected::UnitVariant,
308                &"struct variant",
309            )),
310            Variant::Value(_) => Err(Error::invalid_type(
311                Unexpected::NewtypeVariant,
312                &"struct variant",
313            )),
314            Variant::Tuple(_) => Err(Error::invalid_type(
315                Unexpected::TupleVariant,
316                &"struct variant",
317            )),
318        }
319    }
320}
serde_buf/de.rs

serde_buf/
de.rs
