1use super::{Deserialize, Deserializer, Error, Visitor};
22use crate::de::{SeqAccess, seed::InPlaceSeed, size_hint};
23use crate::lib::*;
24use havok_types::*;
25
26macro_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
85impl<'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
119impl<'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
146impl<'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#[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
255macro_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#[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
443struct 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
622macro_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};