serde_object/
lib.rs

1pub mod assistant;
2pub mod serializer;
3
4use {
5    assistant::{EnumAssistant, Seed, VariantKind},
6    serde::{
7        de::{self, Deserializer as _, IntoDeserializer as _, VariantAccess as _},
8        forward_to_deserialize_any,
9        ser::{
10            self, SerializeMap as _, SerializeStruct as _, SerializeStructVariant as _,
11            SerializeTuple as _, SerializeTupleStruct as _, SerializeTupleVariant as _,
12        },
13        serde_if_integer128,
14    },
15    std::{borrow::Cow, marker::PhantomData},
16    try_match::try_match,
17    wyz::pipe::Pipe as _,
18};
19
20/// Represents a Serde data model value, losslessly.  
21/// See <https://serde.rs/data-model.html> for more information.
22///
23/// # Limitations
24///
25/// - There is no way for Deserializers to hint what kind of enum variant they have available, so an [assistant] must be provided to support deserialising them at all.  
26///   (Libraries can provide plug-in support here, which makes it possible to deserialize enum variants without specifying an assistant consumer-side.)
27///
28/// # Leaks
29///
30/// Some memory is leaked when:
31///
32/// - a UnitStruct is serialized (for its name).
33/// - a UnitVariant is serialized (for its name and variant).
34/// - a NewtypeStruct is serialized (for its name).
35/// - a NewtypeVariant is serialized (for its name and variant).
36/// - a TupleStruct is serialized (for its name).
37/// - a TupleVariant is serialized (for its name and variant).
38/// - a Struct is serialized (for its name and each of its field keys).
39/// - a StructVariant is **deserialized** (for its field keys).
40///
41/// TODO: Organise storage for these and add a way to clear it.
42#[derive(Debug)]
43pub enum Object<'a> {
44    Bool(bool),
45
46    I8(i8),
47    I16(i16),
48    I32(i32),
49    I64(i64),
50    I128(i128),
51
52    U8(u8),
53    U16(u16),
54    U32(u32),
55    U64(u64),
56    U128(u128),
57
58    F32(f32),
59    F64(f64),
60
61    Char(char),
62
63    String(Cow<'a, str>),
64
65    ByteArray(Cow<'a, [u8]>),
66
67    Option(Option<Box<Object<'a>>>),
68
69    Unit,
70
71    UnitStruct {
72        name: Cow<'a, str>,
73    },
74
75    UnitVariant {
76        name: Cow<'a, str>,
77        variant: Box<Object<'a>>,
78    },
79
80    NewtypeStruct {
81        name: Cow<'a, str>,
82        value: Box<Object<'a>>,
83    },
84
85    NewtypeVariant {
86        name: Cow<'a, str>,
87        variant: Box<Object<'a>>,
88        value: Box<Object<'a>>,
89    },
90
91    Seq(Vec<Object<'a>>),
92
93    Tuple(Vec<Object<'a>>),
94
95    TupleStruct {
96        name: Cow<'a, str>,
97        fields: Vec<Object<'a>>,
98    },
99
100    TupleVariant {
101        name: Cow<'a, str>,
102        variant: Box<Object<'a>>,
103        fields: Box<Object<'a>>,
104    },
105
106    /// This variant does not care whether keys are duplicated.  
107    /// Formats might mind it.
108    Map(Vec<(Object<'a>, Object<'a>)>),
109
110    /// This variant may store duplicate fields.
111    /// Formats may have a problem with it.
112    Struct {
113        name: Cow<'a, str>,
114        fields: Vec<(Cow<'a, str>, Option<Object<'a>>)>,
115    },
116
117    /// This variant may store duplicate fields.
118    /// Formats may have a problem with it.
119    StructVariant {
120        name: Cow<'a, str>,
121        variant: Box<Object<'a>>,
122        fields: Box<Object<'a>>,
123    },
124
125    /// Created by [`Serializer`].  
126    /// Serialized as string or [`u32`] depending on the target [`ser::Serializer::is_human_readable()`].
127    DualVariantKey {
128        index: u32,
129        name: Cow<'a, str>,
130    },
131
132    /// Created by [`Serializer`] when serializing struct variants.  
133    /// Like [`Map`], but fields may be skipped.
134    FieldMap(Vec<(Object<'a>, Option<Object<'a>>)>),
135}
136
137impl<'a> Object<'a> {
138    pub fn into_owned(self) -> Object<'static> {
139        match self {
140            Object::Bool(bool) => Object::Bool(bool),
141
142            Object::I8(i8) => Object::I8(i8),
143            Object::I16(i16) => Object::I16(i16),
144            Object::I32(i32) => Object::I32(i32),
145            Object::I64(i64) => Object::I64(i64),
146            Object::I128(i128) => Object::I128(i128),
147
148            Object::U8(u8) => Object::U8(u8),
149            Object::U16(u16) => Object::U16(u16),
150            Object::U32(u32) => Object::U32(u32),
151            Object::U64(u64) => Object::U64(u64),
152            Object::U128(u128) => Object::U128(u128),
153
154            Object::F32(f32) => Object::F32(f32),
155            Object::F64(f64) => Object::F64(f64),
156
157            Object::Char(char) => Object::Char(char),
158
159            Object::String(string) => Object::String(string.into_owned().into()),
160
161            Object::ByteArray(bytes) => Object::ByteArray(bytes.into_owned().into()),
162
163            Object::Option(option) => Object::Option(option.map(|b| b.into_owned().into())),
164
165            Object::Unit => Object::Unit,
166
167            Object::UnitStruct { name } => Object::UnitStruct {
168                name: name.into_owned().into(),
169            },
170
171            Object::UnitVariant { name, variant } => Object::UnitVariant {
172                name: name.into_owned().into(),
173                variant: variant.into_owned().into(),
174            },
175
176            Object::NewtypeStruct { name, value } => Object::NewtypeStruct {
177                name: name.into_owned().into(),
178                value: value.into_owned().into(),
179            },
180            Object::NewtypeVariant {
181                name,
182                variant,
183                value,
184            } => Object::NewtypeVariant {
185                name: name.into_owned().into(),
186                variant: variant.into_owned().into(),
187                value: value.into_owned().into(),
188            },
189
190            Object::Seq(elements) => {
191                Object::Seq(elements.into_iter().map(Object::into_owned).collect())
192            }
193
194            Object::Tuple(fields) => {
195                Object::Seq(fields.into_iter().map(Object::into_owned).collect())
196            }
197
198            Object::TupleStruct { name, fields } => Object::TupleStruct {
199                name: name.into_owned().into(),
200                fields: fields.into_iter().map(Object::into_owned).collect(),
201            },
202
203            Object::TupleVariant {
204                name,
205                variant,
206                fields,
207            } => Object::TupleVariant {
208                name: name.into_owned().into(),
209                variant: variant.into_owned().into(),
210                fields: fields.into_owned().into(),
211            },
212
213            Object::Map(fields) => Object::Map(
214                fields
215                    .into_iter()
216                    .map(|(k, v)| (k.into_owned(), v.into_owned()))
217                    .collect(),
218            ),
219
220            Object::Struct { name, fields } => Object::Struct {
221                name: name.into_owned().into(),
222                fields: fields
223                    .into_iter()
224                    .map(|(k, v)| (k.into_owned().into(), v.map(Object::into_owned)))
225                    .collect(),
226            },
227
228            Object::StructVariant {
229                name,
230                variant,
231                fields,
232            } => Object::StructVariant {
233                name: name.into_owned().into(),
234                variant: variant.into_owned().into(),
235                fields: fields.into_owned().into(),
236            },
237
238            Object::DualVariantKey { index, name } => Object::DualVariantKey {
239                index,
240                name: name.into_owned().into(),
241            },
242
243            Object::FieldMap(fields) => Object::FieldMap(
244                fields
245                    .into_iter()
246                    .map(|(k, v)| (k.into_owned(), v.map(Object::into_owned)))
247                    .collect(),
248            ),
249        }
250    }
251}
252
253impl<'a> ser::Serialize for Object<'a> {
254    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
255    where
256        S: ser::Serializer,
257    {
258        match self {
259            Object::Bool(bool) => serializer.serialize_bool(*bool),
260
261            Object::I8(i8) => serializer.serialize_i8(*i8),
262            Object::I16(i16) => serializer.serialize_i16(*i16),
263            Object::I32(i32) => serializer.serialize_i32(*i32),
264            Object::I64(i64) => serializer.serialize_i64(*i64),
265            Object::I128(i128) => serializer.serialize_i128(*i128),
266
267            Object::U8(u8) => serializer.serialize_u8(*u8),
268            Object::U16(u16) => serializer.serialize_u16(*u16),
269            Object::U32(u32) => serializer.serialize_u32(*u32),
270            Object::U64(u64) => serializer.serialize_u64(*u64),
271            Object::U128(u128) => serializer.serialize_u128(*u128),
272
273            Object::F32(f32) => serializer.serialize_f32(*f32),
274            Object::F64(f64) => serializer.serialize_f64(*f64),
275
276            Object::Char(char) => serializer.serialize_char(*char),
277
278            Object::String(cow) => serializer.serialize_str(cow),
279
280            Object::ByteArray(cow) => serializer.serialize_bytes(cow),
281
282            Object::Option(option) => match option {
283                Some(object) => serializer.serialize_some(object),
284                None => serializer.serialize_none(),
285            },
286
287            Object::Unit => serializer.serialize_unit(),
288
289            Object::UnitStruct { name } => serializer.serialize_unit_struct(leak_str(name)),
290
291            Object::UnitVariant { name, variant } => serializer.serialize_unit_variant(
292                leak_str(name),
293                make_variant_index(variant),
294                make_variant_name(variant)?,
295            ),
296
297            Object::NewtypeStruct { name, value } => {
298                serializer.serialize_newtype_struct(leak_str(name), value)
299            }
300
301            Object::NewtypeVariant {
302                name,
303                variant,
304                value,
305            } => serializer.serialize_newtype_variant(
306                leak_str(name),
307                make_variant_index(variant),
308                make_variant_name(variant)?,
309                value,
310            ),
311
312            Object::Seq(vec) => serializer.collect_seq(vec.iter()),
313
314            Object::Tuple(vec) => {
315                let mut serializer = serializer.serialize_tuple(vec.len())?;
316                for element in vec {
317                    serializer.serialize_element(element)?
318                }
319                serializer.end()
320            }
321
322            Object::TupleStruct { name, fields } => {
323                let mut serializer =
324                    serializer.serialize_tuple_struct(leak_str(name), fields.len())?;
325                for field in fields {
326                    serializer.serialize_field(field)?
327                }
328                serializer.end()
329            }
330
331            Object::TupleVariant {
332                name,
333                variant,
334                fields,
335            } => {
336                let mut serializer = serializer.serialize_tuple_variant(
337                    leak_str(name),
338                    make_variant_index(variant),
339                    make_variant_name(variant)?,
340                    match Box::as_ref(fields) {
341                        Object::String(cow) => cow.as_ref().len(),
342                        Object::ByteArray(cow) => cow.as_ref().len(),
343                        Object::Seq(vec) | Object::Tuple(vec) => vec.len(),
344                        Object::Map(vec) => vec.len(),
345                        _ => return Err(ser::Error::custom("Tried to serialise a tuple variant, but couldn't figure out the field count."))
346                    },
347                )?;
348
349                match Box::as_ref(fields) {
350                    Object::String(cow) => {
351                        for value in cow.chars() {
352                            serializer.serialize_field(&value)?
353                        }
354                    }
355                    Object::ByteArray(cow) => {
356                        for value in cow.iter() {
357                            serializer.serialize_field(value)?
358                        }
359                    }
360                    Object::Seq(vec) | Object::Tuple(vec) => {
361                        for value in vec.iter() {
362                            serializer.serialize_field(value)?
363                        }
364                    }
365                    Object::Map(vec) => {
366                        for value in vec.iter() {
367                            serializer.serialize_field(value)?
368                        }
369                    }
370                    _ => unreachable!(),
371                }
372                serializer.end()
373            }
374
375            Object::Map(pairs) => {
376                let mut serialize_map = serializer.serialize_map(pairs.len().into())?;
377                for (k, v) in pairs {
378                    serialize_map.serialize_entry(k, v)?
379                }
380                serialize_map.end()
381            }
382
383            Object::Struct { name, fields } => {
384                let mut serializer = serializer.serialize_struct(leak_str(name), fields.len())?;
385                for (key, value) in fields {
386                    if let Some(value) = value.as_ref() {
387                        serializer.serialize_field(leak_str(key), value)?
388                    } else {
389                        serializer.skip_field(leak_str(key))?
390                    }
391                }
392                serializer.end()
393            }
394
395            Object::StructVariant {
396                name,
397                variant,
398                fields,
399            } => {
400                let mut serializer = serializer.serialize_struct_variant(
401                    leak_str(name),
402                    make_variant_index(variant),
403                    make_variant_name(variant)?,
404                    match Box::as_ref(fields) {
405                        Object::String(cow) => cow.as_ref().len(),
406                        Object::ByteArray(cow) => cow.as_ref().len(),
407                        Object::Seq(vec) | Object::Tuple(vec) => vec.len(),
408                        Object::Map(vec) => vec.len(),
409                        Object::FieldMap(vec) => vec.len(),
410                        _ => return Err(ser::Error::custom("Tried to serialise a struct variant, but couldn't figure out the field count."))
411                    },
412                )?;
413
414                match Box::as_ref(fields) {
415                    Object::String(cow) => {
416                        for (key, value) in cow.chars().enumerate() {
417                            serializer
418                                .serialize_field(leak_str(key.to_string().as_ref()), &value)?
419                        }
420                    }
421                    Object::ByteArray(cow) => {
422                        for (key, value) in cow.iter().enumerate() {
423                            serializer.serialize_field(leak_str(key.to_string().as_ref()), value)?
424                        }
425                    }
426                    Object::Seq(vec) | Object::Tuple(vec) => {
427                        for (key, value) in vec.iter().enumerate() {
428                            serializer.serialize_field(leak_str(key.to_string().as_ref()), value)?
429                        }
430                    }
431                    Object::Map(vec) => {
432                        for (key, value) in vec.iter() {
433                            serializer.serialize_field(make_field_key(key)?, value)?
434                        }
435                    }
436                    Object::FieldMap(vec) => {
437                        for (key, value) in vec.iter() {
438                            let key = make_field_key(key)?;
439                            if let Some(value) = value {
440                                serializer.serialize_field(key, value)?
441                            } else {
442                                serializer.skip_field(key)?
443                            }
444                        }
445                    }
446                    _ => unreachable!(),
447                }
448                serializer.end()
449            }
450
451            Object::DualVariantKey { index, name } => {
452                if serializer.is_human_readable() {
453                    serializer.serialize_str(name)
454                } else {
455                    serializer.serialize_u32(*index)
456                }
457            }
458
459            Object::FieldMap(map) => {
460                serializer.collect_map(map.iter().filter_map(|(k, v)| v.as_ref().map(|v| (k, v))))
461            }
462        }
463    }
464}
465
466fn make_variant_index<'a>(variant: impl AsRef<Object<'a>>) -> u32 {
467    match variant.as_ref() {
468        Object::U8(u8) => *u8 as u32,
469        Object::U16(u16) => *u16 as u32,
470        Object::U32(u32) => *u32,
471        _ => u32::MAX,
472    }
473}
474
475fn make_variant_name<'a, E: ser::Error>(
476    variant: impl AsRef<Object<'a>>,
477) -> Result<&'static str, E> {
478    leak_str(
479        match variant.as_ref() {
480            Object::Bool(bool) => bool.to_string(),
481            Object::I8(i8) => i8.to_string(),
482            Object::I16(i16) => i16.to_string(),
483            Object::I32(i32) => i32.to_string(),
484            Object::I64(i64) => i64.to_string(),
485            Object::I128(i128) => i128.to_string(),
486            Object::U8(u8) => u8.to_string(),
487            Object::U16(u16) => u16.to_string(),
488            Object::U32(u32) => u32.to_string(),
489            Object::U64(u64) => u64.to_string(),
490            Object::U128(u128) => u128.to_string(),
491            Object::F32(f32) => f32.to_string(),
492            Object::F64(f64) => f64.to_string(),
493            Object::Char(char) => char.to_string(),
494            Object::String(cow) => cow.to_string(),
495            Object::ByteArray(cow) => String::from_utf8_lossy(cow).to_string(),
496            _ => {
497                return Err(ser::Error::custom(
498                    "Tried to serialise a variant, but couldn't make a name.",
499                ))
500            }
501        }
502        .as_ref(),
503    )
504    .pipe(Ok)
505}
506
507fn make_field_key<E: ser::Error>(variant: &Object) -> Result<&'static str, E> {
508    leak_str(
509        match variant {
510            Object::Bool(bool) => bool.to_string(),
511            Object::I8(i8) => i8.to_string(),
512            Object::I16(i16) => i16.to_string(),
513            Object::I32(i32) => i32.to_string(),
514            Object::I64(i64) => i64.to_string(),
515            Object::I128(i128) => i128.to_string(),
516            Object::U8(u8) => u8.to_string(),
517            Object::U16(u16) => u16.to_string(),
518            Object::U32(u32) => u32.to_string(),
519            Object::U64(u64) => u64.to_string(),
520            Object::U128(u128) => u128.to_string(),
521            Object::F32(f32) => f32.to_string(),
522            Object::F64(f64) => f64.to_string(),
523            Object::Char(char) => char.to_string(),
524            Object::String(cow) => cow.to_string(),
525            Object::ByteArray(cow) => String::from_utf8_lossy(cow).to_string(),
526            Object::DualVariantKey { index: _, name } => name.to_string(),
527            _ => {
528                return Err(ser::Error::custom(
529                    "Tried to serialise a struct variant, but couldn't make a field key.",
530                ))
531            }
532        }
533        .as_ref(),
534    )
535    .pipe(Ok)
536}
537
538//TODO: Some leaks may be avoidable if deref specialisation works with lifetimes.
539//TODO: Evaluate interning as an option to mitigate memory usage somewhat.
540fn leak_str(str: &str) -> &'static str {
541    Box::leak(Box::new(str.to_string()))
542}
543
544impl<'de> de::Deserialize<'de> for Object<'de> {
545    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
546    where
547        D: de::Deserializer<'de>,
548    {
549        deserializer.deserialize_any(Visitor(NoEnumAssistant))
550    }
551}
552
553macro_rules! visit {
554    ($($visit_:ident$(+ $self:ident)?($($ty:ty$( | $($expr:expr$(, $question_mark:tt)*);+$(;)?)?)?) => $variant:ident$(($const:expr))? $(/ ::$Error:ident where T: $t_path:path)?),*$(,)?) => {
555        $(
556            fn $visit_<T>(self$(, v: $ty)?) -> Result<Self::Value, T$(::$Error)?>
557            where
558                T: $($t_path, T::Error: )?de::Error,
559            {
560                $(let $self = self;)?
561                Ok(Object::$variant
562                    // Alternatives:
563                    $(({let _: $ty; v$($(.pipe($expr)$($question_mark)*)+)?.into()}))?
564                    $(($const))?
565                )
566            }
567        )*
568    };
569}
570
571#[derive(Clone)]
572struct Visitor<Assistant: EnumAssistant + Clone>(Assistant);
573impl<'de, Assistant: EnumAssistant + Clone> de::Visitor<'de> for Visitor<Assistant> {
574    type Value = Object<'de>;
575
576    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
577        write!(formatter, "just about anything")
578    }
579
580    visit! {
581        visit_bool(bool) => Bool,
582
583        visit_i8(i8) => I8,
584        visit_i16(i16) => I16,
585        visit_i32(i32) => I32,
586        visit_i64(i64) => I64,
587        visit_i128(i128) => I128,
588
589        visit_u8(u8) => U8,
590        visit_u16(u16) => U16,
591        visit_u32(u32) => U32,
592        visit_u64(u64) => U64,
593        visit_u128(u128) => U128,
594
595        visit_f32(f32) => F32,
596        visit_f64(f64) => F64,
597
598        visit_char(char) => Char,
599
600        visit_str(&str | str::to_owned) => String,
601        visit_borrowed_str(&'de str) => String,
602        visit_string(String) => String,
603
604        visit_bytes(&[u8] | <[u8]>::to_owned) => ByteArray,
605        visit_borrowed_bytes(&'de [u8]) => ByteArray,
606        visit_byte_buf(Vec<u8>) => ByteArray,
607
608        visit_none() => Option(None),
609        visit_some + self_(T | |d| d.deserialize_any(self_), ?; Box::new) => Option / ::Error where T: de::Deserializer<'de>,
610
611        visit_unit() => Unit,
612    }
613
614    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
615    where
616        D: de::Deserializer<'de>,
617    {
618        Ok(Object::NewtypeStruct {
619            name: "UNKNOWN".into(),
620            value: deserializer.deserialize_any(self)?.into(),
621        })
622    }
623
624    fn visit_seq<A>(self, access: A) -> Result<Self::Value, A::Error>
625    where
626        A: de::SeqAccess<'de>,
627    {
628        struct SeqAccessIterator<'de, Assistant: EnumAssistant + Clone, Access: de::SeqAccess<'de>> {
629            assistant: Assistant,
630            access: Access,
631            marker: PhantomData<&'de ()>,
632        }
633        impl<'de, Assistant: EnumAssistant + Clone, Access: de::SeqAccess<'de>> Iterator
634            for SeqAccessIterator<'de, Assistant, Access>
635        {
636            type Item = Result<Object<'de>, Access::Error>;
637            fn next(&mut self) -> Option<Self::Item> {
638                self.access
639                    .next_element_seed(Seed(self.assistant.clone()))
640                    .transpose()
641            }
642            fn size_hint(&self) -> (usize, Option<usize>) {
643                (self.access.size_hint().unwrap_or(0), None)
644            }
645        }
646
647        Ok(Object::Seq(
648            SeqAccessIterator {
649                assistant: self.0,
650                access,
651                marker: PhantomData,
652            }
653            .collect::<Result<_, _>>()?,
654        ))
655    }
656
657    fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error>
658    where
659        A: de::MapAccess<'de>,
660    {
661        struct MapAccessIterator<'de, Assistant: EnumAssistant + Clone, Access> {
662            assistant: Assistant,
663            access: Access,
664            marker: PhantomData<&'de ()>,
665        };
666        impl<'de, Assistant: EnumAssistant + Clone, Access: de::MapAccess<'de>> Iterator
667            for MapAccessIterator<'de, Assistant, Access>
668        {
669            type Item = Result<(Object<'de>, Object<'de>), Access::Error>;
670            fn next(&mut self) -> Option<Self::Item> {
671                self.access
672                    .next_entry_seed(Seed(self.assistant.clone()), Seed(self.assistant.clone()))
673                    .transpose()
674            }
675            fn size_hint(&self) -> (usize, Option<usize>) {
676                (self.access.size_hint().unwrap_or(0), None)
677            }
678        }
679
680        Ok(Object::Map(
681            MapAccessIterator {
682                assistant: self.0,
683                access,
684                marker: PhantomData,
685            }
686            .collect::<Result<_, _>>()?,
687        ))
688    }
689
690    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
691    where
692        A: de::EnumAccess<'de>,
693    {
694        // (Likely!) Goes through deserialize_identifier => deserialize_any, but we'll probably get a string, number (u64) or bytes.
695        let (variant, variant_access): (Object<'de>, _) =
696            data.variant_seed(Seed(self.0.clone()))?;
697
698        let name = Cow::Borrowed("UNKNOWN_ENUM");
699        let variant = Box::new(variant);
700
701        // So this is hacky...
702        // Essentially, we have no way of knowing what kind of variant is coming up, so we need a little more info.
703        // (We can't do this by trial and error even in a self-describing format since the A::Variant is consumed each time.)
704
705        // First, try to get a library-provided hint.
706        #[cfg(feature = "assistant-extra")]
707        let extra_hint = assistant::extra::enum_variant_hint();
708        #[cfg(not(feature = "assistant-extra"))]
709        let extra_hint = None;
710        
711        // Then, try a user-provided hint.
712        match extra_hint.map_or_else(|| self.0.variant_hint(&variant), Ok)? {
713            VariantKind::Unit => variant_access
714                .unit_variant()
715                .map(|()| Object::UnitVariant { name, variant }),
716            VariantKind::Newtype => {
717                variant_access
718                    .newtype_variant_seed(Seed(self.0))
719                    .map(|value| Object::NewtypeVariant {
720                        name,
721                        variant,
722                        value: Box::new(value),
723                    })
724            }
725            VariantKind::Tuple(len) => {
726                variant_access
727                    .tuple_variant(len, self)
728                    .map(|fields| Object::TupleVariant {
729                        name,
730                        variant,
731                        fields: Box::new(fields),
732                    })
733            }
734            VariantKind::Struct(field_names) => {
735                let field_names = field_names
736                    .iter()
737                    .map(|name| name.as_ref().pipe(leak_str))
738                    .collect::<Vec<_>>()
739                    .pipe(leak_vec);
740                variant_access
741                    .struct_variant(field_names, self)
742                    .map(|fields| Object::StructVariant {
743                        name,
744                        variant,
745                        fields: Box::new(fields),
746                    })
747            }
748        }
749    }
750}
751
752fn leak_vec<T>(vec: Vec<T>) -> &'static [T] {
753    vec.pipe(Box::new).pipe(Box::leak)
754}
755
756impl<'de> de::IntoDeserializer<'de> for Object<'de> {
757    type Deserializer = Self;
758    fn into_deserializer(self) -> Self::Deserializer {
759        self
760    }
761}
762
763impl<'de> de::Deserializer<'de> for Object<'de> {
764    type Error = de::value::Error;
765    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
766    where
767        V: de::Visitor<'de>,
768    {
769        match self {
770            Object::Bool(bool) => visitor.visit_bool(bool),
771
772            Object::I8(i8) => visitor.visit_i8(i8),
773            Object::I16(i16) => visitor.visit_i16(i16),
774            Object::I32(i32) => visitor.visit_i32(i32),
775            Object::I64(i64) => visitor.visit_i64(i64),
776            Object::I128(i128) => visitor.visit_i128(i128),
777
778            Object::U8(u8) => visitor.visit_u8(u8),
779            Object::U16(u16) => visitor.visit_u16(u16),
780            Object::U32(u32) => visitor.visit_u32(u32),
781            Object::U64(u64) => visitor.visit_u64(u64),
782            Object::U128(u128) => visitor.visit_u128(u128),
783
784            Object::F32(f32) => visitor.visit_f32(f32),
785            Object::F64(f64) => visitor.visit_f64(f64),
786
787            Object::Char(char) => visitor.visit_char(char),
788            Object::String(cow) => match cow {
789                Cow::Borrowed(str) => visitor.visit_borrowed_str(str),
790                Cow::Owned(string) => visitor.visit_string(string),
791            },
792
793            Object::ByteArray(cow) => match cow {
794                Cow::Borrowed(slice) => visitor.visit_borrowed_bytes(slice),
795                Cow::Owned(vec) => visitor.visit_byte_buf(vec),
796            },
797
798            Object::Option(option) => match option {
799                Some(b) => visitor.visit_some(*b),
800                None => visitor.visit_none(),
801            },
802
803            Object::Unit => visitor.visit_unit(),
804
805            Object::UnitStruct { .. } => visitor.visit_unit(),
806            self_ @ Object::UnitVariant { .. } => visitor.visit_enum(EnumAccess(self_)),
807            Object::NewtypeStruct { name: _, value } => visitor.visit_newtype_struct(*value),
808            self_ @ Object::NewtypeVariant { .. } => visitor.visit_enum(EnumAccess(self_)),
809            Object::Seq(elements) => visitor.visit_seq(elements.into_deserializer()),
810            Object::Tuple(fields) => visitor.visit_seq(fields.into_deserializer()),
811            Object::TupleStruct { name: _, fields } => {
812                visitor.visit_seq(fields.into_deserializer())
813            }
814            self_ @ Object::TupleVariant { .. } => visitor.visit_enum(EnumAccess(self_)),
815            Object::Map(map) => visitor.visit_map(MapAccess::new(map)),
816            Object::Struct { name: _, fields } => visitor.visit_map(MapAccess::new(
817                fields
818                    .into_iter()
819                    .filter_map(|(k, v)| v.map(|v| (Object::String(k), v))),
820            )),
821            self_ @ Object::StructVariant { .. } => visitor.visit_enum(EnumAccess(self_)),
822
823            self_ @ Object::DualVariantKey { .. } => {
824                let is_human_readable = self_.is_human_readable();
825                let key = try_match!(Object::DualVariantKey { name, index } = self_).unwrap();
826                if is_human_readable {
827                    visitor.visit_str(key.name.as_ref())
828                } else {
829                    visitor.visit_u32(key.index)
830                }
831            }
832            Object::FieldMap(fields) => visitor.visit_map(MapAccess::new(
833                fields.into_iter().filter_map(|(k, v)| v.map(|v| (k, v))),
834            )),
835        }
836    }
837
838    forward_to_deserialize_any! {
839        bool i8 i16 i32 i64 u8 u16 u64 f32 f64 char
840        bytes byte_buf option unit unit_struct newtype_struct seq tuple
841        tuple_struct map struct enum identifier ignored_any
842    }
843
844    serde_if_integer128!(forward_to_deserialize_any! {
845        i128 u128
846    });
847
848    fn is_human_readable(&self) -> bool {
849        //TODO: This should *probably* be a little smarter depending on the field keys available.
850        true
851    }
852
853    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
854    where
855        V: de::Visitor<'de>,
856    {
857        match self {
858            Object::DualVariantKey { index, .. } => visitor.visit_u32(index),
859            self_ => self_.deserialize_any(visitor),
860        }
861    }
862    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
863    where
864        V: de::Visitor<'de>,
865    {
866        match self {
867            Object::DualVariantKey { name, .. } => visitor.visit_str(name.as_ref()),
868            self_ => self_.deserialize_any(visitor),
869        }
870    }
871    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
872    where
873        V: de::Visitor<'de>,
874    {
875        match self {
876            Object::DualVariantKey { name, .. } => visitor.visit_string(name.to_string()),
877            self_ => self_.deserialize_any(visitor),
878        }
879    }
880}
881
882struct MapAccess<'de, I: Iterator<Item = (Object<'de>, Object<'de>)>> {
883    iter: I,
884    next_value: Option<Object<'de>>,
885}
886impl<'de, I: Iterator<Item = (Object<'de>, Object<'de>)>> MapAccess<'de, I> {
887    fn new(map: impl IntoIterator<Item = (Object<'de>, Object<'de>), IntoIter = I>) -> Self {
888        Self {
889            iter: map.into_iter(),
890            next_value: None,
891        }
892    }
893}
894impl<'de, I: Iterator<Item = (Object<'de>, Object<'de>)>> de::MapAccess<'de> for MapAccess<'de, I> {
895    type Error = de::value::Error;
896    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
897    where
898        K: de::DeserializeSeed<'de>,
899    {
900        self.iter
901            .next()
902            .map(|(k, v)| {
903                self.next_value = Some(v);
904                seed.deserialize(k)
905            })
906            .transpose()
907    }
908
909    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
910    where
911        V: de::DeserializeSeed<'de>,
912    {
913        seed.deserialize(
914            self.next_value
915                .take()
916                .expect("Called next_value_seed before next_key_seed."),
917        )
918    }
919
920    #[allow(clippy::type_complexity)]
921    fn next_entry_seed<K, V>(
922        &mut self,
923        kseed: K,
924        vseed: V,
925    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
926    where
927        K: de::DeserializeSeed<'de>,
928        V: de::DeserializeSeed<'de>,
929    {
930        assert!(self.next_value.is_none());
931        self.iter
932            .next()
933            .map(|(k, v)| {
934                kseed
935                    .deserialize(k)
936                    .and_then(|key| vseed.deserialize(v).map(|value| (key, value)))
937            })
938            .transpose()
939    }
940
941    fn size_hint(&self) -> Option<usize> {
942        if let (min, Some(max)) = self.iter.size_hint() {
943            if min == max {
944                return Some(min);
945            }
946        }
947        None
948    }
949}
950
951struct EnumAccess<'de>(Object<'de>);
952impl<'de> de::EnumAccess<'de> for EnumAccess<'de> {
953    type Error = <Object<'de> as de::Deserializer<'de>>::Error;
954    type Variant = VariantAccess<'de>;
955    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
956    where
957        V: de::DeserializeSeed<'de>,
958    {
959        match self.0 {
960            Object::UnitVariant { variant, .. } => {
961                (seed.deserialize(*variant)?, VariantAccess::Unit)
962            }
963            Object::NewtypeVariant { variant, value, .. } => {
964                (seed.deserialize(*variant)?, VariantAccess::Newtype(*value))
965            }
966            Object::TupleVariant {
967                variant, fields, ..
968            } => (seed.deserialize(*variant)?, VariantAccess::Tuple(*fields)),
969            Object::StructVariant {
970                variant, fields, ..
971            } => (seed.deserialize(*variant)?, VariantAccess::Struct(*fields)),
972            _ => {
973                return Err(de::Error::invalid_type(
974                    de::Unexpected::Other("non-variant Object"),
975                    &"enum variant",
976                ))
977            }
978        }
979        .pipe(Ok)
980    }
981}
982
983enum VariantAccess<'a> {
984    Unit,
985    Newtype(Object<'a>),
986    Tuple(Object<'a>),
987    Struct(Object<'a>),
988}
989impl<'de> de::VariantAccess<'de> for VariantAccess<'de> {
990    type Error = <Object<'de> as de::Deserializer<'de>>::Error;
991    fn unit_variant(self) -> Result<(), Self::Error> {
992        match self {
993            VariantAccess::Unit => Ok(()),
994            _ => Err(de::Error::invalid_type(self.unexp(), &"unit variant")),
995        }
996    }
997    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
998    where
999        T: de::DeserializeSeed<'de>,
1000    {
1001        match self {
1002            VariantAccess::Newtype(value) => seed.deserialize(value),
1003            _ => Err(de::Error::invalid_type(self.unexp(), &"newtype variant")),
1004        }
1005    }
1006    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1007    where
1008        V: de::Visitor<'de>,
1009    {
1010        match self {
1011            //TODO: Check length?
1012            VariantAccess::Tuple(fields) => fields.deserialize_any(visitor),
1013            _ => Err(de::Error::invalid_type(self.unexp(), &"tuple variant")),
1014        }
1015    }
1016    fn struct_variant<V>(
1017        self,
1018        fields: &'static [&'static str],
1019        visitor: V,
1020    ) -> Result<V::Value, Self::Error>
1021    where
1022        V: de::Visitor<'de>,
1023    {
1024        match self {
1025            //TODO: Check fields?
1026            VariantAccess::Struct(fields) => fields.deserialize_any(visitor),
1027            _ => Err(de::Error::invalid_type(self.unexp(), &"struct variant")),
1028        }
1029    }
1030}
1031impl<'de> VariantAccess<'de> {
1032    fn unexp(&self) -> de::Unexpected {
1033        match self {
1034            VariantAccess::Unit => de::Unexpected::UnitVariant,
1035            VariantAccess::Newtype(_) => de::Unexpected::NewtypeVariant,
1036            VariantAccess::Tuple(_) => de::Unexpected::TupleVariant,
1037            VariantAccess::Struct(_) => de::Unexpected::StructVariant,
1038        }
1039    }
1040}
1041
1042#[derive(Debug, Clone, Copy)]
1043struct NoEnumAssistant;
1044impl EnumAssistant for NoEnumAssistant {
1045    fn variant_hint<E: de::Error>(&self, _variant: &Object) -> Result<VariantKind, E> {
1046        Err(de::Error::custom(
1047            "Encountered enum variant with no EnumAssistant specified.",
1048        ))
1049    }
1050}
serde_object/lib.rs

serde_object/
lib.rs
