havok_classes/generated/
hkTrackerSerializableScanSnapshot_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkTrackerSerializableScanSnapshot`
5/// - version: `0`
6/// - signature: `0x875af1d9`
7/// - size: ` 92`(x86)/`128`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `allocations`(ctype: `hkArray<struct hkTrackerSerializableScanSnapshotAllocation>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "allocations"))]
35    #[cfg_attr(feature = "serde", serde(rename = "allocations"))]
36    pub m_allocations: Vec<hkTrackerSerializableScanSnapshotAllocation>,
37    /// # C++ Info
38    /// - name: `blocks`(ctype: `hkArray<struct hkTrackerSerializableScanSnapshotBlock>`)
39    /// - offset: ` 20`(x86)/` 32`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "blocks"))]
42    #[cfg_attr(feature = "serde", serde(rename = "blocks"))]
43    pub m_blocks: Vec<hkTrackerSerializableScanSnapshotBlock>,
44    /// # C++ Info
45    /// - name: `refs`(ctype: `hkArray<hkInt32>`)
46    /// - offset: ` 32`(x86)/` 48`(x86_64)
47    /// - type_size: ` 12`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "refs"))]
49    #[cfg_attr(feature = "serde", serde(rename = "refs"))]
50    pub m_refs: Vec<i32>,
51    /// # C++ Info
52    /// - name: `typeNames`(ctype: `hkArray<hkUint8>`)
53    /// - offset: ` 44`(x86)/` 64`(x86_64)
54    /// - type_size: ` 12`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "typeNames"))]
56    #[cfg_attr(feature = "serde", serde(rename = "typeNames"))]
57    pub m_typeNames: Vec<u8>,
58    /// # C++ Info
59    /// - name: `traceText`(ctype: `hkArray<hkUint8>`)
60    /// - offset: ` 56`(x86)/` 80`(x86_64)
61    /// - type_size: ` 12`(x86)/` 16`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "traceText"))]
63    #[cfg_attr(feature = "serde", serde(rename = "traceText"))]
64    pub m_traceText: Vec<u8>,
65    /// # C++ Info
66    /// - name: `traceAddrs`(ctype: `hkArray<hkUint64>`)
67    /// - offset: ` 68`(x86)/` 96`(x86_64)
68    /// - type_size: ` 12`(x86)/` 16`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "traceAddrs"))]
70    #[cfg_attr(feature = "serde", serde(rename = "traceAddrs"))]
71    pub m_traceAddrs: Vec<u64>,
72    /// # C++ Info
73    /// - name: `traceParents`(ctype: `hkArray<hkInt32>`)
74    /// - offset: ` 80`(x86)/`112`(x86_64)
75    /// - type_size: ` 12`(x86)/` 16`(x86_64)
76    #[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                /// Intended for use in XML.
207                #[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};