havok_serde/de/
impls.rs

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2//
3// # Forked serde (ver. 1.0.202)
4// And serde holds the same license as Rust. https://github.com/rust-lang/rust/pull/43498
5// See: https://github.com/serde-rs/serde/commit/58b3af4c2915c3ae789778a11f3b7a468c1cec17
6//
7// The default implementation does not fully express Havok's special XML format.
8//
9// # Modification details
10// - Rust std types -> Havok Types
11// - Changed serde method to Havok XML& binary data signatures, which are easier to modify.
12//
13// # Memory optimization of `visit_array`
14// MaybeUninit leaks memory if an error occurs during initialization, but we learned from the
15// following how to use Guard to prevent leaks if necessary.
16//
17// SPDX-FileCopyrightText: 2017-2020 The array-init developers
18// https://github.com/Manishearth/array-init/blob/master/src/lib.rs
19//! Implement `Deserialize`
20
21use super::{Deserialize, Deserializer, Error, Visitor};
22use crate::de::{SeqAccess, seed::InPlaceSeed, size_hint};
23use crate::lib::*;
24use havok_types::*;
25
26////////////////////////////////////////////////////////////////////////////////
27
28macro_rules! impl_deserialize {
29    ($ty:ty, $visitor:tt, $de_method:tt) => {
30        impl<'de> Deserialize<'de> for $ty {
31            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
32            where
33                D: Deserializer<'de>,
34            {
35                struct InnerVisitor;
36                impl<'a> Visitor<'a> for InnerVisitor {
37                    type Value = $ty;
38
39                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
40                        formatter.write_str(stringify!($ty))
41                    }
42
43                    fn $visitor<E>(self, v: $ty) -> Result<Self::Value, E>
44                    where
45                        E: Error,
46                    {
47                        Ok(v)
48                    }
49                }
50
51                Ok(tri!(deserializer.$de_method(InnerVisitor)))
52            }
53        }
54    };
55}
56
57impl_deserialize!((), visit_void, deserialize_void);
58impl_deserialize!(char, visit_char, deserialize_char);
59impl_deserialize!(bool, visit_bool, deserialize_bool);
60
61impl_deserialize!(i8, visit_int8, deserialize_int8);
62impl_deserialize!(i16, visit_int16, deserialize_int16);
63impl_deserialize!(i32, visit_int32, deserialize_int32);
64impl_deserialize!(i64, visit_int64, deserialize_int64);
65
66impl_deserialize!(u8, visit_uint8, deserialize_uint8);
67impl_deserialize!(u16, visit_uint16, deserialize_uint16);
68impl_deserialize!(u32, visit_uint32, deserialize_uint32);
69impl_deserialize!(u64, visit_uint64, deserialize_uint64);
70
71impl_deserialize!(f16, visit_half, deserialize_half);
72impl_deserialize!(f32, visit_real, deserialize_real);
73
74impl_deserialize!(Vector4, visit_vector4, deserialize_vector4);
75impl_deserialize!(Quaternion, visit_quaternion, deserialize_quaternion);
76impl_deserialize!(Matrix3, visit_matrix3, deserialize_matrix3);
77impl_deserialize!(Rotation, visit_rotation, deserialize_rotation);
78impl_deserialize!(QsTransform, visit_qstransform, deserialize_qstransform);
79impl_deserialize!(Matrix4, visit_matrix4, deserialize_matrix4);
80impl_deserialize!(Transform, visit_transform, deserialize_transform);
81
82impl_deserialize!(Variant, visit_variant, deserialize_variant);
83impl_deserialize!(Pointer, visit_pointer, deserialize_pointer);
84
85////////////////////////////////////////////////////////////////////////////////
86
87impl<'de> Deserialize<'de> for Ulong {
88    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
89    where
90        D: Deserializer<'de>,
91    {
92        struct InnerVisitor;
93        impl Visitor<'_> for InnerVisitor {
94            type Value = Ulong;
95
96            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
97                formatter.write_str("Ulong")
98            }
99
100            fn visit_uint32<E>(self, v: u32) -> Result<Self::Value, E>
101            where
102                E: Error,
103            {
104                Ok(Ulong::new(v as u64))
105            }
106
107            fn visit_uint64<E>(self, v: u64) -> Result<Self::Value, E>
108            where
109                E: Error,
110            {
111                Ok(Ulong::new(v))
112            }
113        }
114
115        Ok(tri!(deserializer.deserialize_ulong(InnerVisitor)))
116    }
117}
118
119////////////////////////////////////////////////////////////////////////////////
120
121impl<'de: 'a, 'a> Deserialize<'de> for CString<'a> {
122    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
123    where
124        D: Deserializer<'de>,
125    {
126        struct CStringVisitor;
127        impl<'a> Visitor<'a> for CStringVisitor {
128            type Value = CString<'a>;
129
130            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
131                formatter.write_str("a cstring")
132            }
133
134            fn visit_cstring<E>(self, v: CString<'a>) -> Result<Self::Value, E>
135            where
136                E: Error,
137            {
138                Ok(v)
139            }
140        }
141
142        Ok(tri!(deserializer.deserialize_cstring(CStringVisitor)))
143    }
144}
145
146////////////////////////////////////////////////////////////////////////////////
147
148impl<'de: 'a, 'a> Deserialize<'de> for StringPtr<'a> {
149    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
150    where
151        D: Deserializer<'de>,
152    {
153        struct StringPtrVisitor;
154        impl<'a> Visitor<'a> for StringPtrVisitor {
155            type Value = StringPtr<'a>;
156
157            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
158                formatter.write_str("a stringptr")
159            }
160
161            fn visit_stringptr<E>(self, v: StringPtr<'a>) -> Result<Self::Value, E>
162            where
163                E: Error,
164            {
165                Ok(v)
166            }
167        }
168
169        Ok(tri!(deserializer.deserialize_stringptr(StringPtrVisitor)))
170    }
171}
172
173////////////////////////////////////////////////////////////////////////////////
174
175#[cfg(any(feature = "std", feature = "alloc"))]
176#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
177impl<'de> Deserialize<'de> for Vec<StringPtr<'de>> {
178    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
179    where
180        D: Deserializer<'de>,
181    {
182        struct VecVisitor;
183
184        impl<'de> Visitor<'de> for VecVisitor {
185            type Value = Vec<StringPtr<'de>>;
186
187            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
188                formatter.write_str("a sequence")
189            }
190
191            fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
192            where
193                A: SeqAccess<'de>,
194            {
195                let capacity = size_hint::cautious::<StringPtr<'de>>(seq.size_hint());
196                let mut values = Vec::with_capacity(capacity);
197
198                while let Some(value) = tri!(seq.next_stringptr_element()) {
199                    values.push(value);
200                }
201
202                Ok(values)
203            }
204        }
205
206        let visitor = VecVisitor;
207        deserializer.deserialize_array(visitor)
208    }
209
210    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
211    where
212        D: Deserializer<'de>,
213    {
214        struct VecInPlaceVisitor<'a, 'de: 'a>(&'a mut Vec<StringPtr<'de>>);
215
216        impl<'a, 'de: 'a> Visitor<'de> for VecInPlaceVisitor<'a, 'de> {
217            type Value = ();
218
219            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
220                formatter.write_str("a sequence")
221            }
222
223            fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
224            where
225                A: SeqAccess<'de>,
226            {
227                let hint = size_hint::cautious::<StringPtr<'de>>(seq.size_hint());
228                if let Some(additional) = hint.checked_sub(self.0.len()) {
229                    self.0.reserve(additional);
230                }
231
232                for i in 0..self.0.len() {
233                    let next = {
234                        let next_place = InPlaceSeed(&mut self.0[i]);
235                        tri!(seq.next_stringptr_element_seed(next_place))
236                    };
237                    if next.is_none() {
238                        self.0.truncate(i);
239                        return Ok(());
240                    }
241                }
242
243                while let Some(value) = tri!(seq.next_stringptr_element()) {
244                    self.0.push(value);
245                }
246
247                Ok(())
248            }
249        }
250
251        deserializer.deserialize_array(VecInPlaceVisitor(place))
252    }
253}
254
255////////////////////////////////////////////////////////////////////////////////
256
257macro_rules! seq_vec_impl {
258    ($($ty:ty),+ $(,)? => $fn_name:tt,  $fn_name_seed:tt) => {
259      $(
260        #[cfg(any(feature = "std", feature = "alloc"))]
261        #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
262        impl<'de> Deserialize<'de> for Vec<$ty> {
263            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
264            where
265                D: Deserializer<'de>,
266            {
267                struct VecVisitor;
268
269                impl<'de> Visitor<'de> for VecVisitor
270                {
271                    type Value = Vec<$ty>;
272
273                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
274                        formatter.write_str("a sequence")
275                    }
276
277                    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
278                    where
279                        A: SeqAccess<'de>,
280                    {
281                        let capacity = size_hint::cautious::<$ty>(seq.size_hint());
282                        let mut values = Vec::with_capacity(capacity);
283
284                        while let Some(value) = tri!(seq.$fn_name()) {
285                            values.push(value);
286                        }
287
288                        Ok(values)
289                    }
290                }
291
292                let visitor = VecVisitor;
293                deserializer.deserialize_array(visitor)
294            }
295
296            fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
297            where
298                D: Deserializer<'de>,
299            {
300                struct VecInPlaceVisitor<'a>(&'a mut Vec<$ty>);
301
302                impl<'a, 'de: 'a> Visitor<'de> for VecInPlaceVisitor<'a>
303                {
304                    type Value = ();
305
306                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
307                        formatter.write_str("a sequence")
308                    }
309
310                    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
311                    where
312                        A: SeqAccess<'de>,
313                    {
314                        let hint = size_hint::cautious::<$ty>(seq.size_hint());
315                        if let Some(additional) = hint.checked_sub(self.0.len()) {
316                            self.0.reserve(additional);
317                        }
318
319                        for i in 0..self.0.len() {
320                            let next = {
321                                let next_place = InPlaceSeed(&mut self.0[i]);
322                                tri!(seq.$fn_name_seed(next_place))
323                            };
324                            if next.is_none() {
325                                self.0.truncate(i);
326                                return Ok(());
327                            }
328                        }
329
330                        while let Some(value) = tri!(seq.$fn_name()) {
331                            self.0.push(value);
332                        }
333
334                        Ok(())
335                    }
336                }
337
338                deserializer.deserialize_array(VecInPlaceVisitor(place))
339            }
340        }
341      )*
342    };
343}
344
345seq_vec_impl!(
346    (), bool, char, u8, u16, u32, u64, i8, i16, i32, i64, f16, f32, Pointer, Ulong
347    => next_primitive_element, next_primitive_element_seed
348);
349seq_vec_impl!(Vector4, Quaternion, Matrix3, Rotation, QsTransform, Matrix4, Transform => next_math_element, next_math_element_seed);
350
351////////////////////////////////////////////////////////////////////////////////
352// For `hkClass`, etc vector.
353
354#[cfg(any(feature = "std", feature = "alloc"))]
355#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
356impl<'de, T> Deserialize<'de> for Vec<T>
357where
358    T: Deserialize<'de> + crate::HavokClass,
359{
360    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
361    where
362        D: Deserializer<'de>,
363    {
364        struct VecVisitor<T>(PhantomData<T>);
365
366        impl<'de, T> Visitor<'de> for VecVisitor<T>
367        where
368            T: Deserialize<'de> + crate::HavokClass,
369        {
370            type Value = Vec<T>;
371
372            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
373                formatter.write_str("a sequence")
374            }
375
376            fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
377            where
378                A: SeqAccess<'de>,
379            {
380                let capacity = size_hint::cautious::<T>(seq.size_hint());
381                let mut values = Vec::with_capacity(capacity);
382
383                while let Some(value) = tri!(seq.next_class_element()) {
384                    values.push(value);
385                }
386
387                Ok(values)
388            }
389        }
390
391        let visitor = VecVisitor(PhantomData);
392        deserializer.deserialize_array(visitor)
393    }
394
395    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
396    where
397        D: Deserializer<'de>,
398    {
399        struct VecInPlaceVisitor<'a, T>(&'a mut Vec<T>);
400
401        impl<'a, 'de: 'a, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
402        where
403            T: Deserialize<'de> + crate::HavokClass,
404        {
405            type Value = ();
406
407            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
408                formatter.write_str("a sequence")
409            }
410
411            fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
412            where
413                A: SeqAccess<'de>,
414            {
415                let hint = size_hint::cautious::<T>(seq.size_hint());
416                if let Some(additional) = hint.checked_sub(self.0.len()) {
417                    self.0.reserve(additional);
418                }
419
420                for i in 0..self.0.len() {
421                    let next = {
422                        let next_place = InPlaceSeed(&mut self.0[i]);
423                        tri!(seq.next_class_element_seed(next_place))
424                    };
425                    if next.is_none() {
426                        self.0.truncate(i);
427                        return Ok(());
428                    }
429                }
430
431                while let Some(value) = tri!(seq.next_class_element()) {
432                    self.0.push(value);
433                }
434
435                Ok(())
436            }
437        }
438
439        deserializer.deserialize_array(VecInPlaceVisitor(place))
440    }
441}
442
443////////////////////////////////////////////////////////////////////////////////
444
445struct ArrayVisitor<A> {
446    marker: PhantomData<A>,
447}
448struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
449
450impl<A> ArrayVisitor<A> {
451    fn new() -> Self {
452        ArrayVisitor {
453            marker: PhantomData,
454        }
455    }
456}
457
458macro_rules! array_impls {
459    ($($ty:ty),+ $(,)? => $fn_name:tt,  $fn_name_seed:tt) => {
460        $(
461            impl<'de, const N: usize> Visitor<'de> for ArrayVisitor<[$ty; N]>
462            {
463                type Value = [$ty; N];
464
465                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
466                    formatter.write_str(&format!("an array of length {N}"))
467                }
468
469                fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
470                where
471                    A: SeqAccess<'de>,
472                {
473                    let mut array = arrayvec::ArrayVec::<$ty, N>::new();
474                    for _ in 0..N {
475                        if let Some(value_i) = tri!(seq.$fn_name()) {
476                            array.push(value_i);
477                        } else {
478                            break;
479                        };
480                    }
481                    match array.take().into_inner() {
482                        Ok(array) => Ok(array),
483                        Err(array) => Err(Error::invalid_length(
484                            array.len(),
485                            &(N.to_string().as_str()),
486                        )),
487                    }
488                }
489            }
490
491            impl<'a, 'de, const N: usize> Visitor<'de> for ArrayInPlaceVisitor<'a, [$ty; N]>
492            where
493            {
494                type Value = ();
495
496                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
497                    formatter.write_str(&format!("an array of length {N}"))
498                }
499
500                #[inline]
501                fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
502                where
503                    A: SeqAccess<'de>,
504                {
505                    let mut fail_idx = None;
506                    for (idx, dest) in self.0[..].iter_mut().enumerate() {
507                        if tri!(seq.$fn_name_seed(InPlaceSeed(dest))).is_none() {
508                            fail_idx = Some(idx);
509                            break;
510                        }
511                    }
512                    if let Some(idx) = fail_idx {
513                        return Err(Error::invalid_length(idx, &self));
514                    }
515                    Ok(())
516                }
517            }
518
519            impl<'de, const N: usize> Deserialize<'de> for [$ty; N]
520            {
521                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
522                where
523                    D: Deserializer<'de>,
524                {
525                    deserializer.deserialize_fixed_array(ArrayVisitor::<[$ty; N]>::new())
526                }
527
528                fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
529                where
530                    D: Deserializer<'de>,
531                {
532                    deserializer.deserialize_fixed_array(ArrayInPlaceVisitor(place))
533                }
534            }
535        )+
536    }
537}
538
539array_impls!((), bool, char, u8, u16, u32, u64, i8, i16, i32, i64, f16, f32, Pointer, Ulong => next_primitive_element, next_primitive_element_seed);
540array_impls!(Vector4, Quaternion, Matrix3, Rotation, QsTransform, Matrix4, Transform => next_math_element, next_math_element_seed);
541
542impl<'de, T, const N: usize> Visitor<'de> for ArrayVisitor<[T; N]>
543where
544    T: Deserialize<'de> + crate::HavokClass,
545{
546    type Value = [T; N];
547
548    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
549        formatter.write_str(&format!("an array of length {N}"))
550    }
551
552    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
553    where
554        A: SeqAccess<'de>,
555    {
556        let mut array = arrayvec::ArrayVec::<T, N>::new();
557        for _ in 0..N {
558            if let Some(value_i) = tri!(seq.next_class_element()) {
559                array.push(value_i);
560            } else {
561                break;
562            };
563        }
564        match array.take().into_inner() {
565            Ok(array) => Ok(array),
566            Err(array) => Err(Error::invalid_length(
567                array.len(),
568                &(N.to_string().as_str()),
569            )),
570        }
571    }
572}
573
574impl<'de, T, const N: usize> Visitor<'de> for ArrayInPlaceVisitor<'_, [T; N]>
575where
576    T: Deserialize<'de> + crate::HavokClass,
577{
578    type Value = ();
579
580    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
581        formatter.write_str(&format!("an array of length {N}"))
582    }
583
584    #[inline]
585    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
586    where
587        A: SeqAccess<'de>,
588    {
589        let mut fail_idx = None;
590        for (idx, dest) in self.0[..].iter_mut().enumerate() {
591            if tri!(seq.next_class_element_seed(InPlaceSeed(dest))).is_none() {
592                fail_idx = Some(idx);
593                break;
594            }
595        }
596        if let Some(idx) = fail_idx {
597            return Err(Error::invalid_length(idx, &self));
598        }
599        Ok(())
600    }
601}
602
603impl<'de, T, const N: usize> Deserialize<'de> for [T; N]
604where
605    T: Deserialize<'de> + crate::HavokClass,
606{
607    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
608    where
609        D: Deserializer<'de>,
610    {
611        deserializer.deserialize_fixed_array(ArrayVisitor::<[T; N]>::new())
612    }
613
614    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
615    where
616        D: Deserializer<'de>,
617    {
618        deserializer.deserialize_fixed_array(ArrayInPlaceVisitor(place))
619    }
620}
621
622////////////////////////////////////////////////////////////////////////////////
623
624macro_rules! impl_deserialize_for_map {
625    ($($map_ident:ident),+ $(,)?) => {
626        $(
627        impl<'de, T> Deserialize<'de> for $map_ident<usize, T>
628        where
629            T: Deserialize<'de> + crate::HavokClass,
630        {
631            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
632            where
633                D: Deserializer<'de>,
634            {
635                struct MapVisitor<T>(PhantomData<T>);
636
637                impl<'de, T> Visitor<'de> for MapVisitor<T>
638                where
639                    T: Deserialize<'de> + crate::HavokClass,
640                {
641                    type Value = $map_ident<usize, T>;
642
643                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
644                        formatter.write_str("a sequence")
645                    }
646
647                    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
648                    where
649                        A: SeqAccess<'de>,
650                    {
651                        let capacity = size_hint::cautious::<T>(seq.size_hint());
652                        let mut values: Self::Value = $map_ident::with_capacity(capacity);
653
654                        while let Some(value) = tri!(seq.next_class_element()) {
655                            values.insert(tri!(seq.class_ptr()), value);
656                        }
657                        Ok(values)
658                    }
659                }
660
661                let visitor = MapVisitor(PhantomData);
662                deserializer.deserialize_class_index_seq(visitor)
663            }
664        }
665
666        impl<'de, T> Deserialize<'de> for $map_ident<Pointer, T>
667        where
668            T: Deserialize<'de> + crate::HavokClass,
669        {
670            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
671            where
672                D: Deserializer<'de>,
673            {
674                struct MapVisitor<T>(PhantomData<T>);
675
676                impl<'de, T> Visitor<'de> for MapVisitor<T>
677                where
678                    T: Deserialize<'de> + crate::HavokClass,
679                {
680                    type Value = $map_ident<Pointer, T>;
681
682                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
683                        formatter.write_str("a sequence")
684                    }
685
686                    fn visit_array<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
687                    where
688                        A: SeqAccess<'de>,
689                    {
690                        let capacity = size_hint::cautious::<T>(seq.size_hint());
691                        let mut values: Self::Value = $map_ident::with_capacity(capacity);
692
693                        while let Some(value) = tri!(seq.next_class_element()) {
694                            values.insert(Pointer::new(tri!(seq.class_ptr())), value);
695                        }
696                        Ok(values)
697                    }
698                }
699
700                let visitor = MapVisitor(PhantomData);
701                deserializer.deserialize_class_index_seq(visitor)
702            }
703        }
704        )*
705    };
706}
707
708#[cfg(all(feature = "indexmap", feature = "std"))]
709const _: () = {
710    use indexmap::IndexMap;
711    impl_deserialize_for_map!(IndexMap);
712};
713
714#[cfg(any(feature = "std", feature = "alloc"))]
715const _: () = {
716    use std::collections::HashMap;
717    impl_deserialize_for_map!(HashMap);
718};
havok_serde/de/impls.rs

havok_serde/de/
impls.rs
