havok_classes/generated/
hkPackfileSectionHeader_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkPackfileSectionHeader`
5/// - version: `0`
6/// - signature: `0xf2a92154`
7/// - size: ` 48`(x86)/` 48`(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 hkPackfileSectionHeader {
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: `sectionTag`(ctype: `hkChar[19]`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 19`(x86)/` 19`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "sectionTag"))]
31    #[cfg_attr(feature = "serde", serde(rename = "sectionTag"))]
32    pub m_sectionTag: [char; 19usize],
33    /// # C++ Info
34    /// - name: `nullByte`(ctype: `hkChar`)
35    /// - offset: ` 19`(x86)/` 19`(x86_64)
36    /// - type_size: `  1`(x86)/`  1`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "nullByte"))]
38    #[cfg_attr(feature = "serde", serde(rename = "nullByte"))]
39    pub m_nullByte: char,
40    /// # C++ Info
41    /// - name: `absoluteDataStart`(ctype: `hkInt32`)
42    /// - offset: ` 20`(x86)/` 20`(x86_64)
43    /// - type_size: `  4`(x86)/`  4`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteDataStart"))]
45    #[cfg_attr(feature = "serde", serde(rename = "absoluteDataStart"))]
46    pub m_absoluteDataStart: i32,
47    /// # C++ Info
48    /// - name: `localFixupsOffset`(ctype: `hkInt32`)
49    /// - offset: ` 24`(x86)/` 24`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "localFixupsOffset"))]
52    #[cfg_attr(feature = "serde", serde(rename = "localFixupsOffset"))]
53    pub m_localFixupsOffset: i32,
54    /// # C++ Info
55    /// - name: `globalFixupsOffset`(ctype: `hkInt32`)
56    /// - offset: ` 28`(x86)/` 28`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "globalFixupsOffset"))]
59    #[cfg_attr(feature = "serde", serde(rename = "globalFixupsOffset"))]
60    pub m_globalFixupsOffset: i32,
61    /// # C++ Info
62    /// - name: `virtualFixupsOffset`(ctype: `hkInt32`)
63    /// - offset: ` 32`(x86)/` 32`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "virtualFixupsOffset"))]
66    #[cfg_attr(feature = "serde", serde(rename = "virtualFixupsOffset"))]
67    pub m_virtualFixupsOffset: i32,
68    /// # C++ Info
69    /// - name: `exportsOffset`(ctype: `hkInt32`)
70    /// - offset: ` 36`(x86)/` 36`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "exportsOffset"))]
73    #[cfg_attr(feature = "serde", serde(rename = "exportsOffset"))]
74    pub m_exportsOffset: i32,
75    /// # C++ Info
76    /// - name: `importsOffset`(ctype: `hkInt32`)
77    /// - offset: ` 40`(x86)/` 40`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "importsOffset"))]
80    #[cfg_attr(feature = "serde", serde(rename = "importsOffset"))]
81    pub m_importsOffset: i32,
82    /// # C++ Info
83    /// - name: `endOffset`(ctype: `hkInt32`)
84    /// - offset: ` 44`(x86)/` 44`(x86_64)
85    /// - type_size: `  4`(x86)/`  4`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "endOffset"))]
87    #[cfg_attr(feature = "serde", serde(rename = "endOffset"))]
88    pub m_endOffset: i32,
89}
90const _: () = {
91    use havok_serde as _serde;
92    impl _serde::HavokClass for hkPackfileSectionHeader {
93        #[inline]
94        fn name(&self) -> &'static str {
95            "hkPackfileSectionHeader"
96        }
97        #[inline]
98        fn signature(&self) -> _serde::__private::Signature {
99            _serde::__private::Signature::new(0xf2a92154)
100        }
101        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
102        fn deps_indexes(&self) -> Vec<usize> {
103            let mut v = Vec::new();
104            v
105        }
106    }
107    impl _serde::Serialize for hkPackfileSectionHeader {
108        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
109        where
110            S: _serde::ser::Serializer,
111        {
112            let class_meta = self
113                .__ptr
114                .map(|name| (name, _serde::__private::Signature::new(0xf2a92154)));
115            let mut serializer = __serializer
116                .serialize_struct(
117                    "hkPackfileSectionHeader",
118                    class_meta,
119                    (48u64, 48u64),
120                )?;
121            serializer
122                .serialize_fixed_array_field(
123                    "sectionTag",
124                    self.m_sectionTag.as_slice(),
125                    TypeSize::NonPtr,
126                )?;
127            serializer.serialize_field("nullByte", &self.m_nullByte)?;
128            serializer.serialize_field("absoluteDataStart", &self.m_absoluteDataStart)?;
129            serializer.serialize_field("localFixupsOffset", &self.m_localFixupsOffset)?;
130            serializer
131                .serialize_field("globalFixupsOffset", &self.m_globalFixupsOffset)?;
132            serializer
133                .serialize_field("virtualFixupsOffset", &self.m_virtualFixupsOffset)?;
134            serializer.serialize_field("exportsOffset", &self.m_exportsOffset)?;
135            serializer.serialize_field("importsOffset", &self.m_importsOffset)?;
136            serializer.serialize_field("endOffset", &self.m_endOffset)?;
137            serializer.end()
138        }
139    }
140};
141#[doc(hidden)]
142#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
143const _: () = {
144    use havok_serde as _serde;
145    #[automatically_derived]
146    impl<'de> _serde::Deserialize<'de> for hkPackfileSectionHeader {
147        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
148        where
149            __D: _serde::Deserializer<'de>,
150        {
151            #[allow(non_camel_case_types)]
152            enum __Field {
153                m_sectionTag,
154                m_nullByte,
155                m_absoluteDataStart,
156                m_localFixupsOffset,
157                m_globalFixupsOffset,
158                m_virtualFixupsOffset,
159                m_exportsOffset,
160                m_importsOffset,
161                m_endOffset,
162                __ignore,
163            }
164            struct __FieldVisitor;
165            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
166                type Value = __Field;
167                fn expecting(
168                    &self,
169                    __formatter: &mut core::fmt::Formatter,
170                ) -> core::fmt::Result {
171                    core::fmt::Formatter::write_str(__formatter, "field identifier")
172                }
173                /// Intended for use in XML.
174                #[allow(clippy::match_single_binding)]
175                #[allow(clippy::reversed_empty_ranges)]
176                #[allow(clippy::single_match)]
177                fn visit_key<__E>(
178                    self,
179                    __value: &str,
180                ) -> core::result::Result<Self::Value, __E>
181                where
182                    __E: _serde::de::Error,
183                {
184                    match __value {
185                        "sectionTag" => Ok(__Field::m_sectionTag),
186                        "nullByte" => Ok(__Field::m_nullByte),
187                        "absoluteDataStart" => Ok(__Field::m_absoluteDataStart),
188                        "localFixupsOffset" => Ok(__Field::m_localFixupsOffset),
189                        "globalFixupsOffset" => Ok(__Field::m_globalFixupsOffset),
190                        "virtualFixupsOffset" => Ok(__Field::m_virtualFixupsOffset),
191                        "exportsOffset" => Ok(__Field::m_exportsOffset),
192                        "importsOffset" => Ok(__Field::m_importsOffset),
193                        "endOffset" => Ok(__Field::m_endOffset),
194                        _ => Ok(__Field::__ignore),
195                    }
196                }
197            }
198            impl<'de> _serde::Deserialize<'de> for __Field {
199                #[inline]
200                fn deserialize<__D>(
201                    __deserializer: __D,
202                ) -> core::result::Result<Self, __D::Error>
203                where
204                    __D: _serde::Deserializer<'de>,
205                {
206                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
207                }
208            }
209            struct __hkPackfileSectionHeaderVisitor<'de> {
210                marker: _serde::__private::PhantomData<hkPackfileSectionHeader>,
211                lifetime: _serde::__private::PhantomData<&'de ()>,
212            }
213            #[allow(clippy::match_single_binding)]
214            #[allow(clippy::reversed_empty_ranges)]
215            #[allow(clippy::single_match)]
216            impl<'de> _serde::de::Visitor<'de>
217            for __hkPackfileSectionHeaderVisitor<'de> {
218                type Value = hkPackfileSectionHeader;
219                fn expecting(
220                    &self,
221                    __formatter: &mut core::fmt::Formatter,
222                ) -> core::fmt::Result {
223                    core::fmt::Formatter::write_str(
224                        __formatter,
225                        "struct hkPackfileSectionHeader",
226                    )
227                }
228                fn visit_struct_for_bytes<__A>(
229                    self,
230                    mut __map: __A,
231                ) -> _serde::__private::Result<Self::Value, __A::Error>
232                where
233                    __A: _serde::de::MapAccess<'de>,
234                {
235                    let __ptr = __A::class_ptr(&mut __map);
236                    let mut m_sectionTag: _serde::__private::Option<[char; 19usize]> = _serde::__private::None;
237                    let mut m_nullByte: _serde::__private::Option<char> = _serde::__private::None;
238                    let mut m_absoluteDataStart: _serde::__private::Option<i32> = _serde::__private::None;
239                    let mut m_localFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
240                    let mut m_globalFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
241                    let mut m_virtualFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
242                    let mut m_exportsOffset: _serde::__private::Option<i32> = _serde::__private::None;
243                    let mut m_importsOffset: _serde::__private::Option<i32> = _serde::__private::None;
244                    let mut m_endOffset: _serde::__private::Option<i32> = _serde::__private::None;
245                    for i in 0..9usize {
246                        match i {
247                            0usize => {
248                                if _serde::__private::Option::is_some(&m_sectionTag) {
249                                    return _serde::__private::Err(
250                                        <__A::Error as _serde::de::Error>::duplicate_field(
251                                            "sectionTag",
252                                        ),
253                                    );
254                                }
255                                m_sectionTag = _serde::__private::Some(
256                                    match __A::next_value::<[char; 19usize]>(&mut __map) {
257                                        _serde::__private::Ok(__val) => __val,
258                                        _serde::__private::Err(__err) => {
259                                            return _serde::__private::Err(__err);
260                                        }
261                                    },
262                                );
263                            }
264                            1usize => {
265                                if _serde::__private::Option::is_some(&m_nullByte) {
266                                    return _serde::__private::Err(
267                                        <__A::Error as _serde::de::Error>::duplicate_field(
268                                            "nullByte",
269                                        ),
270                                    );
271                                }
272                                m_nullByte = _serde::__private::Some(
273                                    match __A::next_value::<char>(&mut __map) {
274                                        _serde::__private::Ok(__val) => __val,
275                                        _serde::__private::Err(__err) => {
276                                            return _serde::__private::Err(__err);
277                                        }
278                                    },
279                                );
280                            }
281                            2usize => {
282                                if _serde::__private::Option::is_some(
283                                    &m_absoluteDataStart,
284                                ) {
285                                    return _serde::__private::Err(
286                                        <__A::Error as _serde::de::Error>::duplicate_field(
287                                            "absoluteDataStart",
288                                        ),
289                                    );
290                                }
291                                m_absoluteDataStart = _serde::__private::Some(
292                                    match __A::next_value::<i32>(&mut __map) {
293                                        _serde::__private::Ok(__val) => __val,
294                                        _serde::__private::Err(__err) => {
295                                            return _serde::__private::Err(__err);
296                                        }
297                                    },
298                                );
299                            }
300                            3usize => {
301                                if _serde::__private::Option::is_some(
302                                    &m_localFixupsOffset,
303                                ) {
304                                    return _serde::__private::Err(
305                                        <__A::Error as _serde::de::Error>::duplicate_field(
306                                            "localFixupsOffset",
307                                        ),
308                                    );
309                                }
310                                m_localFixupsOffset = _serde::__private::Some(
311                                    match __A::next_value::<i32>(&mut __map) {
312                                        _serde::__private::Ok(__val) => __val,
313                                        _serde::__private::Err(__err) => {
314                                            return _serde::__private::Err(__err);
315                                        }
316                                    },
317                                );
318                            }
319                            4usize => {
320                                if _serde::__private::Option::is_some(
321                                    &m_globalFixupsOffset,
322                                ) {
323                                    return _serde::__private::Err(
324                                        <__A::Error as _serde::de::Error>::duplicate_field(
325                                            "globalFixupsOffset",
326                                        ),
327                                    );
328                                }
329                                m_globalFixupsOffset = _serde::__private::Some(
330                                    match __A::next_value::<i32>(&mut __map) {
331                                        _serde::__private::Ok(__val) => __val,
332                                        _serde::__private::Err(__err) => {
333                                            return _serde::__private::Err(__err);
334                                        }
335                                    },
336                                );
337                            }
338                            5usize => {
339                                if _serde::__private::Option::is_some(
340                                    &m_virtualFixupsOffset,
341                                ) {
342                                    return _serde::__private::Err(
343                                        <__A::Error as _serde::de::Error>::duplicate_field(
344                                            "virtualFixupsOffset",
345                                        ),
346                                    );
347                                }
348                                m_virtualFixupsOffset = _serde::__private::Some(
349                                    match __A::next_value::<i32>(&mut __map) {
350                                        _serde::__private::Ok(__val) => __val,
351                                        _serde::__private::Err(__err) => {
352                                            return _serde::__private::Err(__err);
353                                        }
354                                    },
355                                );
356                            }
357                            6usize => {
358                                if _serde::__private::Option::is_some(&m_exportsOffset) {
359                                    return _serde::__private::Err(
360                                        <__A::Error as _serde::de::Error>::duplicate_field(
361                                            "exportsOffset",
362                                        ),
363                                    );
364                                }
365                                m_exportsOffset = _serde::__private::Some(
366                                    match __A::next_value::<i32>(&mut __map) {
367                                        _serde::__private::Ok(__val) => __val,
368                                        _serde::__private::Err(__err) => {
369                                            return _serde::__private::Err(__err);
370                                        }
371                                    },
372                                );
373                            }
374                            7usize => {
375                                if _serde::__private::Option::is_some(&m_importsOffset) {
376                                    return _serde::__private::Err(
377                                        <__A::Error as _serde::de::Error>::duplicate_field(
378                                            "importsOffset",
379                                        ),
380                                    );
381                                }
382                                m_importsOffset = _serde::__private::Some(
383                                    match __A::next_value::<i32>(&mut __map) {
384                                        _serde::__private::Ok(__val) => __val,
385                                        _serde::__private::Err(__err) => {
386                                            return _serde::__private::Err(__err);
387                                        }
388                                    },
389                                );
390                            }
391                            8usize => {
392                                if _serde::__private::Option::is_some(&m_endOffset) {
393                                    return _serde::__private::Err(
394                                        <__A::Error as _serde::de::Error>::duplicate_field(
395                                            "endOffset",
396                                        ),
397                                    );
398                                }
399                                m_endOffset = _serde::__private::Some(
400                                    match __A::next_value::<i32>(&mut __map) {
401                                        _serde::__private::Ok(__val) => __val,
402                                        _serde::__private::Err(__err) => {
403                                            return _serde::__private::Err(__err);
404                                        }
405                                    },
406                                );
407                            }
408                            _ => {}
409                        }
410                    }
411                    let m_sectionTag = match m_sectionTag {
412                        _serde::__private::Some(__field) => __field,
413                        _serde::__private::None => {
414                            return _serde::__private::Err(
415                                <__A::Error as _serde::de::Error>::missing_field(
416                                    "sectionTag",
417                                ),
418                            );
419                        }
420                    };
421                    let m_nullByte = match m_nullByte {
422                        _serde::__private::Some(__field) => __field,
423                        _serde::__private::None => {
424                            return _serde::__private::Err(
425                                <__A::Error as _serde::de::Error>::missing_field("nullByte"),
426                            );
427                        }
428                    };
429                    let m_absoluteDataStart = match m_absoluteDataStart {
430                        _serde::__private::Some(__field) => __field,
431                        _serde::__private::None => {
432                            return _serde::__private::Err(
433                                <__A::Error as _serde::de::Error>::missing_field(
434                                    "absoluteDataStart",
435                                ),
436                            );
437                        }
438                    };
439                    let m_localFixupsOffset = match m_localFixupsOffset {
440                        _serde::__private::Some(__field) => __field,
441                        _serde::__private::None => {
442                            return _serde::__private::Err(
443                                <__A::Error as _serde::de::Error>::missing_field(
444                                    "localFixupsOffset",
445                                ),
446                            );
447                        }
448                    };
449                    let m_globalFixupsOffset = match m_globalFixupsOffset {
450                        _serde::__private::Some(__field) => __field,
451                        _serde::__private::None => {
452                            return _serde::__private::Err(
453                                <__A::Error as _serde::de::Error>::missing_field(
454                                    "globalFixupsOffset",
455                                ),
456                            );
457                        }
458                    };
459                    let m_virtualFixupsOffset = match m_virtualFixupsOffset {
460                        _serde::__private::Some(__field) => __field,
461                        _serde::__private::None => {
462                            return _serde::__private::Err(
463                                <__A::Error as _serde::de::Error>::missing_field(
464                                    "virtualFixupsOffset",
465                                ),
466                            );
467                        }
468                    };
469                    let m_exportsOffset = match m_exportsOffset {
470                        _serde::__private::Some(__field) => __field,
471                        _serde::__private::None => {
472                            return _serde::__private::Err(
473                                <__A::Error as _serde::de::Error>::missing_field(
474                                    "exportsOffset",
475                                ),
476                            );
477                        }
478                    };
479                    let m_importsOffset = match m_importsOffset {
480                        _serde::__private::Some(__field) => __field,
481                        _serde::__private::None => {
482                            return _serde::__private::Err(
483                                <__A::Error as _serde::de::Error>::missing_field(
484                                    "importsOffset",
485                                ),
486                            );
487                        }
488                    };
489                    let m_endOffset = match m_endOffset {
490                        _serde::__private::Some(__field) => __field,
491                        _serde::__private::None => {
492                            return _serde::__private::Err(
493                                <__A::Error as _serde::de::Error>::missing_field(
494                                    "endOffset",
495                                ),
496                            );
497                        }
498                    };
499                    _serde::__private::Ok(hkPackfileSectionHeader {
500                        __ptr,
501                        m_sectionTag,
502                        m_nullByte,
503                        m_absoluteDataStart,
504                        m_localFixupsOffset,
505                        m_globalFixupsOffset,
506                        m_virtualFixupsOffset,
507                        m_exportsOffset,
508                        m_importsOffset,
509                        m_endOffset,
510                    })
511                }
512                #[allow(clippy::manual_unwrap_or_default)]
513                fn visit_struct<__A>(
514                    self,
515                    mut __map: __A,
516                ) -> _serde::__private::Result<Self::Value, __A::Error>
517                where
518                    __A: _serde::de::MapAccess<'de>,
519                {
520                    let mut m_sectionTag: _serde::__private::Option<[char; 19usize]> = _serde::__private::None;
521                    let mut m_nullByte: _serde::__private::Option<char> = _serde::__private::None;
522                    let mut m_absoluteDataStart: _serde::__private::Option<i32> = _serde::__private::None;
523                    let mut m_localFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
524                    let mut m_globalFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
525                    let mut m_virtualFixupsOffset: _serde::__private::Option<i32> = _serde::__private::None;
526                    let mut m_exportsOffset: _serde::__private::Option<i32> = _serde::__private::None;
527                    let mut m_importsOffset: _serde::__private::Option<i32> = _serde::__private::None;
528                    let mut m_endOffset: _serde::__private::Option<i32> = _serde::__private::None;
529                    while let _serde::__private::Some(__key) = {
530                        __A::next_key::<__Field>(&mut __map)?
531                    } {
532                        match __key {
533                            __Field::m_sectionTag => {
534                                #[cfg(
535                                    any(feature = "strict", feature = "ignore_duplicates")
536                                )]
537                                if _serde::__private::Option::is_some(&m_sectionTag) {
538                                    #[cfg(feature = "ignore_duplicates")]
539                                    {
540                                        __A::skip_value(&mut __map)?;
541                                        continue;
542                                    }
543                                    #[cfg(feature = "strict")]
544                                    return _serde::__private::Err(
545                                        <__A::Error as _serde::de::Error>::duplicate_field(
546                                            "sectionTag",
547                                        ),
548                                    );
549                                }
550                                m_sectionTag = _serde::__private::Some(
551                                    match __A::next_value::<[char; 19usize]>(&mut __map) {
552                                        _serde::__private::Ok(__val) => __val,
553                                        _serde::__private::Err(__err) => {
554                                            return _serde::__private::Err(__err);
555                                        }
556                                    },
557                                );
558                            }
559                            __Field::m_nullByte => {
560                                #[cfg(
561                                    any(feature = "strict", feature = "ignore_duplicates")
562                                )]
563                                if _serde::__private::Option::is_some(&m_nullByte) {
564                                    #[cfg(feature = "ignore_duplicates")]
565                                    {
566                                        __A::skip_value(&mut __map)?;
567                                        continue;
568                                    }
569                                    #[cfg(feature = "strict")]
570                                    return _serde::__private::Err(
571                                        <__A::Error as _serde::de::Error>::duplicate_field(
572                                            "nullByte",
573                                        ),
574                                    );
575                                }
576                                m_nullByte = _serde::__private::Some(
577                                    match __A::next_value::<char>(&mut __map) {
578                                        _serde::__private::Ok(__val) => __val,
579                                        _serde::__private::Err(__err) => {
580                                            return _serde::__private::Err(__err);
581                                        }
582                                    },
583                                );
584                            }
585                            __Field::m_absoluteDataStart => {
586                                #[cfg(
587                                    any(feature = "strict", feature = "ignore_duplicates")
588                                )]
589                                if _serde::__private::Option::is_some(
590                                    &m_absoluteDataStart,
591                                ) {
592                                    #[cfg(feature = "ignore_duplicates")]
593                                    {
594                                        __A::skip_value(&mut __map)?;
595                                        continue;
596                                    }
597                                    #[cfg(feature = "strict")]
598                                    return _serde::__private::Err(
599                                        <__A::Error as _serde::de::Error>::duplicate_field(
600                                            "absoluteDataStart",
601                                        ),
602                                    );
603                                }
604                                m_absoluteDataStart = _serde::__private::Some(
605                                    match __A::next_value::<i32>(&mut __map) {
606                                        _serde::__private::Ok(__val) => __val,
607                                        _serde::__private::Err(__err) => {
608                                            return _serde::__private::Err(__err);
609                                        }
610                                    },
611                                );
612                            }
613                            __Field::m_localFixupsOffset => {
614                                #[cfg(
615                                    any(feature = "strict", feature = "ignore_duplicates")
616                                )]
617                                if _serde::__private::Option::is_some(
618                                    &m_localFixupsOffset,
619                                ) {
620                                    #[cfg(feature = "ignore_duplicates")]
621                                    {
622                                        __A::skip_value(&mut __map)?;
623                                        continue;
624                                    }
625                                    #[cfg(feature = "strict")]
626                                    return _serde::__private::Err(
627                                        <__A::Error as _serde::de::Error>::duplicate_field(
628                                            "localFixupsOffset",
629                                        ),
630                                    );
631                                }
632                                m_localFixupsOffset = _serde::__private::Some(
633                                    match __A::next_value::<i32>(&mut __map) {
634                                        _serde::__private::Ok(__val) => __val,
635                                        _serde::__private::Err(__err) => {
636                                            return _serde::__private::Err(__err);
637                                        }
638                                    },
639                                );
640                            }
641                            __Field::m_globalFixupsOffset => {
642                                #[cfg(
643                                    any(feature = "strict", feature = "ignore_duplicates")
644                                )]
645                                if _serde::__private::Option::is_some(
646                                    &m_globalFixupsOffset,
647                                ) {
648                                    #[cfg(feature = "ignore_duplicates")]
649                                    {
650                                        __A::skip_value(&mut __map)?;
651                                        continue;
652                                    }
653                                    #[cfg(feature = "strict")]
654                                    return _serde::__private::Err(
655                                        <__A::Error as _serde::de::Error>::duplicate_field(
656                                            "globalFixupsOffset",
657                                        ),
658                                    );
659                                }
660                                m_globalFixupsOffset = _serde::__private::Some(
661                                    match __A::next_value::<i32>(&mut __map) {
662                                        _serde::__private::Ok(__val) => __val,
663                                        _serde::__private::Err(__err) => {
664                                            return _serde::__private::Err(__err);
665                                        }
666                                    },
667                                );
668                            }
669                            __Field::m_virtualFixupsOffset => {
670                                #[cfg(
671                                    any(feature = "strict", feature = "ignore_duplicates")
672                                )]
673                                if _serde::__private::Option::is_some(
674                                    &m_virtualFixupsOffset,
675                                ) {
676                                    #[cfg(feature = "ignore_duplicates")]
677                                    {
678                                        __A::skip_value(&mut __map)?;
679                                        continue;
680                                    }
681                                    #[cfg(feature = "strict")]
682                                    return _serde::__private::Err(
683                                        <__A::Error as _serde::de::Error>::duplicate_field(
684                                            "virtualFixupsOffset",
685                                        ),
686                                    );
687                                }
688                                m_virtualFixupsOffset = _serde::__private::Some(
689                                    match __A::next_value::<i32>(&mut __map) {
690                                        _serde::__private::Ok(__val) => __val,
691                                        _serde::__private::Err(__err) => {
692                                            return _serde::__private::Err(__err);
693                                        }
694                                    },
695                                );
696                            }
697                            __Field::m_exportsOffset => {
698                                #[cfg(
699                                    any(feature = "strict", feature = "ignore_duplicates")
700                                )]
701                                if _serde::__private::Option::is_some(&m_exportsOffset) {
702                                    #[cfg(feature = "ignore_duplicates")]
703                                    {
704                                        __A::skip_value(&mut __map)?;
705                                        continue;
706                                    }
707                                    #[cfg(feature = "strict")]
708                                    return _serde::__private::Err(
709                                        <__A::Error as _serde::de::Error>::duplicate_field(
710                                            "exportsOffset",
711                                        ),
712                                    );
713                                }
714                                m_exportsOffset = _serde::__private::Some(
715                                    match __A::next_value::<i32>(&mut __map) {
716                                        _serde::__private::Ok(__val) => __val,
717                                        _serde::__private::Err(__err) => {
718                                            return _serde::__private::Err(__err);
719                                        }
720                                    },
721                                );
722                            }
723                            __Field::m_importsOffset => {
724                                #[cfg(
725                                    any(feature = "strict", feature = "ignore_duplicates")
726                                )]
727                                if _serde::__private::Option::is_some(&m_importsOffset) {
728                                    #[cfg(feature = "ignore_duplicates")]
729                                    {
730                                        __A::skip_value(&mut __map)?;
731                                        continue;
732                                    }
733                                    #[cfg(feature = "strict")]
734                                    return _serde::__private::Err(
735                                        <__A::Error as _serde::de::Error>::duplicate_field(
736                                            "importsOffset",
737                                        ),
738                                    );
739                                }
740                                m_importsOffset = _serde::__private::Some(
741                                    match __A::next_value::<i32>(&mut __map) {
742                                        _serde::__private::Ok(__val) => __val,
743                                        _serde::__private::Err(__err) => {
744                                            return _serde::__private::Err(__err);
745                                        }
746                                    },
747                                );
748                            }
749                            __Field::m_endOffset => {
750                                #[cfg(
751                                    any(feature = "strict", feature = "ignore_duplicates")
752                                )]
753                                if _serde::__private::Option::is_some(&m_endOffset) {
754                                    #[cfg(feature = "ignore_duplicates")]
755                                    {
756                                        __A::skip_value(&mut __map)?;
757                                        continue;
758                                    }
759                                    #[cfg(feature = "strict")]
760                                    return _serde::__private::Err(
761                                        <__A::Error as _serde::de::Error>::duplicate_field(
762                                            "endOffset",
763                                        ),
764                                    );
765                                }
766                                m_endOffset = _serde::__private::Some(
767                                    match __A::next_value::<i32>(&mut __map) {
768                                        _serde::__private::Ok(__val) => __val,
769                                        _serde::__private::Err(__err) => {
770                                            return _serde::__private::Err(__err);
771                                        }
772                                    },
773                                );
774                            }
775                            _ => __A::skip_value(&mut __map)?,
776                        }
777                    }
778                    let m_sectionTag = match m_sectionTag {
779                        _serde::__private::Some(__field) => __field,
780                        _serde::__private::None => {
781                            #[cfg(feature = "strict")]
782                            return _serde::__private::Err(
783                                <__A::Error as _serde::de::Error>::missing_field(
784                                    "sectionTag",
785                                ),
786                            );
787                            #[cfg(not(feature = "strict"))] Default::default()
788                        }
789                    };
790                    let m_nullByte = match m_nullByte {
791                        _serde::__private::Some(__field) => __field,
792                        _serde::__private::None => {
793                            #[cfg(feature = "strict")]
794                            return _serde::__private::Err(
795                                <__A::Error as _serde::de::Error>::missing_field("nullByte"),
796                            );
797                            #[cfg(not(feature = "strict"))] Default::default()
798                        }
799                    };
800                    let m_absoluteDataStart = match m_absoluteDataStart {
801                        _serde::__private::Some(__field) => __field,
802                        _serde::__private::None => {
803                            #[cfg(feature = "strict")]
804                            return _serde::__private::Err(
805                                <__A::Error as _serde::de::Error>::missing_field(
806                                    "absoluteDataStart",
807                                ),
808                            );
809                            #[cfg(not(feature = "strict"))] Default::default()
810                        }
811                    };
812                    let m_localFixupsOffset = match m_localFixupsOffset {
813                        _serde::__private::Some(__field) => __field,
814                        _serde::__private::None => {
815                            #[cfg(feature = "strict")]
816                            return _serde::__private::Err(
817                                <__A::Error as _serde::de::Error>::missing_field(
818                                    "localFixupsOffset",
819                                ),
820                            );
821                            #[cfg(not(feature = "strict"))] Default::default()
822                        }
823                    };
824                    let m_globalFixupsOffset = match m_globalFixupsOffset {
825                        _serde::__private::Some(__field) => __field,
826                        _serde::__private::None => {
827                            #[cfg(feature = "strict")]
828                            return _serde::__private::Err(
829                                <__A::Error as _serde::de::Error>::missing_field(
830                                    "globalFixupsOffset",
831                                ),
832                            );
833                            #[cfg(not(feature = "strict"))] Default::default()
834                        }
835                    };
836                    let m_virtualFixupsOffset = match m_virtualFixupsOffset {
837                        _serde::__private::Some(__field) => __field,
838                        _serde::__private::None => {
839                            #[cfg(feature = "strict")]
840                            return _serde::__private::Err(
841                                <__A::Error as _serde::de::Error>::missing_field(
842                                    "virtualFixupsOffset",
843                                ),
844                            );
845                            #[cfg(not(feature = "strict"))] Default::default()
846                        }
847                    };
848                    let m_exportsOffset = match m_exportsOffset {
849                        _serde::__private::Some(__field) => __field,
850                        _serde::__private::None => {
851                            #[cfg(feature = "strict")]
852                            return _serde::__private::Err(
853                                <__A::Error as _serde::de::Error>::missing_field(
854                                    "exportsOffset",
855                                ),
856                            );
857                            #[cfg(not(feature = "strict"))] Default::default()
858                        }
859                    };
860                    let m_importsOffset = match m_importsOffset {
861                        _serde::__private::Some(__field) => __field,
862                        _serde::__private::None => {
863                            #[cfg(feature = "strict")]
864                            return _serde::__private::Err(
865                                <__A::Error as _serde::de::Error>::missing_field(
866                                    "importsOffset",
867                                ),
868                            );
869                            #[cfg(not(feature = "strict"))] Default::default()
870                        }
871                    };
872                    let m_endOffset = match m_endOffset {
873                        _serde::__private::Some(__field) => __field,
874                        _serde::__private::None => {
875                            #[cfg(feature = "strict")]
876                            return _serde::__private::Err(
877                                <__A::Error as _serde::de::Error>::missing_field(
878                                    "endOffset",
879                                ),
880                            );
881                            #[cfg(not(feature = "strict"))] Default::default()
882                        }
883                    };
884                    let __ptr = __A::class_ptr(&mut __map);
885                    _serde::__private::Ok(hkPackfileSectionHeader {
886                        __ptr,
887                        m_sectionTag,
888                        m_nullByte,
889                        m_absoluteDataStart,
890                        m_localFixupsOffset,
891                        m_globalFixupsOffset,
892                        m_virtualFixupsOffset,
893                        m_exportsOffset,
894                        m_importsOffset,
895                        m_endOffset,
896                    })
897                }
898            }
899            const FIELDS: &[&str] = &[
900                "sectionTag",
901                "nullByte",
902                "absoluteDataStart",
903                "localFixupsOffset",
904                "globalFixupsOffset",
905                "virtualFixupsOffset",
906                "exportsOffset",
907                "importsOffset",
908                "endOffset",
909            ];
910            _serde::Deserializer::deserialize_struct(
911                deserializer,
912                "hkPackfileSectionHeader",
913                FIELDS,
914                __hkPackfileSectionHeaderVisitor {
915                    marker: _serde::__private::PhantomData::<hkPackfileSectionHeader>,
916                    lifetime: _serde::__private::PhantomData,
917                },
918            )
919        }
920    }
921};