havok_classes/generated/
hkPackfileHeader_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkPackfileHeader`
5/// - version: `1`
6/// - signature: `0x79f9ffda`
7/// - size: ` 64`(x86)/` 64`(x86_64)
8/// -  vtable: `false`
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 hkPackfileHeader {
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    /// # C++ Info
27    /// - name: `magic`(ctype: `hkInt32[2]`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  8`(x86)/`  8`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "magic"))]
31    #[cfg_attr(feature = "serde", serde(rename = "magic"))]
32    pub m_magic: [i32; 2usize],
33    /// # C++ Info
34    /// - name: `userTag`(ctype: `hkInt32`)
35    /// - offset: `  8`(x86)/`  8`(x86_64)
36    /// - type_size: `  4`(x86)/`  4`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "userTag"))]
38    #[cfg_attr(feature = "serde", serde(rename = "userTag"))]
39    pub m_userTag: i32,
40    /// # C++ Info
41    /// - name: `fileVersion`(ctype: `hkInt32`)
42    /// - offset: ` 12`(x86)/` 12`(x86_64)
43    /// - type_size: `  4`(x86)/`  4`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "fileVersion"))]
45    #[cfg_attr(feature = "serde", serde(rename = "fileVersion"))]
46    pub m_fileVersion: i32,
47    /// # C++ Info
48    /// - name: `layoutRules`(ctype: `hkUint8[4]`)
49    /// - offset: ` 16`(x86)/` 16`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "layoutRules"))]
52    #[cfg_attr(feature = "serde", serde(rename = "layoutRules"))]
53    pub m_layoutRules: [u8; 4usize],
54    /// # C++ Info
55    /// - name: `numSections`(ctype: `hkInt32`)
56    /// - offset: ` 20`(x86)/` 20`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "numSections"))]
59    #[cfg_attr(feature = "serde", serde(rename = "numSections"))]
60    pub m_numSections: i32,
61    /// # C++ Info
62    /// - name: `contentsSectionIndex`(ctype: `hkInt32`)
63    /// - offset: ` 24`(x86)/` 24`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "contentsSectionIndex"))]
66    #[cfg_attr(feature = "serde", serde(rename = "contentsSectionIndex"))]
67    pub m_contentsSectionIndex: i32,
68    /// # C++ Info
69    /// - name: `contentsSectionOffset`(ctype: `hkInt32`)
70    /// - offset: ` 28`(x86)/` 28`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "contentsSectionOffset"))]
73    #[cfg_attr(feature = "serde", serde(rename = "contentsSectionOffset"))]
74    pub m_contentsSectionOffset: i32,
75    /// # C++ Info
76    /// - name: `contentsClassNameSectionIndex`(ctype: `hkInt32`)
77    /// - offset: ` 32`(x86)/` 32`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(
80        feature = "json_schema",
81        schemars(rename = "contentsClassNameSectionIndex")
82    )]
83    #[cfg_attr(feature = "serde", serde(rename = "contentsClassNameSectionIndex"))]
84    pub m_contentsClassNameSectionIndex: i32,
85    /// # C++ Info
86    /// - name: `contentsClassNameSectionOffset`(ctype: `hkInt32`)
87    /// - offset: ` 36`(x86)/` 36`(x86_64)
88    /// - type_size: `  4`(x86)/`  4`(x86_64)
89    #[cfg_attr(
90        feature = "json_schema",
91        schemars(rename = "contentsClassNameSectionOffset")
92    )]
93    #[cfg_attr(feature = "serde", serde(rename = "contentsClassNameSectionOffset"))]
94    pub m_contentsClassNameSectionOffset: i32,
95    /// # C++ Info
96    /// - name: `contentsVersion`(ctype: `hkChar[16]`)
97    /// - offset: ` 40`(x86)/` 40`(x86_64)
98    /// - type_size: ` 16`(x86)/` 16`(x86_64)
99    #[cfg_attr(feature = "json_schema", schemars(rename = "contentsVersion"))]
100    #[cfg_attr(feature = "serde", serde(rename = "contentsVersion"))]
101    pub m_contentsVersion: [char; 16usize],
102    /// # C++ Info
103    /// - name: `flags`(ctype: `hkInt32`)
104    /// - offset: ` 56`(x86)/` 56`(x86_64)
105    /// - type_size: `  4`(x86)/`  4`(x86_64)
106    #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
107    #[cfg_attr(feature = "serde", serde(rename = "flags"))]
108    pub m_flags: i32,
109    /// # C++ Info
110    /// - name: `pad`(ctype: `hkInt32[1]`)
111    /// - offset: ` 60`(x86)/` 60`(x86_64)
112    /// - type_size: `  4`(x86)/`  4`(x86_64)
113    #[cfg_attr(feature = "json_schema", schemars(rename = "pad"))]
114    #[cfg_attr(feature = "serde", serde(rename = "pad"))]
115    pub m_pad: [i32; 1usize],
116}
117const _: () = {
118    use havok_serde as _serde;
119    impl _serde::HavokClass for hkPackfileHeader {
120        #[inline]
121        fn name(&self) -> &'static str {
122            "hkPackfileHeader"
123        }
124        #[inline]
125        fn signature(&self) -> _serde::__private::Signature {
126            _serde::__private::Signature::new(0x79f9ffda)
127        }
128        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
129        fn deps_indexes(&self) -> Vec<usize> {
130            let mut v = Vec::new();
131            v
132        }
133    }
134    impl _serde::Serialize for hkPackfileHeader {
135        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
136        where
137            S: _serde::ser::Serializer,
138        {
139            let class_meta = self
140                .__ptr
141                .map(|name| (name, _serde::__private::Signature::new(0x79f9ffda)));
142            let mut serializer = __serializer
143                .serialize_struct("hkPackfileHeader", class_meta, (64u64, 64u64))?;
144            serializer
145                .serialize_fixed_array_field(
146                    "magic",
147                    self.m_magic.as_slice(),
148                    TypeSize::NonPtr,
149                )?;
150            serializer.serialize_field("userTag", &self.m_userTag)?;
151            serializer.serialize_field("fileVersion", &self.m_fileVersion)?;
152            serializer
153                .serialize_fixed_array_field(
154                    "layoutRules",
155                    self.m_layoutRules.as_slice(),
156                    TypeSize::NonPtr,
157                )?;
158            serializer.serialize_field("numSections", &self.m_numSections)?;
159            serializer
160                .serialize_field("contentsSectionIndex", &self.m_contentsSectionIndex)?;
161            serializer
162                .serialize_field(
163                    "contentsSectionOffset",
164                    &self.m_contentsSectionOffset,
165                )?;
166            serializer
167                .serialize_field(
168                    "contentsClassNameSectionIndex",
169                    &self.m_contentsClassNameSectionIndex,
170                )?;
171            serializer
172                .serialize_field(
173                    "contentsClassNameSectionOffset",
174                    &self.m_contentsClassNameSectionOffset,
175                )?;
176            serializer
177                .serialize_fixed_array_field(
178                    "contentsVersion",
179                    self.m_contentsVersion.as_slice(),
180                    TypeSize::NonPtr,
181                )?;
182            serializer.serialize_field("flags", &self.m_flags)?;
183            serializer
184                .serialize_fixed_array_field(
185                    "pad",
186                    self.m_pad.as_slice(),
187                    TypeSize::NonPtr,
188                )?;
189            serializer.end()
190        }
191    }
192};
193#[doc(hidden)]
194#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
195const _: () = {
196    use havok_serde as _serde;
197    #[automatically_derived]
198    impl<'de> _serde::Deserialize<'de> for hkPackfileHeader {
199        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
200        where
201            __D: _serde::Deserializer<'de>,
202        {
203            #[allow(non_camel_case_types)]
204            enum __Field {
205                m_magic,
206                m_userTag,
207                m_fileVersion,
208                m_layoutRules,
209                m_numSections,
210                m_contentsSectionIndex,
211                m_contentsSectionOffset,
212                m_contentsClassNameSectionIndex,
213                m_contentsClassNameSectionOffset,
214                m_contentsVersion,
215                m_flags,
216                m_pad,
217                __ignore,
218            }
219            struct __FieldVisitor;
220            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
221                type Value = __Field;
222                fn expecting(
223                    &self,
224                    __formatter: &mut core::fmt::Formatter,
225                ) -> core::fmt::Result {
226                    core::fmt::Formatter::write_str(__formatter, "field identifier")
227                }
228                /// Intended for use in XML.
229                #[allow(clippy::match_single_binding)]
230                #[allow(clippy::reversed_empty_ranges)]
231                #[allow(clippy::single_match)]
232                fn visit_key<__E>(
233                    self,
234                    __value: &str,
235                ) -> core::result::Result<Self::Value, __E>
236                where
237                    __E: _serde::de::Error,
238                {
239                    match __value {
240                        "magic" => Ok(__Field::m_magic),
241                        "userTag" => Ok(__Field::m_userTag),
242                        "fileVersion" => Ok(__Field::m_fileVersion),
243                        "layoutRules" => Ok(__Field::m_layoutRules),
244                        "numSections" => Ok(__Field::m_numSections),
245                        "contentsSectionIndex" => Ok(__Field::m_contentsSectionIndex),
246                        "contentsSectionOffset" => Ok(__Field::m_contentsSectionOffset),
247                        "contentsClassNameSectionIndex" => {
248                            Ok(__Field::m_contentsClassNameSectionIndex)
249                        }
250                        "contentsClassNameSectionOffset" => {
251                            Ok(__Field::m_contentsClassNameSectionOffset)
252                        }
253                        "contentsVersion" => Ok(__Field::m_contentsVersion),
254                        "flags" => Ok(__Field::m_flags),
255                        "pad" => Ok(__Field::m_pad),
256                        _ => Ok(__Field::__ignore),
257                    }
258                }
259            }
260            impl<'de> _serde::Deserialize<'de> for __Field {
261                #[inline]
262                fn deserialize<__D>(
263                    __deserializer: __D,
264                ) -> core::result::Result<Self, __D::Error>
265                where
266                    __D: _serde::Deserializer<'de>,
267                {
268                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
269                }
270            }
271            struct __hkPackfileHeaderVisitor<'de> {
272                marker: _serde::__private::PhantomData<hkPackfileHeader>,
273                lifetime: _serde::__private::PhantomData<&'de ()>,
274            }
275            #[allow(clippy::match_single_binding)]
276            #[allow(clippy::reversed_empty_ranges)]
277            #[allow(clippy::single_match)]
278            impl<'de> _serde::de::Visitor<'de> for __hkPackfileHeaderVisitor<'de> {
279                type Value = hkPackfileHeader;
280                fn expecting(
281                    &self,
282                    __formatter: &mut core::fmt::Formatter,
283                ) -> core::fmt::Result {
284                    core::fmt::Formatter::write_str(
285                        __formatter,
286                        "struct hkPackfileHeader",
287                    )
288                }
289                fn visit_struct_for_bytes<__A>(
290                    self,
291                    mut __map: __A,
292                ) -> _serde::__private::Result<Self::Value, __A::Error>
293                where
294                    __A: _serde::de::MapAccess<'de>,
295                {
296                    let __ptr = __A::class_ptr(&mut __map);
297                    let mut m_magic: _serde::__private::Option<[i32; 2usize]> = _serde::__private::None;
298                    let mut m_userTag: _serde::__private::Option<i32> = _serde::__private::None;
299                    let mut m_fileVersion: _serde::__private::Option<i32> = _serde::__private::None;
300                    let mut m_layoutRules: _serde::__private::Option<[u8; 4usize]> = _serde::__private::None;
301                    let mut m_numSections: _serde::__private::Option<i32> = _serde::__private::None;
302                    let mut m_contentsSectionIndex: _serde::__private::Option<i32> = _serde::__private::None;
303                    let mut m_contentsSectionOffset: _serde::__private::Option<i32> = _serde::__private::None;
304                    let mut m_contentsClassNameSectionIndex: _serde::__private::Option<
305                        i32,
306                    > = _serde::__private::None;
307                    let mut m_contentsClassNameSectionOffset: _serde::__private::Option<
308                        i32,
309                    > = _serde::__private::None;
310                    let mut m_contentsVersion: _serde::__private::Option<
311                        [char; 16usize],
312                    > = _serde::__private::None;
313                    let mut m_flags: _serde::__private::Option<i32> = _serde::__private::None;
314                    let mut m_pad: _serde::__private::Option<[i32; 1usize]> = _serde::__private::None;
315                    for i in 0..12usize {
316                        match i {
317                            0usize => {
318                                if _serde::__private::Option::is_some(&m_magic) {
319                                    return _serde::__private::Err(
320                                        <__A::Error as _serde::de::Error>::duplicate_field("magic"),
321                                    );
322                                }
323                                m_magic = _serde::__private::Some(
324                                    match __A::next_value::<[i32; 2usize]>(&mut __map) {
325                                        _serde::__private::Ok(__val) => __val,
326                                        _serde::__private::Err(__err) => {
327                                            return _serde::__private::Err(__err);
328                                        }
329                                    },
330                                );
331                            }
332                            1usize => {
333                                if _serde::__private::Option::is_some(&m_userTag) {
334                                    return _serde::__private::Err(
335                                        <__A::Error as _serde::de::Error>::duplicate_field(
336                                            "userTag",
337                                        ),
338                                    );
339                                }
340                                m_userTag = _serde::__private::Some(
341                                    match __A::next_value::<i32>(&mut __map) {
342                                        _serde::__private::Ok(__val) => __val,
343                                        _serde::__private::Err(__err) => {
344                                            return _serde::__private::Err(__err);
345                                        }
346                                    },
347                                );
348                            }
349                            2usize => {
350                                if _serde::__private::Option::is_some(&m_fileVersion) {
351                                    return _serde::__private::Err(
352                                        <__A::Error as _serde::de::Error>::duplicate_field(
353                                            "fileVersion",
354                                        ),
355                                    );
356                                }
357                                m_fileVersion = _serde::__private::Some(
358                                    match __A::next_value::<i32>(&mut __map) {
359                                        _serde::__private::Ok(__val) => __val,
360                                        _serde::__private::Err(__err) => {
361                                            return _serde::__private::Err(__err);
362                                        }
363                                    },
364                                );
365                            }
366                            3usize => {
367                                if _serde::__private::Option::is_some(&m_layoutRules) {
368                                    return _serde::__private::Err(
369                                        <__A::Error as _serde::de::Error>::duplicate_field(
370                                            "layoutRules",
371                                        ),
372                                    );
373                                }
374                                m_layoutRules = _serde::__private::Some(
375                                    match __A::next_value::<[u8; 4usize]>(&mut __map) {
376                                        _serde::__private::Ok(__val) => __val,
377                                        _serde::__private::Err(__err) => {
378                                            return _serde::__private::Err(__err);
379                                        }
380                                    },
381                                );
382                            }
383                            4usize => {
384                                if _serde::__private::Option::is_some(&m_numSections) {
385                                    return _serde::__private::Err(
386                                        <__A::Error as _serde::de::Error>::duplicate_field(
387                                            "numSections",
388                                        ),
389                                    );
390                                }
391                                m_numSections = _serde::__private::Some(
392                                    match __A::next_value::<i32>(&mut __map) {
393                                        _serde::__private::Ok(__val) => __val,
394                                        _serde::__private::Err(__err) => {
395                                            return _serde::__private::Err(__err);
396                                        }
397                                    },
398                                );
399                            }
400                            5usize => {
401                                if _serde::__private::Option::is_some(
402                                    &m_contentsSectionIndex,
403                                ) {
404                                    return _serde::__private::Err(
405                                        <__A::Error as _serde::de::Error>::duplicate_field(
406                                            "contentsSectionIndex",
407                                        ),
408                                    );
409                                }
410                                m_contentsSectionIndex = _serde::__private::Some(
411                                    match __A::next_value::<i32>(&mut __map) {
412                                        _serde::__private::Ok(__val) => __val,
413                                        _serde::__private::Err(__err) => {
414                                            return _serde::__private::Err(__err);
415                                        }
416                                    },
417                                );
418                            }
419                            6usize => {
420                                if _serde::__private::Option::is_some(
421                                    &m_contentsSectionOffset,
422                                ) {
423                                    return _serde::__private::Err(
424                                        <__A::Error as _serde::de::Error>::duplicate_field(
425                                            "contentsSectionOffset",
426                                        ),
427                                    );
428                                }
429                                m_contentsSectionOffset = _serde::__private::Some(
430                                    match __A::next_value::<i32>(&mut __map) {
431                                        _serde::__private::Ok(__val) => __val,
432                                        _serde::__private::Err(__err) => {
433                                            return _serde::__private::Err(__err);
434                                        }
435                                    },
436                                );
437                            }
438                            7usize => {
439                                if _serde::__private::Option::is_some(
440                                    &m_contentsClassNameSectionIndex,
441                                ) {
442                                    return _serde::__private::Err(
443                                        <__A::Error as _serde::de::Error>::duplicate_field(
444                                            "contentsClassNameSectionIndex",
445                                        ),
446                                    );
447                                }
448                                m_contentsClassNameSectionIndex = _serde::__private::Some(
449                                    match __A::next_value::<i32>(&mut __map) {
450                                        _serde::__private::Ok(__val) => __val,
451                                        _serde::__private::Err(__err) => {
452                                            return _serde::__private::Err(__err);
453                                        }
454                                    },
455                                );
456                            }
457                            8usize => {
458                                if _serde::__private::Option::is_some(
459                                    &m_contentsClassNameSectionOffset,
460                                ) {
461                                    return _serde::__private::Err(
462                                        <__A::Error as _serde::de::Error>::duplicate_field(
463                                            "contentsClassNameSectionOffset",
464                                        ),
465                                    );
466                                }
467                                m_contentsClassNameSectionOffset = _serde::__private::Some(
468                                    match __A::next_value::<i32>(&mut __map) {
469                                        _serde::__private::Ok(__val) => __val,
470                                        _serde::__private::Err(__err) => {
471                                            return _serde::__private::Err(__err);
472                                        }
473                                    },
474                                );
475                            }
476                            9usize => {
477                                if _serde::__private::Option::is_some(&m_contentsVersion) {
478                                    return _serde::__private::Err(
479                                        <__A::Error as _serde::de::Error>::duplicate_field(
480                                            "contentsVersion",
481                                        ),
482                                    );
483                                }
484                                m_contentsVersion = _serde::__private::Some(
485                                    match __A::next_value::<[char; 16usize]>(&mut __map) {
486                                        _serde::__private::Ok(__val) => __val,
487                                        _serde::__private::Err(__err) => {
488                                            return _serde::__private::Err(__err);
489                                        }
490                                    },
491                                );
492                            }
493                            10usize => {
494                                if _serde::__private::Option::is_some(&m_flags) {
495                                    return _serde::__private::Err(
496                                        <__A::Error as _serde::de::Error>::duplicate_field("flags"),
497                                    );
498                                }
499                                m_flags = _serde::__private::Some(
500                                    match __A::next_value::<i32>(&mut __map) {
501                                        _serde::__private::Ok(__val) => __val,
502                                        _serde::__private::Err(__err) => {
503                                            return _serde::__private::Err(__err);
504                                        }
505                                    },
506                                );
507                            }
508                            11usize => {
509                                if _serde::__private::Option::is_some(&m_pad) {
510                                    return _serde::__private::Err(
511                                        <__A::Error as _serde::de::Error>::duplicate_field("pad"),
512                                    );
513                                }
514                                m_pad = _serde::__private::Some(
515                                    match __A::next_value::<[i32; 1usize]>(&mut __map) {
516                                        _serde::__private::Ok(__val) => __val,
517                                        _serde::__private::Err(__err) => {
518                                            return _serde::__private::Err(__err);
519                                        }
520                                    },
521                                );
522                            }
523                            _ => {}
524                        }
525                    }
526                    let m_magic = match m_magic {
527                        _serde::__private::Some(__field) => __field,
528                        _serde::__private::None => {
529                            return _serde::__private::Err(
530                                <__A::Error as _serde::de::Error>::missing_field("magic"),
531                            );
532                        }
533                    };
534                    let m_userTag = match m_userTag {
535                        _serde::__private::Some(__field) => __field,
536                        _serde::__private::None => {
537                            return _serde::__private::Err(
538                                <__A::Error as _serde::de::Error>::missing_field("userTag"),
539                            );
540                        }
541                    };
542                    let m_fileVersion = match m_fileVersion {
543                        _serde::__private::Some(__field) => __field,
544                        _serde::__private::None => {
545                            return _serde::__private::Err(
546                                <__A::Error as _serde::de::Error>::missing_field(
547                                    "fileVersion",
548                                ),
549                            );
550                        }
551                    };
552                    let m_layoutRules = match m_layoutRules {
553                        _serde::__private::Some(__field) => __field,
554                        _serde::__private::None => {
555                            return _serde::__private::Err(
556                                <__A::Error as _serde::de::Error>::missing_field(
557                                    "layoutRules",
558                                ),
559                            );
560                        }
561                    };
562                    let m_numSections = match m_numSections {
563                        _serde::__private::Some(__field) => __field,
564                        _serde::__private::None => {
565                            return _serde::__private::Err(
566                                <__A::Error as _serde::de::Error>::missing_field(
567                                    "numSections",
568                                ),
569                            );
570                        }
571                    };
572                    let m_contentsSectionIndex = match m_contentsSectionIndex {
573                        _serde::__private::Some(__field) => __field,
574                        _serde::__private::None => {
575                            return _serde::__private::Err(
576                                <__A::Error as _serde::de::Error>::missing_field(
577                                    "contentsSectionIndex",
578                                ),
579                            );
580                        }
581                    };
582                    let m_contentsSectionOffset = match m_contentsSectionOffset {
583                        _serde::__private::Some(__field) => __field,
584                        _serde::__private::None => {
585                            return _serde::__private::Err(
586                                <__A::Error as _serde::de::Error>::missing_field(
587                                    "contentsSectionOffset",
588                                ),
589                            );
590                        }
591                    };
592                    let m_contentsClassNameSectionIndex = match m_contentsClassNameSectionIndex {
593                        _serde::__private::Some(__field) => __field,
594                        _serde::__private::None => {
595                            return _serde::__private::Err(
596                                <__A::Error as _serde::de::Error>::missing_field(
597                                    "contentsClassNameSectionIndex",
598                                ),
599                            );
600                        }
601                    };
602                    let m_contentsClassNameSectionOffset = match m_contentsClassNameSectionOffset {
603                        _serde::__private::Some(__field) => __field,
604                        _serde::__private::None => {
605                            return _serde::__private::Err(
606                                <__A::Error as _serde::de::Error>::missing_field(
607                                    "contentsClassNameSectionOffset",
608                                ),
609                            );
610                        }
611                    };
612                    let m_contentsVersion = match m_contentsVersion {
613                        _serde::__private::Some(__field) => __field,
614                        _serde::__private::None => {
615                            return _serde::__private::Err(
616                                <__A::Error as _serde::de::Error>::missing_field(
617                                    "contentsVersion",
618                                ),
619                            );
620                        }
621                    };
622                    let m_flags = match m_flags {
623                        _serde::__private::Some(__field) => __field,
624                        _serde::__private::None => {
625                            return _serde::__private::Err(
626                                <__A::Error as _serde::de::Error>::missing_field("flags"),
627                            );
628                        }
629                    };
630                    let m_pad = match m_pad {
631                        _serde::__private::Some(__field) => __field,
632                        _serde::__private::None => {
633                            return _serde::__private::Err(
634                                <__A::Error as _serde::de::Error>::missing_field("pad"),
635                            );
636                        }
637                    };
638                    _serde::__private::Ok(hkPackfileHeader {
639                        __ptr,
640                        m_magic,
641                        m_userTag,
642                        m_fileVersion,
643                        m_layoutRules,
644                        m_numSections,
645                        m_contentsSectionIndex,
646                        m_contentsSectionOffset,
647                        m_contentsClassNameSectionIndex,
648                        m_contentsClassNameSectionOffset,
649                        m_contentsVersion,
650                        m_flags,
651                        m_pad,
652                    })
653                }
654                #[allow(clippy::manual_unwrap_or_default)]
655                fn visit_struct<__A>(
656                    self,
657                    mut __map: __A,
658                ) -> _serde::__private::Result<Self::Value, __A::Error>
659                where
660                    __A: _serde::de::MapAccess<'de>,
661                {
662                    let mut m_magic: _serde::__private::Option<[i32; 2usize]> = _serde::__private::None;
663                    let mut m_userTag: _serde::__private::Option<i32> = _serde::__private::None;
664                    let mut m_fileVersion: _serde::__private::Option<i32> = _serde::__private::None;
665                    let mut m_layoutRules: _serde::__private::Option<[u8; 4usize]> = _serde::__private::None;
666                    let mut m_numSections: _serde::__private::Option<i32> = _serde::__private::None;
667                    let mut m_contentsSectionIndex: _serde::__private::Option<i32> = _serde::__private::None;
668                    let mut m_contentsSectionOffset: _serde::__private::Option<i32> = _serde::__private::None;
669                    let mut m_contentsClassNameSectionIndex: _serde::__private::Option<
670                        i32,
671                    > = _serde::__private::None;
672                    let mut m_contentsClassNameSectionOffset: _serde::__private::Option<
673                        i32,
674                    > = _serde::__private::None;
675                    let mut m_contentsVersion: _serde::__private::Option<
676                        [char; 16usize],
677                    > = _serde::__private::None;
678                    let mut m_flags: _serde::__private::Option<i32> = _serde::__private::None;
679                    let mut m_pad: _serde::__private::Option<[i32; 1usize]> = _serde::__private::None;
680                    while let _serde::__private::Some(__key) = {
681                        __A::next_key::<__Field>(&mut __map)?
682                    } {
683                        match __key {
684                            __Field::m_magic => {
685                                #[cfg(
686                                    any(feature = "strict", feature = "ignore_duplicates")
687                                )]
688                                if _serde::__private::Option::is_some(&m_magic) {
689                                    #[cfg(feature = "ignore_duplicates")]
690                                    {
691                                        __A::skip_value(&mut __map)?;
692                                        continue;
693                                    }
694                                    #[cfg(feature = "strict")]
695                                    return _serde::__private::Err(
696                                        <__A::Error as _serde::de::Error>::duplicate_field("magic"),
697                                    );
698                                }
699                                m_magic = _serde::__private::Some(
700                                    match __A::next_value::<[i32; 2usize]>(&mut __map) {
701                                        _serde::__private::Ok(__val) => __val,
702                                        _serde::__private::Err(__err) => {
703                                            return _serde::__private::Err(__err);
704                                        }
705                                    },
706                                );
707                            }
708                            __Field::m_userTag => {
709                                #[cfg(
710                                    any(feature = "strict", feature = "ignore_duplicates")
711                                )]
712                                if _serde::__private::Option::is_some(&m_userTag) {
713                                    #[cfg(feature = "ignore_duplicates")]
714                                    {
715                                        __A::skip_value(&mut __map)?;
716                                        continue;
717                                    }
718                                    #[cfg(feature = "strict")]
719                                    return _serde::__private::Err(
720                                        <__A::Error as _serde::de::Error>::duplicate_field(
721                                            "userTag",
722                                        ),
723                                    );
724                                }
725                                m_userTag = _serde::__private::Some(
726                                    match __A::next_value::<i32>(&mut __map) {
727                                        _serde::__private::Ok(__val) => __val,
728                                        _serde::__private::Err(__err) => {
729                                            return _serde::__private::Err(__err);
730                                        }
731                                    },
732                                );
733                            }
734                            __Field::m_fileVersion => {
735                                #[cfg(
736                                    any(feature = "strict", feature = "ignore_duplicates")
737                                )]
738                                if _serde::__private::Option::is_some(&m_fileVersion) {
739                                    #[cfg(feature = "ignore_duplicates")]
740                                    {
741                                        __A::skip_value(&mut __map)?;
742                                        continue;
743                                    }
744                                    #[cfg(feature = "strict")]
745                                    return _serde::__private::Err(
746                                        <__A::Error as _serde::de::Error>::duplicate_field(
747                                            "fileVersion",
748                                        ),
749                                    );
750                                }
751                                m_fileVersion = _serde::__private::Some(
752                                    match __A::next_value::<i32>(&mut __map) {
753                                        _serde::__private::Ok(__val) => __val,
754                                        _serde::__private::Err(__err) => {
755                                            return _serde::__private::Err(__err);
756                                        }
757                                    },
758                                );
759                            }
760                            __Field::m_layoutRules => {
761                                #[cfg(
762                                    any(feature = "strict", feature = "ignore_duplicates")
763                                )]
764                                if _serde::__private::Option::is_some(&m_layoutRules) {
765                                    #[cfg(feature = "ignore_duplicates")]
766                                    {
767                                        __A::skip_value(&mut __map)?;
768                                        continue;
769                                    }
770                                    #[cfg(feature = "strict")]
771                                    return _serde::__private::Err(
772                                        <__A::Error as _serde::de::Error>::duplicate_field(
773                                            "layoutRules",
774                                        ),
775                                    );
776                                }
777                                m_layoutRules = _serde::__private::Some(
778                                    match __A::next_value::<[u8; 4usize]>(&mut __map) {
779                                        _serde::__private::Ok(__val) => __val,
780                                        _serde::__private::Err(__err) => {
781                                            return _serde::__private::Err(__err);
782                                        }
783                                    },
784                                );
785                            }
786                            __Field::m_numSections => {
787                                #[cfg(
788                                    any(feature = "strict", feature = "ignore_duplicates")
789                                )]
790                                if _serde::__private::Option::is_some(&m_numSections) {
791                                    #[cfg(feature = "ignore_duplicates")]
792                                    {
793                                        __A::skip_value(&mut __map)?;
794                                        continue;
795                                    }
796                                    #[cfg(feature = "strict")]
797                                    return _serde::__private::Err(
798                                        <__A::Error as _serde::de::Error>::duplicate_field(
799                                            "numSections",
800                                        ),
801                                    );
802                                }
803                                m_numSections = _serde::__private::Some(
804                                    match __A::next_value::<i32>(&mut __map) {
805                                        _serde::__private::Ok(__val) => __val,
806                                        _serde::__private::Err(__err) => {
807                                            return _serde::__private::Err(__err);
808                                        }
809                                    },
810                                );
811                            }
812                            __Field::m_contentsSectionIndex => {
813                                #[cfg(
814                                    any(feature = "strict", feature = "ignore_duplicates")
815                                )]
816                                if _serde::__private::Option::is_some(
817                                    &m_contentsSectionIndex,
818                                ) {
819                                    #[cfg(feature = "ignore_duplicates")]
820                                    {
821                                        __A::skip_value(&mut __map)?;
822                                        continue;
823                                    }
824                                    #[cfg(feature = "strict")]
825                                    return _serde::__private::Err(
826                                        <__A::Error as _serde::de::Error>::duplicate_field(
827                                            "contentsSectionIndex",
828                                        ),
829                                    );
830                                }
831                                m_contentsSectionIndex = _serde::__private::Some(
832                                    match __A::next_value::<i32>(&mut __map) {
833                                        _serde::__private::Ok(__val) => __val,
834                                        _serde::__private::Err(__err) => {
835                                            return _serde::__private::Err(__err);
836                                        }
837                                    },
838                                );
839                            }
840                            __Field::m_contentsSectionOffset => {
841                                #[cfg(
842                                    any(feature = "strict", feature = "ignore_duplicates")
843                                )]
844                                if _serde::__private::Option::is_some(
845                                    &m_contentsSectionOffset,
846                                ) {
847                                    #[cfg(feature = "ignore_duplicates")]
848                                    {
849                                        __A::skip_value(&mut __map)?;
850                                        continue;
851                                    }
852                                    #[cfg(feature = "strict")]
853                                    return _serde::__private::Err(
854                                        <__A::Error as _serde::de::Error>::duplicate_field(
855                                            "contentsSectionOffset",
856                                        ),
857                                    );
858                                }
859                                m_contentsSectionOffset = _serde::__private::Some(
860                                    match __A::next_value::<i32>(&mut __map) {
861                                        _serde::__private::Ok(__val) => __val,
862                                        _serde::__private::Err(__err) => {
863                                            return _serde::__private::Err(__err);
864                                        }
865                                    },
866                                );
867                            }
868                            __Field::m_contentsClassNameSectionIndex => {
869                                #[cfg(
870                                    any(feature = "strict", feature = "ignore_duplicates")
871                                )]
872                                if _serde::__private::Option::is_some(
873                                    &m_contentsClassNameSectionIndex,
874                                ) {
875                                    #[cfg(feature = "ignore_duplicates")]
876                                    {
877                                        __A::skip_value(&mut __map)?;
878                                        continue;
879                                    }
880                                    #[cfg(feature = "strict")]
881                                    return _serde::__private::Err(
882                                        <__A::Error as _serde::de::Error>::duplicate_field(
883                                            "contentsClassNameSectionIndex",
884                                        ),
885                                    );
886                                }
887                                m_contentsClassNameSectionIndex = _serde::__private::Some(
888                                    match __A::next_value::<i32>(&mut __map) {
889                                        _serde::__private::Ok(__val) => __val,
890                                        _serde::__private::Err(__err) => {
891                                            return _serde::__private::Err(__err);
892                                        }
893                                    },
894                                );
895                            }
896                            __Field::m_contentsClassNameSectionOffset => {
897                                #[cfg(
898                                    any(feature = "strict", feature = "ignore_duplicates")
899                                )]
900                                if _serde::__private::Option::is_some(
901                                    &m_contentsClassNameSectionOffset,
902                                ) {
903                                    #[cfg(feature = "ignore_duplicates")]
904                                    {
905                                        __A::skip_value(&mut __map)?;
906                                        continue;
907                                    }
908                                    #[cfg(feature = "strict")]
909                                    return _serde::__private::Err(
910                                        <__A::Error as _serde::de::Error>::duplicate_field(
911                                            "contentsClassNameSectionOffset",
912                                        ),
913                                    );
914                                }
915                                m_contentsClassNameSectionOffset = _serde::__private::Some(
916                                    match __A::next_value::<i32>(&mut __map) {
917                                        _serde::__private::Ok(__val) => __val,
918                                        _serde::__private::Err(__err) => {
919                                            return _serde::__private::Err(__err);
920                                        }
921                                    },
922                                );
923                            }
924                            __Field::m_contentsVersion => {
925                                #[cfg(
926                                    any(feature = "strict", feature = "ignore_duplicates")
927                                )]
928                                if _serde::__private::Option::is_some(&m_contentsVersion) {
929                                    #[cfg(feature = "ignore_duplicates")]
930                                    {
931                                        __A::skip_value(&mut __map)?;
932                                        continue;
933                                    }
934                                    #[cfg(feature = "strict")]
935                                    return _serde::__private::Err(
936                                        <__A::Error as _serde::de::Error>::duplicate_field(
937                                            "contentsVersion",
938                                        ),
939                                    );
940                                }
941                                m_contentsVersion = _serde::__private::Some(
942                                    match __A::next_value::<[char; 16usize]>(&mut __map) {
943                                        _serde::__private::Ok(__val) => __val,
944                                        _serde::__private::Err(__err) => {
945                                            return _serde::__private::Err(__err);
946                                        }
947                                    },
948                                );
949                            }
950                            __Field::m_flags => {
951                                #[cfg(
952                                    any(feature = "strict", feature = "ignore_duplicates")
953                                )]
954                                if _serde::__private::Option::is_some(&m_flags) {
955                                    #[cfg(feature = "ignore_duplicates")]
956                                    {
957                                        __A::skip_value(&mut __map)?;
958                                        continue;
959                                    }
960                                    #[cfg(feature = "strict")]
961                                    return _serde::__private::Err(
962                                        <__A::Error as _serde::de::Error>::duplicate_field("flags"),
963                                    );
964                                }
965                                m_flags = _serde::__private::Some(
966                                    match __A::next_value::<i32>(&mut __map) {
967                                        _serde::__private::Ok(__val) => __val,
968                                        _serde::__private::Err(__err) => {
969                                            return _serde::__private::Err(__err);
970                                        }
971                                    },
972                                );
973                            }
974                            __Field::m_pad => {
975                                #[cfg(
976                                    any(feature = "strict", feature = "ignore_duplicates")
977                                )]
978                                if _serde::__private::Option::is_some(&m_pad) {
979                                    #[cfg(feature = "ignore_duplicates")]
980                                    {
981                                        __A::skip_value(&mut __map)?;
982                                        continue;
983                                    }
984                                    #[cfg(feature = "strict")]
985                                    return _serde::__private::Err(
986                                        <__A::Error as _serde::de::Error>::duplicate_field("pad"),
987                                    );
988                                }
989                                m_pad = _serde::__private::Some(
990                                    match __A::next_value::<[i32; 1usize]>(&mut __map) {
991                                        _serde::__private::Ok(__val) => __val,
992                                        _serde::__private::Err(__err) => {
993                                            return _serde::__private::Err(__err);
994                                        }
995                                    },
996                                );
997                            }
998                            _ => __A::skip_value(&mut __map)?,
999                        }
1000                    }
1001                    let m_magic = match m_magic {
1002                        _serde::__private::Some(__field) => __field,
1003                        _serde::__private::None => {
1004                            #[cfg(feature = "strict")]
1005                            return _serde::__private::Err(
1006                                <__A::Error as _serde::de::Error>::missing_field("magic"),
1007                            );
1008                            #[cfg(not(feature = "strict"))] Default::default()
1009                        }
1010                    };
1011                    let m_userTag = match m_userTag {
1012                        _serde::__private::Some(__field) => __field,
1013                        _serde::__private::None => {
1014                            #[cfg(feature = "strict")]
1015                            return _serde::__private::Err(
1016                                <__A::Error as _serde::de::Error>::missing_field("userTag"),
1017                            );
1018                            #[cfg(not(feature = "strict"))] Default::default()
1019                        }
1020                    };
1021                    let m_fileVersion = match m_fileVersion {
1022                        _serde::__private::Some(__field) => __field,
1023                        _serde::__private::None => {
1024                            #[cfg(feature = "strict")]
1025                            return _serde::__private::Err(
1026                                <__A::Error as _serde::de::Error>::missing_field(
1027                                    "fileVersion",
1028                                ),
1029                            );
1030                            #[cfg(not(feature = "strict"))] Default::default()
1031                        }
1032                    };
1033                    let m_layoutRules = match m_layoutRules {
1034                        _serde::__private::Some(__field) => __field,
1035                        _serde::__private::None => {
1036                            #[cfg(feature = "strict")]
1037                            return _serde::__private::Err(
1038                                <__A::Error as _serde::de::Error>::missing_field(
1039                                    "layoutRules",
1040                                ),
1041                            );
1042                            #[cfg(not(feature = "strict"))] Default::default()
1043                        }
1044                    };
1045                    let m_numSections = match m_numSections {
1046                        _serde::__private::Some(__field) => __field,
1047                        _serde::__private::None => {
1048                            #[cfg(feature = "strict")]
1049                            return _serde::__private::Err(
1050                                <__A::Error as _serde::de::Error>::missing_field(
1051                                    "numSections",
1052                                ),
1053                            );
1054                            #[cfg(not(feature = "strict"))] Default::default()
1055                        }
1056                    };
1057                    let m_contentsSectionIndex = match m_contentsSectionIndex {
1058                        _serde::__private::Some(__field) => __field,
1059                        _serde::__private::None => {
1060                            #[cfg(feature = "strict")]
1061                            return _serde::__private::Err(
1062                                <__A::Error as _serde::de::Error>::missing_field(
1063                                    "contentsSectionIndex",
1064                                ),
1065                            );
1066                            #[cfg(not(feature = "strict"))] Default::default()
1067                        }
1068                    };
1069                    let m_contentsSectionOffset = match m_contentsSectionOffset {
1070                        _serde::__private::Some(__field) => __field,
1071                        _serde::__private::None => {
1072                            #[cfg(feature = "strict")]
1073                            return _serde::__private::Err(
1074                                <__A::Error as _serde::de::Error>::missing_field(
1075                                    "contentsSectionOffset",
1076                                ),
1077                            );
1078                            #[cfg(not(feature = "strict"))] Default::default()
1079                        }
1080                    };
1081                    let m_contentsClassNameSectionIndex = match m_contentsClassNameSectionIndex {
1082                        _serde::__private::Some(__field) => __field,
1083                        _serde::__private::None => {
1084                            #[cfg(feature = "strict")]
1085                            return _serde::__private::Err(
1086                                <__A::Error as _serde::de::Error>::missing_field(
1087                                    "contentsClassNameSectionIndex",
1088                                ),
1089                            );
1090                            #[cfg(not(feature = "strict"))] Default::default()
1091                        }
1092                    };
1093                    let m_contentsClassNameSectionOffset = match m_contentsClassNameSectionOffset {
1094                        _serde::__private::Some(__field) => __field,
1095                        _serde::__private::None => {
1096                            #[cfg(feature = "strict")]
1097                            return _serde::__private::Err(
1098                                <__A::Error as _serde::de::Error>::missing_field(
1099                                    "contentsClassNameSectionOffset",
1100                                ),
1101                            );
1102                            #[cfg(not(feature = "strict"))] Default::default()
1103                        }
1104                    };
1105                    let m_contentsVersion = match m_contentsVersion {
1106                        _serde::__private::Some(__field) => __field,
1107                        _serde::__private::None => {
1108                            #[cfg(feature = "strict")]
1109                            return _serde::__private::Err(
1110                                <__A::Error as _serde::de::Error>::missing_field(
1111                                    "contentsVersion",
1112                                ),
1113                            );
1114                            #[cfg(not(feature = "strict"))] Default::default()
1115                        }
1116                    };
1117                    let m_flags = match m_flags {
1118                        _serde::__private::Some(__field) => __field,
1119                        _serde::__private::None => {
1120                            #[cfg(feature = "strict")]
1121                            return _serde::__private::Err(
1122                                <__A::Error as _serde::de::Error>::missing_field("flags"),
1123                            );
1124                            #[cfg(not(feature = "strict"))] Default::default()
1125                        }
1126                    };
1127                    let m_pad = match m_pad {
1128                        _serde::__private::Some(__field) => __field,
1129                        _serde::__private::None => {
1130                            #[cfg(feature = "strict")]
1131                            return _serde::__private::Err(
1132                                <__A::Error as _serde::de::Error>::missing_field("pad"),
1133                            );
1134                            #[cfg(not(feature = "strict"))] Default::default()
1135                        }
1136                    };
1137                    let __ptr = __A::class_ptr(&mut __map);
1138                    _serde::__private::Ok(hkPackfileHeader {
1139                        __ptr,
1140                        m_magic,
1141                        m_userTag,
1142                        m_fileVersion,
1143                        m_layoutRules,
1144                        m_numSections,
1145                        m_contentsSectionIndex,
1146                        m_contentsSectionOffset,
1147                        m_contentsClassNameSectionIndex,
1148                        m_contentsClassNameSectionOffset,
1149                        m_contentsVersion,
1150                        m_flags,
1151                        m_pad,
1152                    })
1153                }
1154            }
1155            const FIELDS: &[&str] = &[
1156                "magic",
1157                "userTag",
1158                "fileVersion",
1159                "layoutRules",
1160                "numSections",
1161                "contentsSectionIndex",
1162                "contentsSectionOffset",
1163                "contentsClassNameSectionIndex",
1164                "contentsClassNameSectionOffset",
1165                "contentsVersion",
1166                "flags",
1167                "pad",
1168            ];
1169            _serde::Deserializer::deserialize_struct(
1170                deserializer,
1171                "hkPackfileHeader",
1172                FIELDS,
1173                __hkPackfileHeaderVisitor {
1174                    marker: _serde::__private::PhantomData::<hkPackfileHeader>,
1175                    lifetime: _serde::__private::PhantomData,
1176                },
1177            )
1178        }
1179    }
1180};