1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkTrackerSerializableScanSnapshot {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "allocations"))]
35 #[cfg_attr(feature = "serde", serde(rename = "allocations"))]
36 pub m_allocations: Vec<hkTrackerSerializableScanSnapshotAllocation>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "blocks"))]
42 #[cfg_attr(feature = "serde", serde(rename = "blocks"))]
43 pub m_blocks: Vec<hkTrackerSerializableScanSnapshotBlock>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "refs"))]
49 #[cfg_attr(feature = "serde", serde(rename = "refs"))]
50 pub m_refs: Vec<i32>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "typeNames"))]
56 #[cfg_attr(feature = "serde", serde(rename = "typeNames"))]
57 pub m_typeNames: Vec<u8>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "traceText"))]
63 #[cfg_attr(feature = "serde", serde(rename = "traceText"))]
64 pub m_traceText: Vec<u8>,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "traceAddrs"))]
70 #[cfg_attr(feature = "serde", serde(rename = "traceAddrs"))]
71 pub m_traceAddrs: Vec<u64>,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "traceParents"))]
77 #[cfg_attr(feature = "serde", serde(rename = "traceParents"))]
78 pub m_traceParents: Vec<i32>,
79}
80const _: () = {
81 use havok_serde as _serde;
82 impl _serde::HavokClass for hkTrackerSerializableScanSnapshot {
83 #[inline]
84 fn name(&self) -> &'static str {
85 "hkTrackerSerializableScanSnapshot"
86 }
87 #[inline]
88 fn signature(&self) -> _serde::__private::Signature {
89 _serde::__private::Signature::new(0x875af1d9)
90 }
91 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
92 fn deps_indexes(&self) -> Vec<usize> {
93 let mut v = Vec::new();
94 v.extend(
95 self
96 .m_allocations
97 .iter()
98 .flat_map(|class| class.deps_indexes())
99 .collect::<Vec<usize>>(),
100 );
101 v.extend(
102 self
103 .m_blocks
104 .iter()
105 .flat_map(|class| class.deps_indexes())
106 .collect::<Vec<usize>>(),
107 );
108 v
109 }
110 }
111 impl _serde::Serialize for hkTrackerSerializableScanSnapshot {
112 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
113 where
114 S: _serde::ser::Serializer,
115 {
116 let class_meta = self
117 .__ptr
118 .map(|name| (name, _serde::__private::Signature::new(0x875af1d9)));
119 let mut serializer = __serializer
120 .serialize_struct(
121 "hkTrackerSerializableScanSnapshot",
122 class_meta,
123 (92u64, 128u64),
124 )?;
125 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
126 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
127 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
128 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
129 serializer
130 .serialize_array_field(
131 "allocations",
132 &self.m_allocations,
133 TypeSize::Struct {
134 size_x86: 12u64,
135 size_x86_64: 24u64,
136 },
137 )?;
138 serializer
139 .serialize_array_field(
140 "blocks",
141 &self.m_blocks,
142 TypeSize::Struct {
143 size_x86: 24u64,
144 size_x86_64: 40u64,
145 },
146 )?;
147 serializer.serialize_array_field("refs", &self.m_refs, TypeSize::NonPtr)?;
148 serializer
149 .serialize_array_field(
150 "typeNames",
151 &self.m_typeNames,
152 TypeSize::NonPtr,
153 )?;
154 serializer
155 .serialize_array_field(
156 "traceText",
157 &self.m_traceText,
158 TypeSize::NonPtr,
159 )?;
160 serializer
161 .serialize_array_field(
162 "traceAddrs",
163 &self.m_traceAddrs,
164 TypeSize::NonPtr,
165 )?;
166 serializer
167 .serialize_array_field(
168 "traceParents",
169 &self.m_traceParents,
170 TypeSize::NonPtr,
171 )?;
172 serializer.end()
173 }
174 }
175};
176#[doc(hidden)]
177#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
178const _: () = {
179 use havok_serde as _serde;
180 #[automatically_derived]
181 impl<'de> _serde::Deserialize<'de> for hkTrackerSerializableScanSnapshot {
182 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
183 where
184 __D: _serde::Deserializer<'de>,
185 {
186 #[allow(non_camel_case_types)]
187 enum __Field {
188 m_allocations,
189 m_blocks,
190 m_refs,
191 m_typeNames,
192 m_traceText,
193 m_traceAddrs,
194 m_traceParents,
195 __ignore,
196 }
197 struct __FieldVisitor;
198 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
199 type Value = __Field;
200 fn expecting(
201 &self,
202 __formatter: &mut core::fmt::Formatter,
203 ) -> core::fmt::Result {
204 core::fmt::Formatter::write_str(__formatter, "field identifier")
205 }
206 #[allow(clippy::match_single_binding)]
208 #[allow(clippy::reversed_empty_ranges)]
209 #[allow(clippy::single_match)]
210 fn visit_key<__E>(
211 self,
212 __value: &str,
213 ) -> core::result::Result<Self::Value, __E>
214 where
215 __E: _serde::de::Error,
216 {
217 match __value {
218 "allocations" => Ok(__Field::m_allocations),
219 "blocks" => Ok(__Field::m_blocks),
220 "refs" => Ok(__Field::m_refs),
221 "typeNames" => Ok(__Field::m_typeNames),
222 "traceText" => Ok(__Field::m_traceText),
223 "traceAddrs" => Ok(__Field::m_traceAddrs),
224 "traceParents" => Ok(__Field::m_traceParents),
225 _ => Ok(__Field::__ignore),
226 }
227 }
228 }
229 impl<'de> _serde::Deserialize<'de> for __Field {
230 #[inline]
231 fn deserialize<__D>(
232 __deserializer: __D,
233 ) -> core::result::Result<Self, __D::Error>
234 where
235 __D: _serde::Deserializer<'de>,
236 {
237 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
238 }
239 }
240 struct __hkTrackerSerializableScanSnapshotVisitor<'de> {
241 marker: _serde::__private::PhantomData<
242 hkTrackerSerializableScanSnapshot,
243 >,
244 lifetime: _serde::__private::PhantomData<&'de ()>,
245 }
246 #[allow(clippy::match_single_binding)]
247 #[allow(clippy::reversed_empty_ranges)]
248 #[allow(clippy::single_match)]
249 impl<'de> _serde::de::Visitor<'de>
250 for __hkTrackerSerializableScanSnapshotVisitor<'de> {
251 type Value = hkTrackerSerializableScanSnapshot;
252 fn expecting(
253 &self,
254 __formatter: &mut core::fmt::Formatter,
255 ) -> core::fmt::Result {
256 core::fmt::Formatter::write_str(
257 __formatter,
258 "struct hkTrackerSerializableScanSnapshot",
259 )
260 }
261 fn visit_struct_for_bytes<__A>(
262 self,
263 mut __map: __A,
264 ) -> _serde::__private::Result<Self::Value, __A::Error>
265 where
266 __A: _serde::de::MapAccess<'de>,
267 {
268 let __ptr = __A::class_ptr(&mut __map);
269 let parent = __A::parent_value(&mut __map)?;
270 let mut m_allocations: _serde::__private::Option<
271 Vec<hkTrackerSerializableScanSnapshotAllocation>,
272 > = _serde::__private::None;
273 let mut m_blocks: _serde::__private::Option<
274 Vec<hkTrackerSerializableScanSnapshotBlock>,
275 > = _serde::__private::None;
276 let mut m_refs: _serde::__private::Option<Vec<i32>> = _serde::__private::None;
277 let mut m_typeNames: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
278 let mut m_traceText: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
279 let mut m_traceAddrs: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
280 let mut m_traceParents: _serde::__private::Option<Vec<i32>> = _serde::__private::None;
281 for i in 0..7usize {
282 match i {
283 0usize => {
284 if _serde::__private::Option::is_some(&m_allocations) {
285 return _serde::__private::Err(
286 <__A::Error as _serde::de::Error>::duplicate_field(
287 "allocations",
288 ),
289 );
290 }
291 m_allocations = _serde::__private::Some(
292 match __A::next_value::<
293 Vec<hkTrackerSerializableScanSnapshotAllocation>,
294 >(&mut __map) {
295 _serde::__private::Ok(__val) => __val,
296 _serde::__private::Err(__err) => {
297 return _serde::__private::Err(__err);
298 }
299 },
300 );
301 }
302 1usize => {
303 if _serde::__private::Option::is_some(&m_blocks) {
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::duplicate_field("blocks"),
306 );
307 }
308 m_blocks = _serde::__private::Some(
309 match __A::next_value::<
310 Vec<hkTrackerSerializableScanSnapshotBlock>,
311 >(&mut __map) {
312 _serde::__private::Ok(__val) => __val,
313 _serde::__private::Err(__err) => {
314 return _serde::__private::Err(__err);
315 }
316 },
317 );
318 }
319 2usize => {
320 if _serde::__private::Option::is_some(&m_refs) {
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::duplicate_field("refs"),
323 );
324 }
325 m_refs = _serde::__private::Some(
326 match __A::next_value::<Vec<i32>>(&mut __map) {
327 _serde::__private::Ok(__val) => __val,
328 _serde::__private::Err(__err) => {
329 return _serde::__private::Err(__err);
330 }
331 },
332 );
333 }
334 3usize => {
335 if _serde::__private::Option::is_some(&m_typeNames) {
336 return _serde::__private::Err(
337 <__A::Error as _serde::de::Error>::duplicate_field(
338 "typeNames",
339 ),
340 );
341 }
342 m_typeNames = _serde::__private::Some(
343 match __A::next_value::<Vec<u8>>(&mut __map) {
344 _serde::__private::Ok(__val) => __val,
345 _serde::__private::Err(__err) => {
346 return _serde::__private::Err(__err);
347 }
348 },
349 );
350 }
351 4usize => {
352 if _serde::__private::Option::is_some(&m_traceText) {
353 return _serde::__private::Err(
354 <__A::Error as _serde::de::Error>::duplicate_field(
355 "traceText",
356 ),
357 );
358 }
359 m_traceText = _serde::__private::Some(
360 match __A::next_value::<Vec<u8>>(&mut __map) {
361 _serde::__private::Ok(__val) => __val,
362 _serde::__private::Err(__err) => {
363 return _serde::__private::Err(__err);
364 }
365 },
366 );
367 }
368 5usize => {
369 if _serde::__private::Option::is_some(&m_traceAddrs) {
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::duplicate_field(
372 "traceAddrs",
373 ),
374 );
375 }
376 m_traceAddrs = _serde::__private::Some(
377 match __A::next_value::<Vec<u64>>(&mut __map) {
378 _serde::__private::Ok(__val) => __val,
379 _serde::__private::Err(__err) => {
380 return _serde::__private::Err(__err);
381 }
382 },
383 );
384 }
385 6usize => {
386 if _serde::__private::Option::is_some(&m_traceParents) {
387 return _serde::__private::Err(
388 <__A::Error as _serde::de::Error>::duplicate_field(
389 "traceParents",
390 ),
391 );
392 }
393 m_traceParents = _serde::__private::Some(
394 match __A::next_value::<Vec<i32>>(&mut __map) {
395 _serde::__private::Ok(__val) => __val,
396 _serde::__private::Err(__err) => {
397 return _serde::__private::Err(__err);
398 }
399 },
400 );
401 }
402 _ => {}
403 }
404 }
405 let m_allocations = match m_allocations {
406 _serde::__private::Some(__field) => __field,
407 _serde::__private::None => {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::missing_field(
410 "allocations",
411 ),
412 );
413 }
414 };
415 let m_blocks = match m_blocks {
416 _serde::__private::Some(__field) => __field,
417 _serde::__private::None => {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::missing_field("blocks"),
420 );
421 }
422 };
423 let m_refs = match m_refs {
424 _serde::__private::Some(__field) => __field,
425 _serde::__private::None => {
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::missing_field("refs"),
428 );
429 }
430 };
431 let m_typeNames = match m_typeNames {
432 _serde::__private::Some(__field) => __field,
433 _serde::__private::None => {
434 return _serde::__private::Err(
435 <__A::Error as _serde::de::Error>::missing_field(
436 "typeNames",
437 ),
438 );
439 }
440 };
441 let m_traceText = match m_traceText {
442 _serde::__private::Some(__field) => __field,
443 _serde::__private::None => {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::missing_field(
446 "traceText",
447 ),
448 );
449 }
450 };
451 let m_traceAddrs = match m_traceAddrs {
452 _serde::__private::Some(__field) => __field,
453 _serde::__private::None => {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::missing_field(
456 "traceAddrs",
457 ),
458 );
459 }
460 };
461 let m_traceParents = match m_traceParents {
462 _serde::__private::Some(__field) => __field,
463 _serde::__private::None => {
464 return _serde::__private::Err(
465 <__A::Error as _serde::de::Error>::missing_field(
466 "traceParents",
467 ),
468 );
469 }
470 };
471 _serde::__private::Ok(hkTrackerSerializableScanSnapshot {
472 __ptr,
473 parent,
474 m_allocations,
475 m_blocks,
476 m_refs,
477 m_typeNames,
478 m_traceText,
479 m_traceAddrs,
480 m_traceParents,
481 })
482 }
483 #[allow(clippy::manual_unwrap_or_default)]
484 fn visit_struct<__A>(
485 self,
486 mut __map: __A,
487 ) -> _serde::__private::Result<Self::Value, __A::Error>
488 where
489 __A: _serde::de::MapAccess<'de>,
490 {
491 let mut m_allocations: _serde::__private::Option<
492 Vec<hkTrackerSerializableScanSnapshotAllocation>,
493 > = _serde::__private::None;
494 let mut m_blocks: _serde::__private::Option<
495 Vec<hkTrackerSerializableScanSnapshotBlock>,
496 > = _serde::__private::None;
497 let mut m_refs: _serde::__private::Option<Vec<i32>> = _serde::__private::None;
498 let mut m_typeNames: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
499 let mut m_traceText: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
500 let mut m_traceAddrs: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
501 let mut m_traceParents: _serde::__private::Option<Vec<i32>> = _serde::__private::None;
502 while let _serde::__private::Some(__key) = {
503 __A::next_key::<__Field>(&mut __map)?
504 } {
505 match __key {
506 __Field::m_allocations => {
507 #[cfg(
508 any(feature = "strict", feature = "ignore_duplicates")
509 )]
510 if _serde::__private::Option::is_some(&m_allocations) {
511 #[cfg(feature = "ignore_duplicates")]
512 {
513 __A::skip_value(&mut __map)?;
514 continue;
515 }
516 #[cfg(feature = "strict")]
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::duplicate_field(
519 "allocations",
520 ),
521 );
522 }
523 m_allocations = _serde::__private::Some(
524 match __A::next_value::<
525 Vec<hkTrackerSerializableScanSnapshotAllocation>,
526 >(&mut __map) {
527 _serde::__private::Ok(__val) => __val,
528 _serde::__private::Err(__err) => {
529 return _serde::__private::Err(__err);
530 }
531 },
532 );
533 }
534 __Field::m_blocks => {
535 #[cfg(
536 any(feature = "strict", feature = "ignore_duplicates")
537 )]
538 if _serde::__private::Option::is_some(&m_blocks) {
539 #[cfg(feature = "ignore_duplicates")]
540 {
541 __A::skip_value(&mut __map)?;
542 continue;
543 }
544 #[cfg(feature = "strict")]
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::duplicate_field("blocks"),
547 );
548 }
549 m_blocks = _serde::__private::Some(
550 match __A::next_value::<
551 Vec<hkTrackerSerializableScanSnapshotBlock>,
552 >(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 __Field::m_refs => {
561 #[cfg(
562 any(feature = "strict", feature = "ignore_duplicates")
563 )]
564 if _serde::__private::Option::is_some(&m_refs) {
565 #[cfg(feature = "ignore_duplicates")]
566 {
567 __A::skip_value(&mut __map)?;
568 continue;
569 }
570 #[cfg(feature = "strict")]
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::duplicate_field("refs"),
573 );
574 }
575 m_refs = _serde::__private::Some(
576 match __A::next_value::<Vec<i32>>(&mut __map) {
577 _serde::__private::Ok(__val) => __val,
578 _serde::__private::Err(__err) => {
579 return _serde::__private::Err(__err);
580 }
581 },
582 );
583 }
584 __Field::m_typeNames => {
585 #[cfg(
586 any(feature = "strict", feature = "ignore_duplicates")
587 )]
588 if _serde::__private::Option::is_some(&m_typeNames) {
589 #[cfg(feature = "ignore_duplicates")]
590 {
591 __A::skip_value(&mut __map)?;
592 continue;
593 }
594 #[cfg(feature = "strict")]
595 return _serde::__private::Err(
596 <__A::Error as _serde::de::Error>::duplicate_field(
597 "typeNames",
598 ),
599 );
600 }
601 m_typeNames = _serde::__private::Some(
602 match __A::next_value::<Vec<u8>>(&mut __map) {
603 _serde::__private::Ok(__val) => __val,
604 _serde::__private::Err(__err) => {
605 return _serde::__private::Err(__err);
606 }
607 },
608 );
609 }
610 __Field::m_traceText => {
611 #[cfg(
612 any(feature = "strict", feature = "ignore_duplicates")
613 )]
614 if _serde::__private::Option::is_some(&m_traceText) {
615 #[cfg(feature = "ignore_duplicates")]
616 {
617 __A::skip_value(&mut __map)?;
618 continue;
619 }
620 #[cfg(feature = "strict")]
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::duplicate_field(
623 "traceText",
624 ),
625 );
626 }
627 m_traceText = _serde::__private::Some(
628 match __A::next_value::<Vec<u8>>(&mut __map) {
629 _serde::__private::Ok(__val) => __val,
630 _serde::__private::Err(__err) => {
631 return _serde::__private::Err(__err);
632 }
633 },
634 );
635 }
636 __Field::m_traceAddrs => {
637 #[cfg(
638 any(feature = "strict", feature = "ignore_duplicates")
639 )]
640 if _serde::__private::Option::is_some(&m_traceAddrs) {
641 #[cfg(feature = "ignore_duplicates")]
642 {
643 __A::skip_value(&mut __map)?;
644 continue;
645 }
646 #[cfg(feature = "strict")]
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::duplicate_field(
649 "traceAddrs",
650 ),
651 );
652 }
653 m_traceAddrs = _serde::__private::Some(
654 match __A::next_value::<Vec<u64>>(&mut __map) {
655 _serde::__private::Ok(__val) => __val,
656 _serde::__private::Err(__err) => {
657 return _serde::__private::Err(__err);
658 }
659 },
660 );
661 }
662 __Field::m_traceParents => {
663 #[cfg(
664 any(feature = "strict", feature = "ignore_duplicates")
665 )]
666 if _serde::__private::Option::is_some(&m_traceParents) {
667 #[cfg(feature = "ignore_duplicates")]
668 {
669 __A::skip_value(&mut __map)?;
670 continue;
671 }
672 #[cfg(feature = "strict")]
673 return _serde::__private::Err(
674 <__A::Error as _serde::de::Error>::duplicate_field(
675 "traceParents",
676 ),
677 );
678 }
679 m_traceParents = _serde::__private::Some(
680 match __A::next_value::<Vec<i32>>(&mut __map) {
681 _serde::__private::Ok(__val) => __val,
682 _serde::__private::Err(__err) => {
683 return _serde::__private::Err(__err);
684 }
685 },
686 );
687 }
688 _ => __A::skip_value(&mut __map)?,
689 }
690 }
691 let m_allocations = match m_allocations {
692 _serde::__private::Some(__field) => __field,
693 _serde::__private::None => {
694 #[cfg(feature = "strict")]
695 return _serde::__private::Err(
696 <__A::Error as _serde::de::Error>::missing_field(
697 "allocations",
698 ),
699 );
700 #[cfg(not(feature = "strict"))] Default::default()
701 }
702 };
703 let m_blocks = match m_blocks {
704 _serde::__private::Some(__field) => __field,
705 _serde::__private::None => {
706 #[cfg(feature = "strict")]
707 return _serde::__private::Err(
708 <__A::Error as _serde::de::Error>::missing_field("blocks"),
709 );
710 #[cfg(not(feature = "strict"))] Default::default()
711 }
712 };
713 let m_refs = match m_refs {
714 _serde::__private::Some(__field) => __field,
715 _serde::__private::None => {
716 #[cfg(feature = "strict")]
717 return _serde::__private::Err(
718 <__A::Error as _serde::de::Error>::missing_field("refs"),
719 );
720 #[cfg(not(feature = "strict"))] Default::default()
721 }
722 };
723 let m_typeNames = match m_typeNames {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 #[cfg(feature = "strict")]
727 return _serde::__private::Err(
728 <__A::Error as _serde::de::Error>::missing_field(
729 "typeNames",
730 ),
731 );
732 #[cfg(not(feature = "strict"))] Default::default()
733 }
734 };
735 let m_traceText = match m_traceText {
736 _serde::__private::Some(__field) => __field,
737 _serde::__private::None => {
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::missing_field(
741 "traceText",
742 ),
743 );
744 #[cfg(not(feature = "strict"))] Default::default()
745 }
746 };
747 let m_traceAddrs = match m_traceAddrs {
748 _serde::__private::Some(__field) => __field,
749 _serde::__private::None => {
750 #[cfg(feature = "strict")]
751 return _serde::__private::Err(
752 <__A::Error as _serde::de::Error>::missing_field(
753 "traceAddrs",
754 ),
755 );
756 #[cfg(not(feature = "strict"))] Default::default()
757 }
758 };
759 let m_traceParents = match m_traceParents {
760 _serde::__private::Some(__field) => __field,
761 _serde::__private::None => {
762 #[cfg(feature = "strict")]
763 return _serde::__private::Err(
764 <__A::Error as _serde::de::Error>::missing_field(
765 "traceParents",
766 ),
767 );
768 #[cfg(not(feature = "strict"))] Default::default()
769 }
770 };
771 let __ptr = None;
772 let parent = hkBaseObject { __ptr };
773 let parent = hkReferencedObject {
774 __ptr,
775 parent,
776 ..Default::default()
777 };
778 let __ptr = __A::class_ptr(&mut __map);
779 _serde::__private::Ok(hkTrackerSerializableScanSnapshot {
780 __ptr,
781 parent,
782 m_allocations,
783 m_blocks,
784 m_refs,
785 m_typeNames,
786 m_traceText,
787 m_traceAddrs,
788 m_traceParents,
789 })
790 }
791 }
792 const FIELDS: &[&str] = &[
793 "allocations",
794 "blocks",
795 "refs",
796 "typeNames",
797 "traceText",
798 "traceAddrs",
799 "traceParents",
800 ];
801 _serde::Deserializer::deserialize_struct(
802 deserializer,
803 "hkTrackerSerializableScanSnapshot",
804 FIELDS,
805 __hkTrackerSerializableScanSnapshotVisitor {
806 marker: _serde::__private::PhantomData::<
807 hkTrackerSerializableScanSnapshot,
808 >,
809 lifetime: _serde::__private::PhantomData,
810 },
811 )
812 }
813 }
814};