valence_nbt/serde/
de.rs

Help
1use std::fmt;
2use std::hash::Hash;
3use std::marker::PhantomData;
4
5use serde::de::value::{
6    MapAccessDeserializer, MapDeserializer, SeqAccessDeserializer, StrDeserializer,
7    StringDeserializer,
8};
9use serde::de::{self, IntoDeserializer, SeqAccess, Visitor};
10use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
11
12use super::Error;
13use crate::conv::{i8_vec_into_u8_vec, u8_slice_as_i8_slice, u8_vec_into_i8_vec};
14use crate::{Compound, List, Value};
15
16impl<'de, S> Deserialize<'de> for Value<S>
17where
18    S: Deserialize<'de> + Ord + Hash,
19{
20    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
21    where
22        D: Deserializer<'de>,
23    {
24        struct ValueVisitor<S>(PhantomData<S>);
25
26        impl<'de, S> Visitor<'de> for ValueVisitor<S>
27        where
28            S: Deserialize<'de> + Ord + Hash,
29        {
30            type Value = Value<S>;
31
32            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
33                write!(formatter, "a valid NBT type")
34            }
35
36            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
37            where
38                E: de::Error,
39            {
40                Ok(Value::Byte(v.into()))
41            }
42
43            fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
44            where
45                E: de::Error,
46            {
47                Ok(Value::Byte(v))
48            }
49
50            fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
51            where
52                E: de::Error,
53            {
54                Ok(Value::Short(v))
55            }
56
57            fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
58            where
59                E: de::Error,
60            {
61                Ok(Value::Int(v))
62            }
63
64            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
65            where
66                E: de::Error,
67            {
68                Ok(Value::Long(v))
69            }
70
71            fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
72            where
73                E: de::Error,
74            {
75                Ok(Value::Byte(v as i8))
76            }
77
78            fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
79            where
80                E: de::Error,
81            {
82                Ok(Value::Short(v as i16))
83            }
84
85            fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
86            where
87                E: de::Error,
88            {
89                Ok(Value::Int(v as i32))
90            }
91
92            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
93            where
94                E: de::Error,
95            {
96                Ok(Value::Long(v as i64))
97            }
98
99            fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
100            where
101                E: de::Error,
102            {
103                Ok(Value::Float(v))
104            }
105
106            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
107            where
108                E: de::Error,
109            {
110                Ok(Value::Double(v))
111            }
112
113            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
114            where
115                E: de::Error,
116            {
117                S::deserialize(StrDeserializer::new(v)).map(Value::String)
118            }
119
120            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
121            where
122                E: de::Error,
123            {
124                S::deserialize(StringDeserializer::new(v)).map(Value::String)
125            }
126
127            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
128            where
129                E: de::Error,
130            {
131                Ok(Value::ByteArray(u8_slice_as_i8_slice(v).into()))
132            }
133
134            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
135            where
136                E: de::Error,
137            {
138                Ok(Value::ByteArray(u8_vec_into_i8_vec(v)))
139            }
140
141            fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
142            where
143                A: de::SeqAccess<'de>,
144            {
145                Ok(List::deserialize(SeqAccessDeserializer::new(seq))?.into())
146            }
147
148            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
149            where
150                A: de::MapAccess<'de>,
151            {
152                Ok(Compound::deserialize(MapAccessDeserializer::new(map))?.into())
153            }
154        }
155
156        deserializer.deserialize_any(ValueVisitor::<S>(PhantomData))
157    }
158}
159
160impl<'de, S> Deserialize<'de> for List<S>
161where
162    S: Deserialize<'de> + Ord + Hash,
163{
164    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
165    where
166        D: Deserializer<'de>,
167    {
168        struct ListVisitor<S>(PhantomData<S>);
169
170        impl<'de, S> Visitor<'de> for ListVisitor<S>
171        where
172            S: Deserialize<'de> + Ord + Hash,
173        {
174            type Value = List<S>;
175
176            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
177                write!(formatter, "a sequence or bytes")
178            }
179
180            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
181            where
182                A: de::SeqAccess<'de>,
183            {
184                match seq.next_element::<Value<S>>()? {
185                    Some(v) => match v {
186                        Value::Byte(v) => deserialize_seq_remainder(v, seq, From::from),
187                        Value::Short(v) => deserialize_seq_remainder(v, seq, From::from),
188                        Value::Int(v) => deserialize_seq_remainder(v, seq, From::from),
189                        Value::Long(v) => deserialize_seq_remainder(v, seq, From::from),
190                        Value::Float(v) => deserialize_seq_remainder(v, seq, From::from),
191                        Value::Double(v) => deserialize_seq_remainder(v, seq, From::from),
192                        Value::ByteArray(v) => deserialize_seq_remainder(v, seq, From::from),
193                        Value::String(v) => deserialize_seq_remainder(v, seq, List::String),
194                        Value::List(v) => deserialize_seq_remainder(v, seq, From::from),
195                        Value::Compound(v) => deserialize_seq_remainder(v, seq, From::from),
196                        Value::IntArray(v) => deserialize_seq_remainder(v, seq, From::from),
197                        Value::LongArray(v) => deserialize_seq_remainder(v, seq, From::from),
198                    },
199                    None => Ok(List::End),
200                }
201            }
202
203            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
204            where
205                E: de::Error,
206            {
207                Ok(List::Byte(u8_vec_into_i8_vec(v)))
208            }
209
210            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
211            where
212                E: de::Error,
213            {
214                Ok(List::Byte(u8_slice_as_i8_slice(v).into()))
215            }
216        }
217
218        deserializer.deserialize_seq(ListVisitor::<S>(PhantomData))
219    }
220}
221
222/// Deserializes the remainder of a sequence after having
223/// determined the type of the first element.
224fn deserialize_seq_remainder<'de, T, A, S, C>(
225    first: T,
226    mut seq: A,
227    conv: C,
228) -> Result<List<S>, A::Error>
229where
230    T: Deserialize<'de>,
231    A: de::SeqAccess<'de>,
232    C: FnOnce(Vec<T>) -> List<S>,
233{
234    let mut vec = match seq.size_hint() {
235        Some(n) => Vec::with_capacity(n + 1),
236        None => Vec::new(),
237    };
238
239    vec.push(first);
240
241    while let Some(v) = seq.next_element()? {
242        vec.push(v);
243    }
244
245    Ok(conv(vec))
246}
247
248impl<'de> Deserializer<'de> for Compound {
249    type Error = Error;
250
251    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
252    where
253        V: Visitor<'de>,
254    {
255        visitor.visit_map(MapDeserializer::new(self.into_iter()))
256    }
257
258    forward_to_deserialize_any! {
259        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
260        bytes byte_buf option unit unit_struct newtype_struct seq tuple
261        tuple_struct map struct enum identifier ignored_any
262    }
263}
264
265impl IntoDeserializer<'_, Error> for Compound {
266    type Deserializer = Self;
267
268    fn into_deserializer(self) -> Self::Deserializer {
269        self
270    }
271}
272
273impl<'de> Deserializer<'de> for Value {
274    type Error = Error;
275
276    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
277    where
278        V: Visitor<'de>,
279    {
280        match self {
281            Value::Byte(v) => visitor.visit_i8(v),
282            Value::Short(v) => visitor.visit_i16(v),
283            Value::Int(v) => visitor.visit_i32(v),
284            Value::Long(v) => visitor.visit_i64(v),
285            Value::Float(v) => visitor.visit_f32(v),
286            Value::Double(v) => visitor.visit_f64(v),
287            Value::ByteArray(v) => visitor.visit_byte_buf(i8_vec_into_u8_vec(v)),
288            Value::String(v) => visitor.visit_string(v),
289            Value::List(v) => v.deserialize_any(visitor),
290            Value::Compound(v) => v.into_deserializer().deserialize_any(visitor),
291            Value::IntArray(v) => v.into_deserializer().deserialize_any(visitor),
292            Value::LongArray(v) => v.into_deserializer().deserialize_any(visitor),
293        }
294    }
295
296    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
297    where
298        V: Visitor<'de>,
299    {
300        match self {
301            Value::Byte(b) => visitor.visit_bool(b != 0),
302            _ => self.deserialize_any(visitor),
303        }
304    }
305
306    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
307    where
308        V: Visitor<'de>,
309    {
310        visitor.visit_some(self)
311    }
312
313    fn deserialize_enum<V>(
314        self,
315        _name: &'static str,
316        _variants: &'static [&'static str],
317        visitor: V,
318    ) -> Result<V::Value, Self::Error>
319    where
320        V: Visitor<'de>,
321    {
322        match self {
323            Value::String(s) => visitor.visit_enum(s.into_deserializer()), // Unit variant.
324            other => other.deserialize_any(visitor),
325        }
326    }
327
328    forward_to_deserialize_any! {
329        i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
330        bytes byte_buf unit unit_struct newtype_struct seq tuple
331        tuple_struct map struct identifier ignored_any
332    }
333}
334
335impl IntoDeserializer<'_, Error> for Value {
336    type Deserializer = Self;
337
338    fn into_deserializer(self) -> Self::Deserializer {
339        self
340    }
341}
342
343impl<'de> Deserializer<'de> for List {
344    type Error = Error;
345
346    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
347    where
348        V: Visitor<'de>,
349    {
350        struct EndSeqAccess;
351
352        impl<'de> SeqAccess<'de> for EndSeqAccess {
353            type Error = Error;
354
355            fn next_element_seed<T>(&mut self, _seed: T) -> Result<Option<T::Value>, Self::Error>
356            where
357                T: de::DeserializeSeed<'de>,
358            {
359                Ok(None)
360            }
361        }
362
363        match self {
364            List::End => visitor.visit_seq(EndSeqAccess),
365            List::Byte(v) => visitor.visit_byte_buf(i8_vec_into_u8_vec(v)),
366            List::Short(v) => v.into_deserializer().deserialize_any(visitor),
367            List::Int(v) => v.into_deserializer().deserialize_any(visitor),
368            List::Long(v) => v.into_deserializer().deserialize_any(visitor),
369            List::Float(v) => v.into_deserializer().deserialize_any(visitor),
370            List::Double(v) => v.into_deserializer().deserialize_any(visitor),
371            List::ByteArray(v) => v.into_deserializer().deserialize_any(visitor),
372            List::String(v) => v.into_deserializer().deserialize_any(visitor),
373            List::List(v) => v.into_deserializer().deserialize_any(visitor),
374            List::Compound(v) => v.into_deserializer().deserialize_any(visitor),
375            List::IntArray(v) => v.into_deserializer().deserialize_any(visitor),
376            List::LongArray(v) => v.into_deserializer().deserialize_any(visitor),
377        }
378    }
379
380    forward_to_deserialize_any! {
381        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
382        bytes byte_buf option unit unit_struct newtype_struct seq tuple
383        tuple_struct map struct enum identifier ignored_any
384    }
385}
386
387impl IntoDeserializer<'_, Error> for List {
388    type Deserializer = Self;
389
390    fn into_deserializer(self) -> Self::Deserializer {
391        self
392    }
393}
valence_nbt/serde/de.rs

valence_nbt/serde/
de.rs
