bones_schema/
ser_de.rs

1use std::any::type_name;
2
3use erased_serde::Deserializer;
4use serde::{
5    de::{DeserializeSeed, Error},
6    Deserialize, Serialize,
7};
8
9use crate::prelude::*;
10
11pub use serializer_deserializer::*;
12mod serializer_deserializer {
13    use serde::{
14        de::{Unexpected, VariantAccess, Visitor},
15        ser::{SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant},
16    };
17    use ustr::Ustr;
18
19    use super::*;
20
21    /// A struct that implements [`Serialize`] and wraps around a [`SchemaRef`] to serialize the value
22    /// using it's schema.
23    ///
24    /// This will error if there are opaque types in the schema ref that cannot be serialized.
25    pub struct SchemaSerializer<'a>(pub SchemaRef<'a>);
26
27    impl<'a> Serialize for SchemaSerializer<'a> {
28        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29        where
30            S: serde::Serializer,
31        {
32            // Specifically handle `Ustr`
33            if let Ok(u) = self.0.try_cast::<Ustr>() {
34                return serializer.serialize_str(u);
35            }
36
37            match self.0.access() {
38                SchemaRefAccess::Struct(s) => {
39                    if s.fields().count() == 1 && s.fields().nth(0).unwrap().name.is_none() {
40                        SchemaSerializer(s.fields().nth(0).unwrap().value).serialize(serializer)
41                    } else {
42                        let named = s.fields().nth(0).map(|x| x.name.is_some()).unwrap_or(false);
43
44                        if named {
45                            let mut ser_struct = serializer
46                                .serialize_struct(&self.0.schema().name, s.fields().count())?;
47                            for field in s.fields() {
48                                ser_struct.serialize_field(
49                                    field.name.as_ref().unwrap(),
50                                    &SchemaSerializer(field.value),
51                                )?;
52                            }
53                            ser_struct.end()
54                        } else {
55                            let mut seq = serializer.serialize_seq(Some(s.fields().count()))?;
56                            for field in s.fields() {
57                                seq.serialize_element(&SchemaSerializer(field.value))?;
58                            }
59                            seq.end()
60                        }
61                    }
62                }
63                SchemaRefAccess::Vec(v) => {
64                    let mut seq = serializer.serialize_seq(Some(v.len()))?;
65                    for item in v.iter() {
66                        seq.serialize_element(&SchemaSerializer(item))?;
67                    }
68                    seq.end()
69                }
70                SchemaRefAccess::Map(m) => {
71                    let mut map = serializer.serialize_map(Some(m.len()))?;
72                    for (key, value) in m.iter() {
73                        map.serialize_entry(&SchemaSerializer(key), &SchemaSerializer(value))?;
74                    }
75                    map.end()
76                }
77                SchemaRefAccess::Enum(e) => {
78                    let variant_idx = e.variant_idx();
79                    let variant_info = e.variant_info();
80                    let access = e.value();
81                    let field_count = access.fields().count();
82
83                    if field_count == 0 {
84                        serializer.serialize_unit_variant(
85                            &self.0.schema().name,
86                            variant_idx,
87                            &variant_info.name,
88                        )
89                    } else if field_count == 1 && access.fields().nth(0).unwrap().name.is_none() {
90                        serializer.serialize_newtype_variant(
91                            &self.0.schema().name,
92                            variant_idx,
93                            &variant_info.name,
94                            &SchemaSerializer(access.as_schema_ref()),
95                        )
96                    } else {
97                        let mut ser_struct = serializer.serialize_struct_variant(
98                            &self.0.schema().name,
99                            variant_idx,
100                            &variant_info.name,
101                            field_count,
102                        )?;
103
104                        for field in access.fields() {
105                            ser_struct.serialize_field(
106                                field.name.as_ref().unwrap(),
107                                &SchemaSerializer(field.value),
108                            )?;
109                        }
110
111                        ser_struct.end()
112                    }
113                }
114                SchemaRefAccess::Primitive(p) => match p {
115                    PrimitiveRef::Bool(b) => serializer.serialize_bool(*b),
116                    PrimitiveRef::U8(n) => serializer.serialize_u8(*n),
117                    PrimitiveRef::U16(n) => serializer.serialize_u16(*n),
118                    PrimitiveRef::U32(n) => serializer.serialize_u32(*n),
119                    PrimitiveRef::U64(n) => serializer.serialize_u64(*n),
120                    PrimitiveRef::U128(n) => serializer.serialize_u128(*n),
121                    PrimitiveRef::I8(n) => serializer.serialize_i8(*n),
122                    PrimitiveRef::I16(n) => serializer.serialize_i16(*n),
123                    PrimitiveRef::I32(n) => serializer.serialize_i32(*n),
124                    PrimitiveRef::I64(n) => serializer.serialize_i64(*n),
125                    PrimitiveRef::I128(n) => serializer.serialize_i128(*n),
126                    PrimitiveRef::F32(n) => serializer.serialize_f32(*n),
127                    PrimitiveRef::F64(n) => serializer.serialize_f64(*n),
128                    PrimitiveRef::String(n) => serializer.serialize_str(n),
129                    PrimitiveRef::Opaque { .. } => {
130                        use serde::ser::Error;
131                        Err(S::Error::custom("Cannot serialize opaque types"))
132                    }
133                },
134            }
135        }
136    }
137
138    /// A struct that implements [`DeserializeSeed`] and can be used to deserialize values matching a
139    /// given [`Schema`].
140    ///
141    /// This will error if there are opaque types in the schema that cannot be deserialized.
142    pub struct SchemaDeserializer(pub &'static Schema);
143
144    impl<'de> DeserializeSeed<'de> for SchemaDeserializer {
145        type Value = SchemaBox;
146
147        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
148        where
149            D: serde::Deserializer<'de>,
150        {
151            // Allocate the object.
152            let mut ptr = SchemaBox::default(self.0);
153
154            // Deserialize into it
155            ptr.as_mut().deserialize(deserializer)?;
156
157            Ok(ptr)
158        }
159    }
160
161    impl<'a, 'de> DeserializeSeed<'de> for SchemaRefMut<'a> {
162        type Value = ();
163
164        fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error>
165        where
166            D: serde::Deserializer<'de>,
167        {
168            // Use custom deserializer if present.
169            if let Some(schema_deserialize) = self.schema().type_data.get::<SchemaDeserialize>() {
170                return schema_deserialize.deserialize(self, deserializer);
171            }
172
173            match &self.schema().kind {
174                SchemaKind::Struct(s) => {
175                    // If this is a newtype struct
176                    if s.fields.len() == 1 && s.fields[0].name.is_none() {
177                        // Deserialize it as the inner type
178                        // SOUND: it is safe to cast a struct with one field to it's field type
179                        unsafe { SchemaRefMut::from_ptr_schema(self.as_ptr(), s.fields[0].schema) }
180                            .deserialize(deserializer)?
181                    } else {
182                        deserializer.deserialize_any(StructVisitor(self))?
183                    }
184                }
185                SchemaKind::Vec(_) => deserializer.deserialize_seq(VecVisitor(self))?,
186                SchemaKind::Map { .. } => deserializer.deserialize_map(MapVisitor(self))?,
187                SchemaKind::Enum(_) => deserializer.deserialize_any(EnumVisitor(self))?,
188                SchemaKind::Box(_) => self.into_box().unwrap().deserialize(deserializer)?,
189                SchemaKind::Primitive(p) => {
190                    match p {
191                        Primitive::Bool => *self.cast_mut() = bool::deserialize(deserializer)?,
192                        Primitive::U8 => *self.cast_mut() = u8::deserialize(deserializer)?,
193                        Primitive::U16 => *self.cast_mut() = u16::deserialize(deserializer)?,
194                        Primitive::U32 => *self.cast_mut() = u32::deserialize(deserializer)?,
195                        Primitive::U64 => *self.cast_mut() = u64::deserialize(deserializer)?,
196                        Primitive::U128 => *self.cast_mut() = u128::deserialize(deserializer)?,
197                        Primitive::I8 => *self.cast_mut() = i8::deserialize(deserializer)?,
198                        Primitive::I16 => *self.cast_mut() = i16::deserialize(deserializer)?,
199                        Primitive::I32 => *self.cast_mut() = i32::deserialize(deserializer)?,
200                        Primitive::I64 => *self.cast_mut() = i64::deserialize(deserializer)?,
201                        Primitive::I128 => *self.cast_mut() = i128::deserialize(deserializer)?,
202                        Primitive::F32 => *self.cast_mut() = f32::deserialize(deserializer)?,
203                        Primitive::F64 => *self.cast_mut() = f64::deserialize(deserializer)?,
204                        Primitive::String => *self.cast_mut() = String::deserialize(deserializer)?,
205                        Primitive::Opaque { .. } => {
206                            return Err(D::Error::custom(
207                                "Opaque types must be #[repr(C)] or have `SchemaDeserialize` type \
208                                data in order to be deserialized.",
209                            ));
210                        }
211                    };
212                }
213            };
214
215            Ok(())
216        }
217    }
218
219    struct StructVisitor<'a>(SchemaRefMut<'a>);
220    impl<'a, 'de> Visitor<'de> for StructVisitor<'a> {
221        type Value = ();
222        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
223            write!(
224                formatter,
225                "asset metadata matching the schema: {:#?}",
226                self.0.schema()
227            )
228        }
229
230        fn visit_seq<A>(mut self, mut seq: A) -> Result<Self::Value, A::Error>
231        where
232            A: serde::de::SeqAccess<'de>,
233        {
234            let field_count = self.0.schema().kind.as_struct().unwrap().fields.len();
235
236            for i in 0..field_count {
237                let field = self.0.access_mut().field(i).unwrap().into_schema_ref_mut();
238                if seq.next_element_seed(field)?.is_none() {
239                    break;
240                }
241            }
242
243            Ok(())
244        }
245
246        fn visit_map<A>(mut self, mut map: A) -> Result<Self::Value, A::Error>
247        where
248            A: serde::de::MapAccess<'de>,
249        {
250            while let Some(key) = map.next_key::<String>()? {
251                match self
252                    .0
253                    .access_mut()
254                    .field(&key)
255                    .map(|x| x.into_schema_ref_mut())
256                {
257                    Ok(field) => {
258                        map.next_value_seed(field)?;
259                    }
260                    Err(_) => {
261                        let fields = &self.0.schema().kind.as_struct().unwrap().fields;
262                        let mut msg = format!("unknown field `{key}`, ");
263                        if !fields.is_empty() {
264                            msg += "expected one of ";
265                            for (i, field) in fields.iter().enumerate() {
266                                msg += &field
267                                    .name
268                                    .as_ref()
269                                    .map(|x| format!("`{x}`"))
270                                    .unwrap_or_else(|| format!("`{i}`"));
271                                if i < fields.len() - 1 {
272                                    msg += ", "
273                                }
274                            }
275                        } else {
276                            msg += "there are no fields"
277                        }
278                        return Err(A::Error::custom(msg));
279                    }
280                }
281            }
282
283            Ok(())
284        }
285    }
286
287    struct VecVisitor<'a>(SchemaRefMut<'a>);
288    impl<'a, 'de> Visitor<'de> for VecVisitor<'a> {
289        type Value = ();
290        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
291            write!(
292                formatter,
293                "asset metadata matching the schema: {:#?}",
294                self.0.schema()
295            )
296        }
297
298        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
299        where
300            A: serde::de::SeqAccess<'de>,
301        {
302            // SOUND: schema asserts this is a SchemaVec.
303            let v = unsafe { &mut *(self.0.as_ptr() as *mut SchemaVec) };
304            let item_schema = v.schema();
305            loop {
306                let mut item = SchemaBox::default(item_schema);
307                let item_ref = item.as_mut();
308                if seq.next_element_seed(item_ref)?.is_none() {
309                    break;
310                }
311                v.push_box(item);
312            }
313
314            Ok(())
315        }
316    }
317    struct MapVisitor<'a>(SchemaRefMut<'a>);
318    impl<'a, 'de> Visitor<'de> for MapVisitor<'a> {
319        type Value = ();
320        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
321            write!(
322                formatter,
323                "asset metadata matching the schema: {:#?}",
324                self.0.schema()
325            )
326        }
327
328        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
329        where
330            A: serde::de::MapAccess<'de>,
331        {
332            // SOUND: schema asserts this is a SchemaMap.
333            let v = unsafe { &mut *(self.0.as_ptr() as *mut SchemaMap) };
334
335            let key_schema = v.key_schema();
336            let value_schema = v.value_schema();
337            loop {
338                let mut key = SchemaBox::default(key_schema);
339                let mut value = SchemaBox::default(value_schema);
340
341                if map.next_key_seed(key.as_mut())?.is_none() {
342                    break;
343                }
344                map.next_value_seed(value.as_mut())?;
345
346                v.insert_box(key, value);
347            }
348            Ok(())
349        }
350    }
351    struct EnumVisitor<'a>(SchemaRefMut<'a>);
352    impl<'a, 'de> Visitor<'de> for EnumVisitor<'a> {
353        type Value = ();
354        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
355            write!(
356                formatter,
357                "asset metadata matching the schema: {:#?}",
358                self.0.schema()
359            )
360        }
361
362        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
363        where
364            E: Error,
365        {
366            let enum_info = self.0.schema().kind.as_enum().unwrap();
367            let var_idx = enum_info
368                .variants
369                .iter()
370                .position(|x| x.name == v)
371                .ok_or_else(|| E::invalid_value(Unexpected::Str(v), &self))?;
372
373            if !enum_info.variants[var_idx]
374                .schema
375                .kind
376                .as_struct()
377                .unwrap()
378                .fields
379                .is_empty()
380            {
381                return Err(E::custom(format!(
382                    "Cannot deserialize enum variant with fields from string: {v}"
383                )));
384            }
385
386            // SOUND: we match the cast with the enum tag type.
387            unsafe {
388                match enum_info.tag_type {
389                    EnumTagType::U8 => self.0.as_ptr().cast::<u8>().write(var_idx as u8),
390                    EnumTagType::U16 => self.0.as_ptr().cast::<u16>().write(var_idx as u16),
391                    EnumTagType::U32 => self.0.as_ptr().cast::<u32>().write(var_idx as u32),
392                }
393            }
394
395            Ok(())
396        }
397
398        fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
399        where
400            A: serde::de::EnumAccess<'de>,
401        {
402            let (value_ptr, var_access) = data.variant_seed(EnumLoad(self.0))?;
403            var_access.newtype_variant_seed(value_ptr)?;
404            Ok(())
405        }
406    }
407
408    struct EnumLoad<'a>(SchemaRefMut<'a>);
409    impl<'a, 'de> DeserializeSeed<'de> for EnumLoad<'a> {
410        type Value = SchemaRefMut<'a>;
411
412        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
413        where
414            D: serde::Deserializer<'de>,
415        {
416            let var_name = String::deserialize(deserializer)?;
417            let enum_info = self.0.schema().kind.as_enum().unwrap();
418            let value_offset = self.0.schema().field_offsets()[0].1;
419            let (var_idx, var_schema) = enum_info
420                .variants
421                .iter()
422                .enumerate()
423                .find_map(|(idx, info)| (info.name == var_name).then_some((idx, info.schema)))
424                .ok_or_else(|| {
425                    D::Error::custom(format!(
426                        "Unknown enum variant `{var_name}`, expected one of: {}",
427                        enum_info
428                            .variants
429                            .iter()
430                            .map(|x| format!("`{}`", x.name))
431                            .collect::<Vec<_>>()
432                            .join(", ")
433                    ))
434                })?;
435
436            // Write the enum variant
437            // SOUND: the schema asserts that the write to the enum discriminant is valid
438            match enum_info.tag_type {
439                EnumTagType::U8 => unsafe { self.0.as_ptr().cast::<u8>().write(var_idx as u8) },
440                EnumTagType::U16 => unsafe { self.0.as_ptr().cast::<u16>().write(var_idx as u16) },
441                EnumTagType::U32 => unsafe { self.0.as_ptr().cast::<u32>().write(var_idx as u32) },
442            }
443
444            if var_schema.kind.as_struct().is_none() {
445                return Err(D::Error::custom(
446                    "All enum variant types must have a struct Schema",
447                ));
448            }
449
450            unsafe {
451                Ok(SchemaRefMut::from_ptr_schema(
452                    self.0.as_ptr().add(value_offset),
453                    var_schema,
454                ))
455            }
456        }
457    }
458}
459
460/// Derivable schema [`type_data`][SchemaData::type_data] for types that implement
461/// [`Deserialize`].
462///
463/// This allows you use serde to implement custom deserialization logic instead of the default one
464/// used for `#[repr(C)]` structs that implement [`HasSchema`].
465pub struct SchemaDeserialize {
466    /// The function that may be used to deserialize the type.
467    pub deserialize_fn: for<'a, 'de> fn(
468        SchemaRefMut<'a>,
469        deserializer: &'a mut dyn Deserializer<'de>,
470    ) -> Result<(), erased_serde::Error>,
471}
472
473unsafe impl HasSchema for SchemaDeserialize {
474    fn schema() -> &'static Schema {
475        use std::{alloc::Layout, any::TypeId, sync::OnceLock};
476        static S: OnceLock<&'static Schema> = OnceLock::new();
477        let layout = Layout::new::<Self>();
478        S.get_or_init(|| {
479            SCHEMA_REGISTRY.register(SchemaData {
480                name: type_name::<Self>().into(),
481                full_name: format!("{}::{}", module_path!(), type_name::<Self>()).into(),
482                kind: SchemaKind::Primitive(Primitive::Opaque {
483                    size: layout.size(),
484                    align: layout.align(),
485                }),
486                type_id: Some(TypeId::of::<Self>()),
487                clone_fn: None,
488                drop_fn: None,
489                default_fn: None,
490                hash_fn: None,
491                eq_fn: None,
492                type_data: Default::default(),
493            })
494        })
495    }
496}
497
498impl SchemaDeserialize {
499    /// Use this [`SchemaDeserialize`] to deserialize data from the `deserializer` into the
500    /// `reference`.
501    pub fn deserialize<'a, 'de, D>(
502        &self,
503        reference: SchemaRefMut<'a>,
504        deserializer: D,
505    ) -> Result<(), D::Error>
506    where
507        D: serde::Deserializer<'de>,
508    {
509        let mut erased = <dyn erased_serde::Deserializer>::erase(deserializer);
510        (self.deserialize_fn)(reference, &mut erased)
511            .map_err(<<D as serde::Deserializer<'de>>::Error as serde::de::Error>::custom)
512    }
513}
514
515impl<T: HasSchema + for<'de> Deserialize<'de>> FromType<T> for SchemaDeserialize {
516    fn from_type() -> Self {
517        SchemaDeserialize {
518            deserialize_fn: |reference, deserializer| {
519                T::schema()
520                    .ensure_match(reference.schema())
521                    .map_err(|e| erased_serde::Error::custom(e.to_string()))?;
522                let data = T::deserialize(deserializer)?;
523
524                // SOUND: we ensured schemas match.
525                unsafe {
526                    reference.as_ptr().cast::<T>().write(data);
527                }
528
529                Ok(())
530            },
531        }
532    }
533}
534
535#[cfg(test)]
536mod test {
537    use super::*;
538    use bones_schema_macros::HasSchema;
539
540    #[derive(HasSchema, Clone, Default)]
541    #[schema_module(crate)]
542    #[repr(C)]
543    struct MyData {
544        name: String,
545        age: Age,
546        favorite_things: SVec<String>,
547        map: SMap<String, String>,
548    }
549
550    #[derive(HasSchema, Clone, Default)]
551    #[schema_module(crate)]
552    #[repr(C)]
553    struct Age(u32);
554
555    const DEMO_YAML: &str = r"name: John
556age: 8
557favorite_things:
558- jelly
559- beans
560map:
561  hello: world
562";
563
564    #[test]
565    fn schema_deserializer() {
566        let deserializer = serde_yaml::Deserializer::from_str(DEMO_YAML);
567
568        let data = SchemaDeserializer(MyData::schema())
569            .deserialize(deserializer)
570            .unwrap()
571            .cast_into::<MyData>();
572
573        assert_eq!(data.name, "John");
574        assert_eq!(data.age.0, 8);
575        assert_eq!(
576            data.favorite_things,
577            ["jelly".to_string(), "beans".to_string()]
578                .into_iter()
579                .collect::<SVec<_>>()
580        );
581        assert_eq!(
582            data.map.into_iter().next().unwrap(),
583            (&"hello".to_string(), &"world".to_string())
584        );
585    }
586
587    #[test]
588    fn schema_serializer() {
589        let mut data = Vec::new();
590        let mut serializer = serde_yaml::Serializer::new(&mut data);
591
592        SchemaSerializer(
593            MyData {
594                name: "John".into(),
595                age: Age(8),
596                favorite_things: ["jelly".to_string(), "beans".to_string()]
597                    .into_iter()
598                    .collect(),
599                map: [("hello".to_string(), "world".to_string())]
600                    .into_iter()
601                    .collect(),
602            }
603            .as_schema_ref(),
604        )
605        .serialize(&mut serializer)
606        .unwrap();
607
608        assert_eq!(DEMO_YAML, String::from_utf8(data).unwrap());
609    }
610}