1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkPackfileSectionHeader {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(rename = "sectionTag"))]
31 #[cfg_attr(feature = "serde", serde(rename = "sectionTag"))]
32 pub m_sectionTag: [char; 19usize],
33 #[cfg_attr(feature = "json_schema", schemars(rename = "nullByte"))]
38 #[cfg_attr(feature = "serde", serde(rename = "nullByte"))]
39 pub m_nullByte: char,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteDataStart"))]
45 #[cfg_attr(feature = "serde", serde(rename = "absoluteDataStart"))]
46 pub m_absoluteDataStart: i32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "localFixupsOffset"))]
52 #[cfg_attr(feature = "serde", serde(rename = "localFixupsOffset"))]
53 pub m_localFixupsOffset: i32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "globalFixupsOffset"))]
59 #[cfg_attr(feature = "serde", serde(rename = "globalFixupsOffset"))]
60 pub m_globalFixupsOffset: i32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "virtualFixupsOffset"))]
66 #[cfg_attr(feature = "serde", serde(rename = "virtualFixupsOffset"))]
67 pub m_virtualFixupsOffset: i32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "exportsOffset"))]
73 #[cfg_attr(feature = "serde", serde(rename = "exportsOffset"))]
74 pub m_exportsOffset: i32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "importsOffset"))]
80 #[cfg_attr(feature = "serde", serde(rename = "importsOffset"))]
81 pub m_importsOffset: i32,
82 #[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 #[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};