valence_nbt/serde/
ser.rs

Help
1use std::hash::Hash;
2use std::marker::PhantomData;
3
4use serde::ser::{Impossible, SerializeMap, SerializeSeq, SerializeStruct};
5use serde::{Serialize, Serializer};
6
7use super::Error;
8use crate::conv::{i8_slice_as_u8_slice, u8_vec_into_i8_vec};
9use crate::{Compound, List, Value};
10
11impl<Str> Serialize for Value<Str>
12where
13    Str: Serialize + Ord + Hash,
14{
15    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
16    where
17        S: serde::Serializer,
18    {
19        match self {
20            Value::Byte(v) => serializer.serialize_i8(*v),
21            Value::Short(v) => serializer.serialize_i16(*v),
22            Value::Int(v) => serializer.serialize_i32(*v),
23            Value::Long(v) => serializer.serialize_i64(*v),
24            Value::Float(v) => serializer.serialize_f32(*v),
25            Value::Double(v) => serializer.serialize_f64(*v),
26            Value::ByteArray(v) => serializer.serialize_bytes(i8_slice_as_u8_slice(v)),
27            Value::String(v) => v.serialize(serializer),
28            Value::List(v) => v.serialize(serializer),
29            Value::Compound(v) => v.serialize(serializer),
30            Value::IntArray(v) => v.serialize(serializer),
31            Value::LongArray(v) => v.serialize(serializer),
32        }
33    }
34}
35
36impl<Str> Serialize for List<Str>
37where
38    Str: Serialize + Ord + Hash,
39{
40    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
41    where
42        S: serde::Serializer,
43    {
44        match self {
45            List::End => serializer.serialize_seq(Some(0))?.end(),
46            List::Byte(v) => v.serialize(serializer),
47            List::Short(v) => v.serialize(serializer),
48            List::Int(v) => v.serialize(serializer),
49            List::Long(v) => v.serialize(serializer),
50            List::Float(v) => v.serialize(serializer),
51            List::Double(v) => v.serialize(serializer),
52            List::ByteArray(v) => v.serialize(serializer),
53            List::String(v) => v.serialize(serializer),
54            List::List(v) => v.serialize(serializer),
55            List::Compound(v) => v.serialize(serializer),
56            List::IntArray(v) => v.serialize(serializer),
57            List::LongArray(v) => v.serialize(serializer),
58        }
59    }
60}
61
62macro_rules! unsupported {
63    ($lit:literal) => {
64        Err(Error::new_static(concat!("unsupported type: ", $lit)))
65    };
66}
67
68/// [`Serializer`] whose output is [`Compound`].
69#[derive(Debug)]
70pub struct CompoundSerializer;
71
72impl Serializer for CompoundSerializer {
73    type Ok = Compound;
74
75    type Error = Error;
76
77    type SerializeSeq = Impossible<Self::Ok, Self::Error>;
78
79    type SerializeTuple = Impossible<Self::Ok, Self::Error>;
80
81    type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
82
83    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
84
85    type SerializeMap = GenericSerializeMap<Self::Ok>;
86
87    type SerializeStruct = GenericSerializeStruct<Self::Ok>;
88
89    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
90
91    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
92        unsupported!("bool")
93    }
94
95    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
96        unsupported!("i8")
97    }
98
99    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
100        unsupported!("i16")
101    }
102
103    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
104        unsupported!("i32")
105    }
106
107    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
108        unsupported!("i64")
109    }
110
111    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
112        unsupported!("u8")
113    }
114
115    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
116        unsupported!("u16")
117    }
118
119    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
120        unsupported!("u32")
121    }
122
123    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
124        unsupported!("u64")
125    }
126
127    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
128        unsupported!("f32")
129    }
130
131    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
132        unsupported!("f64")
133    }
134
135    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
136        unsupported!("char")
137    }
138
139    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
140        unsupported!("str")
141    }
142
143    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
144        unsupported!("bytes")
145    }
146
147    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
148        unsupported!("none")
149    }
150
151    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
152    where
153        T: Serialize + ?Sized,
154    {
155        unsupported!("some")
156    }
157
158    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
159        unsupported!("unit")
160    }
161
162    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
163        unsupported!("unit struct")
164    }
165
166    fn serialize_unit_variant(
167        self,
168        _name: &'static str,
169        _variant_index: u32,
170        _variant: &'static str,
171    ) -> Result<Self::Ok, Self::Error> {
172        unsupported!("unit variant")
173    }
174
175    fn serialize_newtype_struct<T>(
176        self,
177        _name: &'static str,
178        _value: &T,
179    ) -> Result<Self::Ok, Self::Error>
180    where
181        T: Serialize + ?Sized,
182    {
183        unsupported!("newtype struct")
184    }
185
186    fn serialize_newtype_variant<T>(
187        self,
188        _name: &'static str,
189        _variant_index: u32,
190        _variant: &'static str,
191        _value: &T,
192    ) -> Result<Self::Ok, Self::Error>
193    where
194        T: Serialize + ?Sized,
195    {
196        unsupported!("newtype variant")
197    }
198
199    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
200        unsupported!("seq")
201    }
202
203    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
204        unsupported!("tuple")
205    }
206
207    fn serialize_tuple_struct(
208        self,
209        _name: &'static str,
210        _len: usize,
211    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
212        unsupported!("tuple struct")
213    }
214
215    fn serialize_tuple_variant(
216        self,
217        _name: &'static str,
218        _variant_index: u32,
219        _variant: &'static str,
220        _len: usize,
221    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
222        unsupported!("tuple variant")
223    }
224
225    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
226        Ok(GenericSerializeMap::new(len))
227    }
228
229    fn serialize_struct(
230        self,
231        _name: &'static str,
232        len: usize,
233    ) -> Result<Self::SerializeStruct, Self::Error> {
234        Ok(GenericSerializeStruct::new(len))
235    }
236
237    fn serialize_struct_variant(
238        self,
239        _name: &'static str,
240        _variant_index: u32,
241        _variant: &'static str,
242        _len: usize,
243    ) -> Result<Self::SerializeStructVariant, Self::Error> {
244        unsupported!("struct variant")
245    }
246}
247
248/// [`Serializer`] whose output is [`Value`].
249struct ValueSerializer;
250
251impl Serializer for ValueSerializer {
252    type Ok = Value;
253
254    type Error = Error;
255
256    type SerializeSeq = ValueSerializeSeq;
257
258    type SerializeTuple = Impossible<Self::Ok, Self::Error>;
259
260    type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
261
262    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
263
264    type SerializeMap = GenericSerializeMap<Self::Ok>;
265
266    type SerializeStruct = GenericSerializeStruct<Self::Ok>;
267
268    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
269
270    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
271        Ok(Value::Byte(v.into()))
272    }
273
274    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
275        Ok(Value::Byte(v))
276    }
277
278    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
279        Ok(Value::Short(v))
280    }
281
282    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
283        Ok(Value::Int(v))
284    }
285
286    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
287        Ok(Value::Long(v))
288    }
289
290    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
291        Ok(Value::Byte(v as i8))
292    }
293
294    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
295        Ok(Value::Short(v as i16))
296    }
297
298    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
299        Ok(Value::Int(v as i32))
300    }
301
302    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
303        Ok(Value::Long(v as i64))
304    }
305
306    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
307        Ok(Value::Float(v))
308    }
309
310    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
311        Ok(Value::Double(v))
312    }
313
314    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
315        Ok(Value::String(v.into()))
316    }
317
318    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
319        Ok(Value::String(v.into()))
320    }
321
322    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
323        Ok(Value::ByteArray(u8_vec_into_i8_vec(v.into())))
324    }
325
326    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
327        unsupported!("none")
328    }
329
330    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
331    where
332        T: Serialize + ?Sized,
333    {
334        value.serialize(self)
335    }
336
337    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
338        unsupported!("unit")
339    }
340
341    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
342        self.serialize_unit()
343    }
344
345    fn serialize_unit_variant(
346        self,
347        _name: &'static str,
348        _variant_index: u32,
349        variant: &'static str,
350    ) -> Result<Self::Ok, Self::Error> {
351        Ok(Value::String(variant.into()))
352    }
353
354    fn serialize_newtype_struct<T>(
355        self,
356        _name: &'static str,
357        value: &T,
358    ) -> Result<Self::Ok, Self::Error>
359    where
360        T: Serialize + ?Sized,
361    {
362        value.serialize(self)
363    }
364
365    fn serialize_newtype_variant<T>(
366        self,
367        _name: &'static str,
368        _variant_index: u32,
369        _variant: &'static str,
370        _value: &T,
371    ) -> Result<Self::Ok, Self::Error>
372    where
373        T: Serialize + ?Sized,
374    {
375        unsupported!("newtype variant")
376    }
377
378    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
379        Ok(ValueSerializeSeq::End {
380            len: len.unwrap_or(0),
381        })
382    }
383
384    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
385        unsupported!("tuple")
386    }
387
388    fn serialize_tuple_struct(
389        self,
390        _name: &'static str,
391        _len: usize,
392    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
393        unsupported!("tuple struct")
394    }
395
396    fn serialize_tuple_variant(
397        self,
398        _name: &'static str,
399        _variant_index: u32,
400        _variant: &'static str,
401        _len: usize,
402    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
403        unsupported!("tuple variant")
404    }
405
406    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
407        Ok(GenericSerializeMap::new(len))
408    }
409
410    fn serialize_struct(
411        self,
412        _name: &'static str,
413        len: usize,
414    ) -> Result<Self::SerializeStruct, Self::Error> {
415        Ok(GenericSerializeStruct::new(len))
416    }
417
418    fn serialize_struct_variant(
419        self,
420        _name: &'static str,
421        _variant_index: u32,
422        _variant: &'static str,
423        _len: usize,
424    ) -> Result<Self::SerializeStructVariant, Self::Error> {
425        unsupported!("struct variant")
426    }
427}
428
429enum ValueSerializeSeq {
430    End { len: usize },
431    Byte(Vec<i8>),
432    Short(Vec<i16>),
433    Int(Vec<i32>),
434    Long(Vec<i64>),
435    Float(Vec<f32>),
436    Double(Vec<f64>),
437    ByteArray(Vec<Vec<i8>>),
438    String(Vec<String>),
439    List(Vec<List>),
440    Compound(Vec<Compound>),
441    IntArray(Vec<Vec<i32>>),
442    LongArray(Vec<Vec<i64>>),
443}
444
445impl SerializeSeq for ValueSerializeSeq {
446    type Ok = Value;
447
448    type Error = Error;
449
450    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
451    where
452        T: Serialize + ?Sized,
453    {
454        macro_rules! serialize_variant {
455            ($variant:ident, $vec:ident, $elem:ident) => {{
456                match $elem.serialize(ValueSerializer)? {
457                    Value::$variant(val) => {
458                        $vec.push(val);
459                        Ok(())
460                    }
461                    _ => Err(Error::new_static(concat!(
462                        "heterogeneous NBT list (expected `",
463                        stringify!($variant),
464                        "` element)"
465                    ))),
466                }
467            }};
468        }
469
470        match self {
471            Self::End { len } => {
472                fn vec<T>(elem: T, len: usize) -> Vec<T> {
473                    let mut vec = Vec::with_capacity(len);
474                    vec.push(elem);
475                    vec
476                }
477
478                // Set the first element of the list.
479                *self = match value.serialize(ValueSerializer)? {
480                    Value::Byte(v) => Self::Byte(vec(v, *len)),
481                    Value::Short(v) => Self::Short(vec(v, *len)),
482                    Value::Int(v) => Self::Int(vec(v, *len)),
483                    Value::Long(v) => Self::Long(vec(v, *len)),
484                    Value::Float(v) => Self::Float(vec(v, *len)),
485                    Value::Double(v) => Self::Double(vec(v, *len)),
486                    Value::ByteArray(v) => Self::ByteArray(vec(v, *len)),
487                    Value::String(v) => Self::String(vec(v, *len)),
488                    Value::List(v) => Self::List(vec(v, *len)),
489                    Value::Compound(v) => Self::Compound(vec(v, *len)),
490                    Value::IntArray(v) => Self::IntArray(vec(v, *len)),
491                    Value::LongArray(v) => Self::LongArray(vec(v, *len)),
492                };
493                Ok(())
494            }
495            Self::Byte(v) => serialize_variant!(Byte, v, value),
496            Self::Short(v) => serialize_variant!(Short, v, value),
497            Self::Int(v) => serialize_variant!(Int, v, value),
498            Self::Long(v) => serialize_variant!(Long, v, value),
499            Self::Float(v) => serialize_variant!(Float, v, value),
500            Self::Double(v) => serialize_variant!(Double, v, value),
501            Self::ByteArray(v) => serialize_variant!(ByteArray, v, value),
502            Self::String(v) => serialize_variant!(String, v, value),
503            Self::List(v) => serialize_variant!(List, v, value),
504            Self::Compound(v) => serialize_variant!(Compound, v, value),
505            Self::IntArray(v) => serialize_variant!(IntArray, v, value),
506            Self::LongArray(v) => serialize_variant!(LongArray, v, value),
507        }
508    }
509
510    fn end(self) -> Result<Self::Ok, Self::Error> {
511        Ok(match self {
512            Self::End { .. } => List::End.into(),
513            Self::Byte(v) => v.into(),
514            Self::Short(v) => List::Short(v).into(),
515            Self::Int(v) => v.into(),
516            Self::Long(v) => List::Long(v).into(),
517            Self::Float(v) => List::Float(v).into(),
518            Self::Double(v) => List::Double(v).into(),
519            Self::ByteArray(v) => List::ByteArray(v).into(),
520            Self::String(v) => List::String(v).into(),
521            Self::List(v) => List::List(v).into(),
522            Self::Compound(v) => List::Compound(v).into(),
523            Self::IntArray(v) => List::IntArray(v).into(),
524            Self::LongArray(v) => List::LongArray(v).into(),
525        })
526    }
527}
528
529#[doc(hidden)]
530#[derive(Debug)]
531pub struct GenericSerializeMap<Ok> {
532    /// Temp storage for `serialize_key`.
533    key: Option<String>,
534    res: Compound,
535    _marker: PhantomData<Ok>,
536}
537
538impl<Ok> GenericSerializeMap<Ok> {
539    pub fn new(len: Option<usize>) -> Self {
540        Self {
541            key: None,
542            res: Compound::with_capacity(len.unwrap_or(0)),
543            _marker: PhantomData,
544        }
545    }
546}
547
548impl<Ok> SerializeMap for GenericSerializeMap<Ok>
549where
550    Compound: Into<Ok>,
551{
552    type Ok = Ok;
553
554    type Error = Error;
555
556    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
557    where
558        T: Serialize + ?Sized,
559    {
560        debug_assert!(
561            self.key.is_none(),
562            "call to `serialize_key` must be followed by `serialize_value`"
563        );
564
565        match key.serialize(ValueSerializer)? {
566            Value::String(s) => {
567                self.key = Some(s);
568                Ok(())
569            }
570            _ => Err(Error::new_static("invalid map key type (expected string)")),
571        }
572    }
573
574    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
575    where
576        T: Serialize + ?Sized,
577    {
578        let key = self
579            .key
580            .take()
581            .expect("missing previous call to `serialize_key`");
582        self.res.insert(key, value.serialize(ValueSerializer)?);
583        Ok(())
584    }
585
586    fn end(self) -> Result<Self::Ok, Self::Error> {
587        Ok(self.res.into())
588    }
589}
590
591#[doc(hidden)]
592#[derive(Debug)]
593pub struct GenericSerializeStruct<Ok> {
594    c: Compound,
595    _marker: PhantomData<Ok>,
596}
597
598impl<Ok> GenericSerializeStruct<Ok> {
599    fn new(len: usize) -> Self {
600        Self {
601            c: Compound::with_capacity(len),
602            _marker: PhantomData,
603        }
604    }
605}
606
607impl<Ok> SerializeStruct for GenericSerializeStruct<Ok>
608where
609    Compound: Into<Ok>,
610{
611    type Ok = Ok;
612
613    type Error = Error;
614
615    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
616    where
617        T: Serialize + ?Sized,
618    {
619        self.c.insert(key, value.serialize(ValueSerializer)?);
620        Ok(())
621    }
622
623    fn end(self) -> Result<Self::Ok, Self::Error> {
624        Ok(self.c.into())
625    }
626}
valence_nbt/serde/ser.rs

valence_nbt/serde/
ser.rs
