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 hkPackfileHeader {
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 = "magic"))]
31 #[cfg_attr(feature = "serde", serde(rename = "magic"))]
32 pub m_magic: [i32; 2usize],
33 #[cfg_attr(feature = "json_schema", schemars(rename = "userTag"))]
38 #[cfg_attr(feature = "serde", serde(rename = "userTag"))]
39 pub m_userTag: i32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "fileVersion"))]
45 #[cfg_attr(feature = "serde", serde(rename = "fileVersion"))]
46 pub m_fileVersion: i32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "layoutRules"))]
52 #[cfg_attr(feature = "serde", serde(rename = "layoutRules"))]
53 pub m_layoutRules: [u8; 4usize],
54 #[cfg_attr(feature = "json_schema", schemars(rename = "numSections"))]
59 #[cfg_attr(feature = "serde", serde(rename = "numSections"))]
60 pub m_numSections: i32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "contentsSectionIndex"))]
66 #[cfg_attr(feature = "serde", serde(rename = "contentsSectionIndex"))]
67 pub m_contentsSectionIndex: i32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "contentsSectionOffset"))]
73 #[cfg_attr(feature = "serde", serde(rename = "contentsSectionOffset"))]
74 pub m_contentsSectionOffset: i32,
75 #[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 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "contentsVersion"))]
100 #[cfg_attr(feature = "serde", serde(rename = "contentsVersion"))]
101 pub m_contentsVersion: [char; 16usize],
102 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
107 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
108 pub m_flags: i32,
109 #[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 #[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};