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 hkClassMember<'a> {
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 = "serde", serde(borrow))]
31 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
32 #[cfg_attr(feature = "serde", serde(rename = "name"))]
33 pub m_name: CString<'a>,
34 #[cfg_attr(feature = "json_schema", schemars(rename = "class"))]
39 #[cfg_attr(feature = "serde", serde(rename = "class"))]
40 pub m_class: Pointer,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "enum"))]
46 #[cfg_attr(feature = "serde", serde(rename = "enum"))]
47 pub m_enum: Pointer,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
53 #[cfg_attr(feature = "serde", serde(rename = "type"))]
54 pub m_type: Type,
55 #[cfg_attr(feature = "json_schema", schemars(rename = "subtype"))]
60 #[cfg_attr(feature = "serde", serde(rename = "subtype"))]
61 pub m_subtype: Type,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "cArraySize"))]
67 #[cfg_attr(feature = "serde", serde(rename = "cArraySize"))]
68 pub m_cArraySize: i16,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
74 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
75 pub m_flags: FlagValues,
76 #[cfg_attr(feature = "json_schema", schemars(rename = "offset"))]
81 #[cfg_attr(feature = "serde", serde(rename = "offset"))]
82 pub m_offset: u16,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "attributes"))]
89 #[cfg_attr(feature = "serde", serde(rename = "attributes"))]
90 pub m_attributes: Pointer,
91}
92const _: () = {
93 use havok_serde as _serde;
94 impl<'a> _serde::HavokClass for hkClassMember<'a> {
95 #[inline]
96 fn name(&self) -> &'static str {
97 "hkClassMember"
98 }
99 #[inline]
100 fn signature(&self) -> _serde::__private::Signature {
101 _serde::__private::Signature::new(0x5c7ea4c2)
102 }
103 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
104 fn deps_indexes(&self) -> Vec<usize> {
105 let mut v = Vec::new();
106 v.push(self.m_class.get());
107 v.push(self.m_enum.get());
108 v.push(self.m_attributes.get());
109 v
110 }
111 }
112 impl<'a> _serde::Serialize for hkClassMember<'a> {
113 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
114 where
115 S: _serde::ser::Serializer,
116 {
117 let class_meta = self
118 .__ptr
119 .map(|name| (name, _serde::__private::Signature::new(0x5c7ea4c2)));
120 let mut serializer = __serializer
121 .serialize_struct("hkClassMember", class_meta, (24u64, 40u64))?;
122 serializer.serialize_field("name", &self.m_name)?;
123 serializer.serialize_field("class", &self.m_class)?;
124 serializer.serialize_field("enum", &self.m_enum)?;
125 serializer.serialize_field("type", &self.m_type)?;
126 serializer.serialize_field("subtype", &self.m_subtype)?;
127 serializer.serialize_field("cArraySize", &self.m_cArraySize)?;
128 serializer.serialize_field("flags", &self.m_flags)?;
129 serializer.serialize_field("offset", &self.m_offset)?;
130 serializer.skip_field("attributes", &self.m_attributes)?;
131 serializer.end()
132 }
133 }
134};
135#[doc(hidden)]
136#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
137const _: () = {
138 use havok_serde as _serde;
139 #[automatically_derived]
140 impl<'de> _serde::Deserialize<'de> for hkClassMember<'de> {
141 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
142 where
143 __D: _serde::Deserializer<'de>,
144 {
145 #[allow(non_camel_case_types)]
146 enum __Field {
147 m_name,
148 m_class,
149 m_enum,
150 m_type,
151 m_subtype,
152 m_cArraySize,
153 m_flags,
154 m_offset,
155 __ignore,
156 }
157 struct __FieldVisitor;
158 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
159 type Value = __Field;
160 fn expecting(
161 &self,
162 __formatter: &mut core::fmt::Formatter,
163 ) -> core::fmt::Result {
164 core::fmt::Formatter::write_str(__formatter, "field identifier")
165 }
166 #[allow(clippy::match_single_binding)]
168 #[allow(clippy::reversed_empty_ranges)]
169 #[allow(clippy::single_match)]
170 fn visit_key<__E>(
171 self,
172 __value: &str,
173 ) -> core::result::Result<Self::Value, __E>
174 where
175 __E: _serde::de::Error,
176 {
177 match __value {
178 "name" => Ok(__Field::m_name),
179 "class" => Ok(__Field::m_class),
180 "enum" => Ok(__Field::m_enum),
181 "type" => Ok(__Field::m_type),
182 "subtype" => Ok(__Field::m_subtype),
183 "cArraySize" => Ok(__Field::m_cArraySize),
184 "flags" => Ok(__Field::m_flags),
185 "offset" => Ok(__Field::m_offset),
186 _ => Ok(__Field::__ignore),
187 }
188 }
189 }
190 impl<'de> _serde::Deserialize<'de> for __Field {
191 #[inline]
192 fn deserialize<__D>(
193 __deserializer: __D,
194 ) -> core::result::Result<Self, __D::Error>
195 where
196 __D: _serde::Deserializer<'de>,
197 {
198 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
199 }
200 }
201 struct __hkClassMemberVisitor<'de> {
202 marker: _serde::__private::PhantomData<hkClassMember<'de>>,
203 lifetime: _serde::__private::PhantomData<&'de ()>,
204 }
205 #[allow(clippy::match_single_binding)]
206 #[allow(clippy::reversed_empty_ranges)]
207 #[allow(clippy::single_match)]
208 impl<'de> _serde::de::Visitor<'de> for __hkClassMemberVisitor<'de> {
209 type Value = hkClassMember<'de>;
210 fn expecting(
211 &self,
212 __formatter: &mut core::fmt::Formatter,
213 ) -> core::fmt::Result {
214 core::fmt::Formatter::write_str(__formatter, "struct hkClassMember")
215 }
216 fn visit_struct_for_bytes<__A>(
217 self,
218 mut __map: __A,
219 ) -> _serde::__private::Result<Self::Value, __A::Error>
220 where
221 __A: _serde::de::MapAccess<'de>,
222 {
223 let __ptr = __A::class_ptr(&mut __map);
224 let mut m_name: _serde::__private::Option<CString<'de>> = _serde::__private::None;
225 let mut m_class: _serde::__private::Option<Pointer> = _serde::__private::None;
226 let mut m_enum: _serde::__private::Option<Pointer> = _serde::__private::None;
227 let mut m_type: _serde::__private::Option<Type> = _serde::__private::None;
228 let mut m_subtype: _serde::__private::Option<Type> = _serde::__private::None;
229 let mut m_cArraySize: _serde::__private::Option<i16> = _serde::__private::None;
230 let mut m_flags: _serde::__private::Option<FlagValues> = _serde::__private::None;
231 let mut m_offset: _serde::__private::Option<u16> = _serde::__private::None;
232 let mut m_attributes: _serde::__private::Option<Pointer> = _serde::__private::None;
233 for i in 0..9usize {
234 match i {
235 0usize => {
236 if _serde::__private::Option::is_some(&m_name) {
237 return _serde::__private::Err(
238 <__A::Error as _serde::de::Error>::duplicate_field("name"),
239 );
240 }
241 m_name = _serde::__private::Some(
242 match __A::next_value::<CString<'de>>(&mut __map) {
243 _serde::__private::Ok(__val) => __val,
244 _serde::__private::Err(__err) => {
245 return _serde::__private::Err(__err);
246 }
247 },
248 );
249 }
250 1usize => {
251 if _serde::__private::Option::is_some(&m_class) {
252 return _serde::__private::Err(
253 <__A::Error as _serde::de::Error>::duplicate_field("class"),
254 );
255 }
256 m_class = _serde::__private::Some(
257 match __A::next_value::<Pointer>(&mut __map) {
258 _serde::__private::Ok(__val) => __val,
259 _serde::__private::Err(__err) => {
260 return _serde::__private::Err(__err);
261 }
262 },
263 );
264 }
265 2usize => {
266 if _serde::__private::Option::is_some(&m_enum) {
267 return _serde::__private::Err(
268 <__A::Error as _serde::de::Error>::duplicate_field("enum"),
269 );
270 }
271 m_enum = _serde::__private::Some(
272 match __A::next_value::<Pointer>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 3usize => {
281 if _serde::__private::Option::is_some(&m_type) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field("type"),
284 );
285 }
286 m_type = _serde::__private::Some(
287 match __A::next_value::<Type>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 4usize => {
296 if _serde::__private::Option::is_some(&m_subtype) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "subtype",
300 ),
301 );
302 }
303 m_subtype = _serde::__private::Some(
304 match __A::next_value::<Type>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 5usize => {
313 if _serde::__private::Option::is_some(&m_cArraySize) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "cArraySize",
317 ),
318 );
319 }
320 m_cArraySize = _serde::__private::Some(
321 match __A::next_value::<i16>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 6usize => {
330 if _serde::__private::Option::is_some(&m_flags) {
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
333 );
334 }
335 m_flags = _serde::__private::Some(
336 match __A::next_value::<FlagValues>(&mut __map) {
337 _serde::__private::Ok(__val) => __val,
338 _serde::__private::Err(__err) => {
339 return _serde::__private::Err(__err);
340 }
341 },
342 );
343 }
344 7usize => {
345 if _serde::__private::Option::is_some(&m_offset) {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::duplicate_field("offset"),
348 );
349 }
350 m_offset = _serde::__private::Some(
351 match __A::next_value::<u16>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 8usize => {
360 if _serde::__private::Option::is_some(&m_attributes) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "attributes",
364 ),
365 );
366 }
367 m_attributes = _serde::__private::Some(
368 match __A::next_value::<Pointer>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 _ => {}
377 }
378 }
379 let m_name = match m_name {
380 _serde::__private::Some(__field) => __field,
381 _serde::__private::None => {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::missing_field("name"),
384 );
385 }
386 };
387 let m_class = match m_class {
388 _serde::__private::Some(__field) => __field,
389 _serde::__private::None => {
390 return _serde::__private::Err(
391 <__A::Error as _serde::de::Error>::missing_field("class"),
392 );
393 }
394 };
395 let m_enum = match m_enum {
396 _serde::__private::Some(__field) => __field,
397 _serde::__private::None => {
398 return _serde::__private::Err(
399 <__A::Error as _serde::de::Error>::missing_field("enum"),
400 );
401 }
402 };
403 let m_type = match m_type {
404 _serde::__private::Some(__field) => __field,
405 _serde::__private::None => {
406 return _serde::__private::Err(
407 <__A::Error as _serde::de::Error>::missing_field("type"),
408 );
409 }
410 };
411 let m_subtype = match m_subtype {
412 _serde::__private::Some(__field) => __field,
413 _serde::__private::None => {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field("subtype"),
416 );
417 }
418 };
419 let m_cArraySize = match m_cArraySize {
420 _serde::__private::Some(__field) => __field,
421 _serde::__private::None => {
422 return _serde::__private::Err(
423 <__A::Error as _serde::de::Error>::missing_field(
424 "cArraySize",
425 ),
426 );
427 }
428 };
429 let m_flags = match m_flags {
430 _serde::__private::Some(__field) => __field,
431 _serde::__private::None => {
432 return _serde::__private::Err(
433 <__A::Error as _serde::de::Error>::missing_field("flags"),
434 );
435 }
436 };
437 let m_offset = match m_offset {
438 _serde::__private::Some(__field) => __field,
439 _serde::__private::None => {
440 return _serde::__private::Err(
441 <__A::Error as _serde::de::Error>::missing_field("offset"),
442 );
443 }
444 };
445 let m_attributes = match m_attributes {
446 _serde::__private::Some(__field) => __field,
447 _serde::__private::None => {
448 return _serde::__private::Err(
449 <__A::Error as _serde::de::Error>::missing_field(
450 "attributes",
451 ),
452 );
453 }
454 };
455 _serde::__private::Ok(hkClassMember {
456 __ptr,
457 m_name,
458 m_class,
459 m_enum,
460 m_type,
461 m_subtype,
462 m_cArraySize,
463 m_flags,
464 m_offset,
465 m_attributes,
466 })
467 }
468 #[allow(clippy::manual_unwrap_or_default)]
469 fn visit_struct<__A>(
470 self,
471 mut __map: __A,
472 ) -> _serde::__private::Result<Self::Value, __A::Error>
473 where
474 __A: _serde::de::MapAccess<'de>,
475 {
476 let mut m_name: _serde::__private::Option<CString<'de>> = _serde::__private::None;
477 let mut m_class: _serde::__private::Option<Pointer> = _serde::__private::None;
478 let mut m_enum: _serde::__private::Option<Pointer> = _serde::__private::None;
479 let mut m_type: _serde::__private::Option<Type> = _serde::__private::None;
480 let mut m_subtype: _serde::__private::Option<Type> = _serde::__private::None;
481 let mut m_cArraySize: _serde::__private::Option<i16> = _serde::__private::None;
482 let mut m_flags: _serde::__private::Option<FlagValues> = _serde::__private::None;
483 let mut m_offset: _serde::__private::Option<u16> = _serde::__private::None;
484 while let _serde::__private::Some(__key) = {
485 __A::next_key::<__Field>(&mut __map)?
486 } {
487 match __key {
488 __Field::m_name => {
489 #[cfg(
490 any(feature = "strict", feature = "ignore_duplicates")
491 )]
492 if _serde::__private::Option::is_some(&m_name) {
493 #[cfg(feature = "ignore_duplicates")]
494 {
495 __A::skip_value(&mut __map)?;
496 continue;
497 }
498 #[cfg(feature = "strict")]
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::duplicate_field("name"),
501 );
502 }
503 m_name = _serde::__private::Some(
504 match __A::next_value::<CString<'de>>(&mut __map) {
505 _serde::__private::Ok(__val) => __val,
506 _serde::__private::Err(__err) => {
507 return _serde::__private::Err(__err);
508 }
509 },
510 );
511 }
512 __Field::m_class => {
513 #[cfg(
514 any(feature = "strict", feature = "ignore_duplicates")
515 )]
516 if _serde::__private::Option::is_some(&m_class) {
517 #[cfg(feature = "ignore_duplicates")]
518 {
519 __A::skip_value(&mut __map)?;
520 continue;
521 }
522 #[cfg(feature = "strict")]
523 return _serde::__private::Err(
524 <__A::Error as _serde::de::Error>::duplicate_field("class"),
525 );
526 }
527 m_class = _serde::__private::Some(
528 match __A::next_value::<Pointer>(&mut __map) {
529 _serde::__private::Ok(__val) => __val,
530 _serde::__private::Err(__err) => {
531 return _serde::__private::Err(__err);
532 }
533 },
534 );
535 }
536 __Field::m_enum => {
537 #[cfg(
538 any(feature = "strict", feature = "ignore_duplicates")
539 )]
540 if _serde::__private::Option::is_some(&m_enum) {
541 #[cfg(feature = "ignore_duplicates")]
542 {
543 __A::skip_value(&mut __map)?;
544 continue;
545 }
546 #[cfg(feature = "strict")]
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::duplicate_field("enum"),
549 );
550 }
551 m_enum = _serde::__private::Some(
552 match __A::next_value::<Pointer>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 __Field::m_type => {
561 #[cfg(
562 any(feature = "strict", feature = "ignore_duplicates")
563 )]
564 if _serde::__private::Option::is_some(&m_type) {
565 #[cfg(feature = "ignore_duplicates")]
566 {
567 __A::skip_value(&mut __map)?;
568 continue;
569 }
570 #[cfg(feature = "strict")]
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::duplicate_field("type"),
573 );
574 }
575 m_type = _serde::__private::Some(
576 match __A::next_value::<Type>(&mut __map) {
577 _serde::__private::Ok(__val) => __val,
578 _serde::__private::Err(__err) => {
579 return _serde::__private::Err(__err);
580 }
581 },
582 );
583 }
584 __Field::m_subtype => {
585 #[cfg(
586 any(feature = "strict", feature = "ignore_duplicates")
587 )]
588 if _serde::__private::Option::is_some(&m_subtype) {
589 #[cfg(feature = "ignore_duplicates")]
590 {
591 __A::skip_value(&mut __map)?;
592 continue;
593 }
594 #[cfg(feature = "strict")]
595 return _serde::__private::Err(
596 <__A::Error as _serde::de::Error>::duplicate_field(
597 "subtype",
598 ),
599 );
600 }
601 m_subtype = _serde::__private::Some(
602 match __A::next_value::<Type>(&mut __map) {
603 _serde::__private::Ok(__val) => __val,
604 _serde::__private::Err(__err) => {
605 return _serde::__private::Err(__err);
606 }
607 },
608 );
609 }
610 __Field::m_cArraySize => {
611 #[cfg(
612 any(feature = "strict", feature = "ignore_duplicates")
613 )]
614 if _serde::__private::Option::is_some(&m_cArraySize) {
615 #[cfg(feature = "ignore_duplicates")]
616 {
617 __A::skip_value(&mut __map)?;
618 continue;
619 }
620 #[cfg(feature = "strict")]
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::duplicate_field(
623 "cArraySize",
624 ),
625 );
626 }
627 m_cArraySize = _serde::__private::Some(
628 match __A::next_value::<i16>(&mut __map) {
629 _serde::__private::Ok(__val) => __val,
630 _serde::__private::Err(__err) => {
631 return _serde::__private::Err(__err);
632 }
633 },
634 );
635 }
636 __Field::m_flags => {
637 #[cfg(
638 any(feature = "strict", feature = "ignore_duplicates")
639 )]
640 if _serde::__private::Option::is_some(&m_flags) {
641 #[cfg(feature = "ignore_duplicates")]
642 {
643 __A::skip_value(&mut __map)?;
644 continue;
645 }
646 #[cfg(feature = "strict")]
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
649 );
650 }
651 m_flags = _serde::__private::Some(
652 match __A::next_value::<FlagValues>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 __Field::m_offset => {
661 #[cfg(
662 any(feature = "strict", feature = "ignore_duplicates")
663 )]
664 if _serde::__private::Option::is_some(&m_offset) {
665 #[cfg(feature = "ignore_duplicates")]
666 {
667 __A::skip_value(&mut __map)?;
668 continue;
669 }
670 #[cfg(feature = "strict")]
671 return _serde::__private::Err(
672 <__A::Error as _serde::de::Error>::duplicate_field("offset"),
673 );
674 }
675 m_offset = _serde::__private::Some(
676 match __A::next_value::<u16>(&mut __map) {
677 _serde::__private::Ok(__val) => __val,
678 _serde::__private::Err(__err) => {
679 return _serde::__private::Err(__err);
680 }
681 },
682 );
683 }
684 _ => __A::skip_value(&mut __map)?,
685 }
686 }
687 let m_name = match m_name {
688 _serde::__private::Some(__field) => __field,
689 _serde::__private::None => {
690 #[cfg(feature = "strict")]
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::missing_field("name"),
693 );
694 #[cfg(not(feature = "strict"))] Default::default()
695 }
696 };
697 let m_class = match m_class {
698 _serde::__private::Some(__field) => __field,
699 _serde::__private::None => {
700 #[cfg(feature = "strict")]
701 return _serde::__private::Err(
702 <__A::Error as _serde::de::Error>::missing_field("class"),
703 );
704 #[cfg(not(feature = "strict"))] Default::default()
705 }
706 };
707 let m_enum = match m_enum {
708 _serde::__private::Some(__field) => __field,
709 _serde::__private::None => {
710 #[cfg(feature = "strict")]
711 return _serde::__private::Err(
712 <__A::Error as _serde::de::Error>::missing_field("enum"),
713 );
714 #[cfg(not(feature = "strict"))] Default::default()
715 }
716 };
717 let m_type = match m_type {
718 _serde::__private::Some(__field) => __field,
719 _serde::__private::None => {
720 #[cfg(feature = "strict")]
721 return _serde::__private::Err(
722 <__A::Error as _serde::de::Error>::missing_field("type"),
723 );
724 #[cfg(not(feature = "strict"))] Default::default()
725 }
726 };
727 let m_subtype = match m_subtype {
728 _serde::__private::Some(__field) => __field,
729 _serde::__private::None => {
730 #[cfg(feature = "strict")]
731 return _serde::__private::Err(
732 <__A::Error as _serde::de::Error>::missing_field("subtype"),
733 );
734 #[cfg(not(feature = "strict"))] Default::default()
735 }
736 };
737 let m_cArraySize = match m_cArraySize {
738 _serde::__private::Some(__field) => __field,
739 _serde::__private::None => {
740 #[cfg(feature = "strict")]
741 return _serde::__private::Err(
742 <__A::Error as _serde::de::Error>::missing_field(
743 "cArraySize",
744 ),
745 );
746 #[cfg(not(feature = "strict"))] Default::default()
747 }
748 };
749 let m_flags = match m_flags {
750 _serde::__private::Some(__field) => __field,
751 _serde::__private::None => {
752 #[cfg(feature = "strict")]
753 return _serde::__private::Err(
754 <__A::Error as _serde::de::Error>::missing_field("flags"),
755 );
756 #[cfg(not(feature = "strict"))] Default::default()
757 }
758 };
759 let m_offset = match m_offset {
760 _serde::__private::Some(__field) => __field,
761 _serde::__private::None => {
762 #[cfg(feature = "strict")]
763 return _serde::__private::Err(
764 <__A::Error as _serde::de::Error>::missing_field("offset"),
765 );
766 #[cfg(not(feature = "strict"))] Default::default()
767 }
768 };
769 let __ptr = __A::class_ptr(&mut __map);
770 _serde::__private::Ok(hkClassMember {
771 __ptr,
772 m_name,
773 m_class,
774 m_enum,
775 m_type,
776 m_subtype,
777 m_cArraySize,
778 m_flags,
779 m_offset,
780 ..Default::default()
781 })
782 }
783 }
784 const FIELDS: &[&str] = &[
785 "name",
786 "class",
787 "enum",
788 "type",
789 "subtype",
790 "cArraySize",
791 "flags",
792 "offset",
793 "attributes",
794 ];
795 _serde::Deserializer::deserialize_struct(
796 deserializer,
797 "hkClassMember",
798 FIELDS,
799 __hkClassMemberVisitor {
800 marker: _serde::__private::PhantomData::<hkClassMember>,
801 lifetime: _serde::__private::PhantomData,
802 },
803 )
804 }
805 }
806};
807#[allow(non_upper_case_globals, non_snake_case)]
810#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
811#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
812#[derive(
813 Debug,
814 Clone,
815 Default,
816 PartialEq,
817 Eq,
818 PartialOrd,
819 Ord,
820 num_derive::ToPrimitive,
821 num_derive::FromPrimitive,
822)]
823pub enum Type {
824 #[default]
825 TYPE_VOID = 0isize,
826 TYPE_BOOL = 1isize,
827 TYPE_CHAR = 2isize,
828 TYPE_INT8 = 3isize,
829 TYPE_UINT8 = 4isize,
830 TYPE_INT16 = 5isize,
831 TYPE_UINT16 = 6isize,
832 TYPE_INT32 = 7isize,
833 TYPE_UINT32 = 8isize,
834 TYPE_INT64 = 9isize,
835 TYPE_UINT64 = 10isize,
836 TYPE_REAL = 11isize,
837 TYPE_VECTOR4 = 12isize,
838 TYPE_QUATERNION = 13isize,
839 TYPE_MATRIX3 = 14isize,
840 TYPE_ROTATION = 15isize,
841 TYPE_QSTRANSFORM = 16isize,
842 TYPE_MATRIX4 = 17isize,
843 TYPE_TRANSFORM = 18isize,
844 TYPE_ZERO = 19isize,
845 TYPE_POINTER = 20isize,
846 TYPE_FUNCTIONPOINTER = 21isize,
847 TYPE_ARRAY = 22isize,
848 TYPE_INPLACEARRAY = 23isize,
849 TYPE_ENUM = 24isize,
850 TYPE_STRUCT = 25isize,
851 TYPE_SIMPLEARRAY = 26isize,
852 TYPE_HOMOGENEOUSARRAY = 27isize,
853 TYPE_VARIANT = 28isize,
854 TYPE_CSTRING = 29isize,
855 TYPE_ULONG = 30isize,
856 TYPE_FLAGS = 31isize,
857 TYPE_HALF = 32isize,
858 TYPE_STRINGPTR = 33isize,
859 TYPE_RELARRAY = 34isize,
860 TYPE_MAX = 35isize,
861}
862#[havok_types_derive::impl_flags_methods]
863bitflags::bitflags! {
864 #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
865 " - name: `FlagValues`(ctype: `hkFlags<FlagValues, hkUint32>`)"]
866 #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
867 derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
868 #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
869 FlagValues : u32 { #[doc = "0"] const FLAGS_NONE = 0u32; #[doc = "128"] const ALIGN_8
870 = 128u32; #[doc = "256"] const ALIGN_16 = 256u32; #[doc = "512"] const NOT_OWNED =
871 512u32; #[doc = "1024"] const SERIALIZE_IGNORED = 1024u32; }
872}
873#[cfg(feature = "json_schema")]
874const _: () = {
875 use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
876 use std::borrow::Cow;
877 impl JsonSchema for FlagValues {
878 fn schema_name() -> Cow<'static, str> {
879 "FlagValues".into()
880 }
881 fn schema_id() -> Cow<'static, str> {
882 concat!(module_path!(), "::", "FlagValues").into()
883 }
884 fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
885 json_schema!(
886 { "description" :
887 "Bitflags field. Specific flags: FLAGS_NONE: 0, ALIGN_8: 128, ALIGN_16: 256, NOT_OWNED: 512, SERIALIZE_IGNORED: 1024. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
888 "type" : "string", }
889 )
890 }
891 }
892};
893const _: () = {
894 use havok_serde as __serde;
895 impl __serde::Serialize for Type {
896 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
897 where
898 S: __serde::ser::Serializer,
899 {
900 let mut __serializer = __serializer.serialize_enum_flags()?;
901 match self {
902 Self::TYPE_VOID => __serializer.serialize_field("TYPE_VOID", &0u64),
903 Self::TYPE_BOOL => __serializer.serialize_field("TYPE_BOOL", &1u64),
904 Self::TYPE_CHAR => __serializer.serialize_field("TYPE_CHAR", &2u64),
905 Self::TYPE_INT8 => __serializer.serialize_field("TYPE_INT8", &3u64),
906 Self::TYPE_UINT8 => __serializer.serialize_field("TYPE_UINT8", &4u64),
907 Self::TYPE_INT16 => __serializer.serialize_field("TYPE_INT16", &5u64),
908 Self::TYPE_UINT16 => __serializer.serialize_field("TYPE_UINT16", &6u64),
909 Self::TYPE_INT32 => __serializer.serialize_field("TYPE_INT32", &7u64),
910 Self::TYPE_UINT32 => __serializer.serialize_field("TYPE_UINT32", &8u64),
911 Self::TYPE_INT64 => __serializer.serialize_field("TYPE_INT64", &9u64),
912 Self::TYPE_UINT64 => __serializer.serialize_field("TYPE_UINT64", &10u64),
913 Self::TYPE_REAL => __serializer.serialize_field("TYPE_REAL", &11u64),
914 Self::TYPE_VECTOR4 => {
915 __serializer.serialize_field("TYPE_VECTOR4", &12u64)
916 }
917 Self::TYPE_QUATERNION => {
918 __serializer.serialize_field("TYPE_QUATERNION", &13u64)
919 }
920 Self::TYPE_MATRIX3 => {
921 __serializer.serialize_field("TYPE_MATRIX3", &14u64)
922 }
923 Self::TYPE_ROTATION => {
924 __serializer.serialize_field("TYPE_ROTATION", &15u64)
925 }
926 Self::TYPE_QSTRANSFORM => {
927 __serializer.serialize_field("TYPE_QSTRANSFORM", &16u64)
928 }
929 Self::TYPE_MATRIX4 => {
930 __serializer.serialize_field("TYPE_MATRIX4", &17u64)
931 }
932 Self::TYPE_TRANSFORM => {
933 __serializer.serialize_field("TYPE_TRANSFORM", &18u64)
934 }
935 Self::TYPE_ZERO => __serializer.serialize_field("TYPE_ZERO", &19u64),
936 Self::TYPE_POINTER => {
937 __serializer.serialize_field("TYPE_POINTER", &20u64)
938 }
939 Self::TYPE_FUNCTIONPOINTER => {
940 __serializer.serialize_field("TYPE_FUNCTIONPOINTER", &21u64)
941 }
942 Self::TYPE_ARRAY => __serializer.serialize_field("TYPE_ARRAY", &22u64),
943 Self::TYPE_INPLACEARRAY => {
944 __serializer.serialize_field("TYPE_INPLACEARRAY", &23u64)
945 }
946 Self::TYPE_ENUM => __serializer.serialize_field("TYPE_ENUM", &24u64),
947 Self::TYPE_STRUCT => __serializer.serialize_field("TYPE_STRUCT", &25u64),
948 Self::TYPE_SIMPLEARRAY => {
949 __serializer.serialize_field("TYPE_SIMPLEARRAY", &26u64)
950 }
951 Self::TYPE_HOMOGENEOUSARRAY => {
952 __serializer.serialize_field("TYPE_HOMOGENEOUSARRAY", &27u64)
953 }
954 Self::TYPE_VARIANT => {
955 __serializer.serialize_field("TYPE_VARIANT", &28u64)
956 }
957 Self::TYPE_CSTRING => {
958 __serializer.serialize_field("TYPE_CSTRING", &29u64)
959 }
960 Self::TYPE_ULONG => __serializer.serialize_field("TYPE_ULONG", &30u64),
961 Self::TYPE_FLAGS => __serializer.serialize_field("TYPE_FLAGS", &31u64),
962 Self::TYPE_HALF => __serializer.serialize_field("TYPE_HALF", &32u64),
963 Self::TYPE_STRINGPTR => {
964 __serializer.serialize_field("TYPE_STRINGPTR", &33u64)
965 }
966 Self::TYPE_RELARRAY => {
967 __serializer.serialize_field("TYPE_RELARRAY", &34u64)
968 }
969 Self::TYPE_MAX => __serializer.serialize_field("TYPE_MAX", &35u64),
970 }?;
971 use num_traits::ToPrimitive as _;
972 let num = self.to_u8().ok_or(S::Error::custom("Failed enum Type to_u8"))?;
973 __serializer.serialize_bits(&num)?;
974 __serializer.end()
975 }
976 }
977};
978const _: () = {
979 use havok_serde as __serde;
980 impl __serde::Serialize for FlagValues {
981 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
982 where
983 S: __serde::ser::Serializer,
984 {
985 let mut __serializer = __serializer.serialize_enum_flags()?;
986 if self.is_empty() {
987 __serializer.serialize_bits(&self.bits())?;
988 __serializer.serialize_empty_bit()?;
989 return __serializer.end();
990 }
991 for flag in self.iter() {
992 match flag {
993 Self::FLAGS_NONE => {
994 __serializer.serialize_field("FLAGS_NONE", &Self::FLAGS_NONE)
995 }
996 Self::ALIGN_8 => {
997 __serializer.serialize_field("ALIGN_8", &Self::ALIGN_8)
998 }
999 Self::ALIGN_16 => {
1000 __serializer.serialize_field("ALIGN_16", &Self::ALIGN_16)
1001 }
1002 Self::NOT_OWNED => {
1003 __serializer.serialize_field("NOT_OWNED", &Self::NOT_OWNED)
1004 }
1005 Self::SERIALIZE_IGNORED => {
1006 __serializer
1007 .serialize_field(
1008 "SERIALIZE_IGNORED",
1009 &Self::SERIALIZE_IGNORED,
1010 )
1011 }
1012 remain => {
1013 __serializer
1014 .serialize_field(&remain.bits().to_string(), &remain.bits())
1015 }
1016 }?;
1017 }
1018 __serializer.serialize_bits(&self.bits())?;
1019 __serializer.end()
1020 }
1021 }
1022};
1023#[doc(hidden)]
1024#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1025const _: () = {
1026 #[allow(unused_extern_crates, clippy::useless_attribute)]
1027 extern crate havok_serde as _serde;
1028 #[automatically_derived]
1029 impl<'de> _serde::Deserialize<'de> for Type {
1030 fn deserialize<__D>(
1031 __deserializer: __D,
1032 ) -> _serde::__private::Result<Self, __D::Error>
1033 where
1034 __D: _serde::Deserializer<'de>,
1035 {
1036 #[allow(non_camel_case_types)]
1037 #[doc(hidden)]
1038 enum __Field {
1039 __field0,
1040 __field1,
1041 __field2,
1042 __field3,
1043 __field4,
1044 __field5,
1045 __field6,
1046 __field7,
1047 __field8,
1048 __field9,
1049 __field10,
1050 __field11,
1051 __field12,
1052 __field13,
1053 __field14,
1054 __field15,
1055 __field16,
1056 __field17,
1057 __field18,
1058 __field19,
1059 __field20,
1060 __field21,
1061 __field22,
1062 __field23,
1063 __field24,
1064 __field25,
1065 __field26,
1066 __field27,
1067 __field28,
1068 __field29,
1069 __field30,
1070 __field31,
1071 __field32,
1072 __field33,
1073 __field34,
1074 __field35,
1075 }
1076 #[doc(hidden)]
1077 struct __FieldVisitor;
1078 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1079 type Value = __Field;
1080 fn expecting(
1081 &self,
1082 __formatter: &mut _serde::__private::Formatter,
1083 ) -> _serde::__private::fmt::Result {
1084 _serde::__private::Formatter::write_str(
1085 __formatter,
1086 "variant identifier",
1087 )
1088 }
1089 fn visit_uint8<__E>(
1090 self,
1091 __value: u8,
1092 ) -> _serde::__private::Result<Self::Value, __E>
1093 where
1094 __E: _serde::de::Error,
1095 {
1096 match __value {
1097 0u8 => _serde::__private::Ok(__Field::__field0),
1098 1u8 => _serde::__private::Ok(__Field::__field1),
1099 2u8 => _serde::__private::Ok(__Field::__field2),
1100 3u8 => _serde::__private::Ok(__Field::__field3),
1101 4u8 => _serde::__private::Ok(__Field::__field4),
1102 5u8 => _serde::__private::Ok(__Field::__field5),
1103 6u8 => _serde::__private::Ok(__Field::__field6),
1104 7u8 => _serde::__private::Ok(__Field::__field7),
1105 8u8 => _serde::__private::Ok(__Field::__field8),
1106 9u8 => _serde::__private::Ok(__Field::__field9),
1107 10u8 => _serde::__private::Ok(__Field::__field10),
1108 11u8 => _serde::__private::Ok(__Field::__field11),
1109 12u8 => _serde::__private::Ok(__Field::__field12),
1110 13u8 => _serde::__private::Ok(__Field::__field13),
1111 14u8 => _serde::__private::Ok(__Field::__field14),
1112 15u8 => _serde::__private::Ok(__Field::__field15),
1113 16u8 => _serde::__private::Ok(__Field::__field16),
1114 17u8 => _serde::__private::Ok(__Field::__field17),
1115 18u8 => _serde::__private::Ok(__Field::__field18),
1116 19u8 => _serde::__private::Ok(__Field::__field19),
1117 20u8 => _serde::__private::Ok(__Field::__field20),
1118 21u8 => _serde::__private::Ok(__Field::__field21),
1119 22u8 => _serde::__private::Ok(__Field::__field22),
1120 23u8 => _serde::__private::Ok(__Field::__field23),
1121 24u8 => _serde::__private::Ok(__Field::__field24),
1122 25u8 => _serde::__private::Ok(__Field::__field25),
1123 26u8 => _serde::__private::Ok(__Field::__field26),
1124 27u8 => _serde::__private::Ok(__Field::__field27),
1125 28u8 => _serde::__private::Ok(__Field::__field28),
1126 29u8 => _serde::__private::Ok(__Field::__field29),
1127 30u8 => _serde::__private::Ok(__Field::__field30),
1128 31u8 => _serde::__private::Ok(__Field::__field31),
1129 32u8 => _serde::__private::Ok(__Field::__field32),
1130 33u8 => _serde::__private::Ok(__Field::__field33),
1131 34u8 => _serde::__private::Ok(__Field::__field34),
1132 35u8 => _serde::__private::Ok(__Field::__field35),
1133 _ => {
1134 _serde::__private::Err(
1135 _serde::de::Error::invalid_value(
1136 _serde::de::Unexpected::Uint8(__value),
1137 &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35",
1138 ),
1139 )
1140 }
1141 }
1142 }
1143 fn visit_stringptr<__E>(
1144 self,
1145 __value: StringPtr<'de>,
1146 ) -> _serde::__private::Result<Self::Value, __E>
1147 where
1148 __E: _serde::de::Error,
1149 {
1150 if let Some(__value) = __value.into_inner() {
1151 match __value.as_ref() {
1152 v if v == "0" || v.eq_ignore_ascii_case("TYPE_VOID") => {
1153 _serde::__private::Ok(__Field::__field0)
1154 }
1155 v if v == "1" || v.eq_ignore_ascii_case("TYPE_BOOL") => {
1156 _serde::__private::Ok(__Field::__field1)
1157 }
1158 v if v == "2" || v.eq_ignore_ascii_case("TYPE_CHAR") => {
1159 _serde::__private::Ok(__Field::__field2)
1160 }
1161 v if v == "3" || v.eq_ignore_ascii_case("TYPE_INT8") => {
1162 _serde::__private::Ok(__Field::__field3)
1163 }
1164 v if v == "4" || v.eq_ignore_ascii_case("TYPE_UINT8") => {
1165 _serde::__private::Ok(__Field::__field4)
1166 }
1167 v if v == "5" || v.eq_ignore_ascii_case("TYPE_INT16") => {
1168 _serde::__private::Ok(__Field::__field5)
1169 }
1170 v if v == "6" || v.eq_ignore_ascii_case("TYPE_UINT16") => {
1171 _serde::__private::Ok(__Field::__field6)
1172 }
1173 v if v == "7" || v.eq_ignore_ascii_case("TYPE_INT32") => {
1174 _serde::__private::Ok(__Field::__field7)
1175 }
1176 v if v == "8" || v.eq_ignore_ascii_case("TYPE_UINT32") => {
1177 _serde::__private::Ok(__Field::__field8)
1178 }
1179 v if v == "9" || v.eq_ignore_ascii_case("TYPE_INT64") => {
1180 _serde::__private::Ok(__Field::__field9)
1181 }
1182 v if v == "10" || v.eq_ignore_ascii_case("TYPE_UINT64") => {
1183 _serde::__private::Ok(__Field::__field10)
1184 }
1185 v if v == "11" || v.eq_ignore_ascii_case("TYPE_REAL") => {
1186 _serde::__private::Ok(__Field::__field11)
1187 }
1188 v if v == "12" || v.eq_ignore_ascii_case("TYPE_VECTOR4") => {
1189 _serde::__private::Ok(__Field::__field12)
1190 }
1191 v if v == "13"
1192 || v.eq_ignore_ascii_case("TYPE_QUATERNION") => {
1193 _serde::__private::Ok(__Field::__field13)
1194 }
1195 v if v == "14" || v.eq_ignore_ascii_case("TYPE_MATRIX3") => {
1196 _serde::__private::Ok(__Field::__field14)
1197 }
1198 v if v == "15" || v.eq_ignore_ascii_case("TYPE_ROTATION") => {
1199 _serde::__private::Ok(__Field::__field15)
1200 }
1201 v if v == "16"
1202 || v.eq_ignore_ascii_case("TYPE_QSTRANSFORM") => {
1203 _serde::__private::Ok(__Field::__field16)
1204 }
1205 v if v == "17" || v.eq_ignore_ascii_case("TYPE_MATRIX4") => {
1206 _serde::__private::Ok(__Field::__field17)
1207 }
1208 v if v == "18"
1209 || v.eq_ignore_ascii_case("TYPE_TRANSFORM") => {
1210 _serde::__private::Ok(__Field::__field18)
1211 }
1212 v if v == "19" || v.eq_ignore_ascii_case("TYPE_ZERO") => {
1213 _serde::__private::Ok(__Field::__field19)
1214 }
1215 v if v == "20" || v.eq_ignore_ascii_case("TYPE_POINTER") => {
1216 _serde::__private::Ok(__Field::__field20)
1217 }
1218 v if v == "21"
1219 || v.eq_ignore_ascii_case("TYPE_FUNCTIONPOINTER") => {
1220 _serde::__private::Ok(__Field::__field21)
1221 }
1222 v if v == "22" || v.eq_ignore_ascii_case("TYPE_ARRAY") => {
1223 _serde::__private::Ok(__Field::__field22)
1224 }
1225 v if v == "23"
1226 || v.eq_ignore_ascii_case("TYPE_INPLACEARRAY") => {
1227 _serde::__private::Ok(__Field::__field23)
1228 }
1229 v if v == "24" || v.eq_ignore_ascii_case("TYPE_ENUM") => {
1230 _serde::__private::Ok(__Field::__field24)
1231 }
1232 v if v == "25" || v.eq_ignore_ascii_case("TYPE_STRUCT") => {
1233 _serde::__private::Ok(__Field::__field25)
1234 }
1235 v if v == "26"
1236 || v.eq_ignore_ascii_case("TYPE_SIMPLEARRAY") => {
1237 _serde::__private::Ok(__Field::__field26)
1238 }
1239 v if v == "27"
1240 || v.eq_ignore_ascii_case("TYPE_HOMOGENEOUSARRAY") => {
1241 _serde::__private::Ok(__Field::__field27)
1242 }
1243 v if v == "28" || v.eq_ignore_ascii_case("TYPE_VARIANT") => {
1244 _serde::__private::Ok(__Field::__field28)
1245 }
1246 v if v == "29" || v.eq_ignore_ascii_case("TYPE_CSTRING") => {
1247 _serde::__private::Ok(__Field::__field29)
1248 }
1249 v if v == "30" || v.eq_ignore_ascii_case("TYPE_ULONG") => {
1250 _serde::__private::Ok(__Field::__field30)
1251 }
1252 v if v == "31" || v.eq_ignore_ascii_case("TYPE_FLAGS") => {
1253 _serde::__private::Ok(__Field::__field31)
1254 }
1255 v if v == "32" || v.eq_ignore_ascii_case("TYPE_HALF") => {
1256 _serde::__private::Ok(__Field::__field32)
1257 }
1258 v if v == "33"
1259 || v.eq_ignore_ascii_case("TYPE_STRINGPTR") => {
1260 _serde::__private::Ok(__Field::__field33)
1261 }
1262 v if v == "34" || v.eq_ignore_ascii_case("TYPE_RELARRAY") => {
1263 _serde::__private::Ok(__Field::__field34)
1264 }
1265 v if v == "35" || v.eq_ignore_ascii_case("TYPE_MAX") => {
1266 _serde::__private::Ok(__Field::__field35)
1267 }
1268 _ => {
1269 _serde::__private::Err(
1270 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1271 )
1272 }
1273 }
1274 } else {
1275 _serde::__private::Err(
1276 _serde::de::Error::unknown_variant("None", VARIANTS),
1277 )
1278 }
1279 }
1280 }
1281 impl<'de> _serde::Deserialize<'de> for __Field {
1282 #[inline]
1283 fn deserialize<__D>(
1284 __deserializer: __D,
1285 ) -> _serde::__private::Result<Self, __D::Error>
1286 where
1287 __D: _serde::Deserializer<'de>,
1288 {
1289 _serde::Deserializer::deserialize_identifier(
1290 __deserializer,
1291 _serde::de::ReadEnumSize::Uint8,
1292 __FieldVisitor,
1293 )
1294 }
1295 }
1296 #[doc(hidden)]
1297 struct __Visitor<'de> {
1298 marker: _serde::__private::PhantomData<Type>,
1299 lifetime: _serde::__private::PhantomData<&'de ()>,
1300 }
1301 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1302 type Value = Type;
1303 fn expecting(
1304 &self,
1305 __formatter: &mut _serde::__private::Formatter,
1306 ) -> _serde::__private::fmt::Result {
1307 _serde::__private::Formatter::write_str(__formatter, "enum Type")
1308 }
1309 fn visit_enum<__A>(
1310 self,
1311 __data: __A,
1312 ) -> _serde::__private::Result<Self::Value, __A::Error>
1313 where
1314 __A: _serde::de::EnumAccess<'de>,
1315 {
1316 match _serde::de::EnumAccess::variant(__data)? {
1317 (__Field::__field0, __variant) => {
1318 _serde::de::VariantAccess::unit_variant(__variant)?;
1319 _serde::__private::Ok(Type::TYPE_VOID)
1320 }
1321 (__Field::__field1, __variant) => {
1322 _serde::de::VariantAccess::unit_variant(__variant)?;
1323 _serde::__private::Ok(Type::TYPE_BOOL)
1324 }
1325 (__Field::__field2, __variant) => {
1326 _serde::de::VariantAccess::unit_variant(__variant)?;
1327 _serde::__private::Ok(Type::TYPE_CHAR)
1328 }
1329 (__Field::__field3, __variant) => {
1330 _serde::de::VariantAccess::unit_variant(__variant)?;
1331 _serde::__private::Ok(Type::TYPE_INT8)
1332 }
1333 (__Field::__field4, __variant) => {
1334 _serde::de::VariantAccess::unit_variant(__variant)?;
1335 _serde::__private::Ok(Type::TYPE_UINT8)
1336 }
1337 (__Field::__field5, __variant) => {
1338 _serde::de::VariantAccess::unit_variant(__variant)?;
1339 _serde::__private::Ok(Type::TYPE_INT16)
1340 }
1341 (__Field::__field6, __variant) => {
1342 _serde::de::VariantAccess::unit_variant(__variant)?;
1343 _serde::__private::Ok(Type::TYPE_UINT16)
1344 }
1345 (__Field::__field7, __variant) => {
1346 _serde::de::VariantAccess::unit_variant(__variant)?;
1347 _serde::__private::Ok(Type::TYPE_INT32)
1348 }
1349 (__Field::__field8, __variant) => {
1350 _serde::de::VariantAccess::unit_variant(__variant)?;
1351 _serde::__private::Ok(Type::TYPE_UINT32)
1352 }
1353 (__Field::__field9, __variant) => {
1354 _serde::de::VariantAccess::unit_variant(__variant)?;
1355 _serde::__private::Ok(Type::TYPE_INT64)
1356 }
1357 (__Field::__field10, __variant) => {
1358 _serde::de::VariantAccess::unit_variant(__variant)?;
1359 _serde::__private::Ok(Type::TYPE_UINT64)
1360 }
1361 (__Field::__field11, __variant) => {
1362 _serde::de::VariantAccess::unit_variant(__variant)?;
1363 _serde::__private::Ok(Type::TYPE_REAL)
1364 }
1365 (__Field::__field12, __variant) => {
1366 _serde::de::VariantAccess::unit_variant(__variant)?;
1367 _serde::__private::Ok(Type::TYPE_VECTOR4)
1368 }
1369 (__Field::__field13, __variant) => {
1370 _serde::de::VariantAccess::unit_variant(__variant)?;
1371 _serde::__private::Ok(Type::TYPE_QUATERNION)
1372 }
1373 (__Field::__field14, __variant) => {
1374 _serde::de::VariantAccess::unit_variant(__variant)?;
1375 _serde::__private::Ok(Type::TYPE_MATRIX3)
1376 }
1377 (__Field::__field15, __variant) => {
1378 _serde::de::VariantAccess::unit_variant(__variant)?;
1379 _serde::__private::Ok(Type::TYPE_ROTATION)
1380 }
1381 (__Field::__field16, __variant) => {
1382 _serde::de::VariantAccess::unit_variant(__variant)?;
1383 _serde::__private::Ok(Type::TYPE_QSTRANSFORM)
1384 }
1385 (__Field::__field17, __variant) => {
1386 _serde::de::VariantAccess::unit_variant(__variant)?;
1387 _serde::__private::Ok(Type::TYPE_MATRIX4)
1388 }
1389 (__Field::__field18, __variant) => {
1390 _serde::de::VariantAccess::unit_variant(__variant)?;
1391 _serde::__private::Ok(Type::TYPE_TRANSFORM)
1392 }
1393 (__Field::__field19, __variant) => {
1394 _serde::de::VariantAccess::unit_variant(__variant)?;
1395 _serde::__private::Ok(Type::TYPE_ZERO)
1396 }
1397 (__Field::__field20, __variant) => {
1398 _serde::de::VariantAccess::unit_variant(__variant)?;
1399 _serde::__private::Ok(Type::TYPE_POINTER)
1400 }
1401 (__Field::__field21, __variant) => {
1402 _serde::de::VariantAccess::unit_variant(__variant)?;
1403 _serde::__private::Ok(Type::TYPE_FUNCTIONPOINTER)
1404 }
1405 (__Field::__field22, __variant) => {
1406 _serde::de::VariantAccess::unit_variant(__variant)?;
1407 _serde::__private::Ok(Type::TYPE_ARRAY)
1408 }
1409 (__Field::__field23, __variant) => {
1410 _serde::de::VariantAccess::unit_variant(__variant)?;
1411 _serde::__private::Ok(Type::TYPE_INPLACEARRAY)
1412 }
1413 (__Field::__field24, __variant) => {
1414 _serde::de::VariantAccess::unit_variant(__variant)?;
1415 _serde::__private::Ok(Type::TYPE_ENUM)
1416 }
1417 (__Field::__field25, __variant) => {
1418 _serde::de::VariantAccess::unit_variant(__variant)?;
1419 _serde::__private::Ok(Type::TYPE_STRUCT)
1420 }
1421 (__Field::__field26, __variant) => {
1422 _serde::de::VariantAccess::unit_variant(__variant)?;
1423 _serde::__private::Ok(Type::TYPE_SIMPLEARRAY)
1424 }
1425 (__Field::__field27, __variant) => {
1426 _serde::de::VariantAccess::unit_variant(__variant)?;
1427 _serde::__private::Ok(Type::TYPE_HOMOGENEOUSARRAY)
1428 }
1429 (__Field::__field28, __variant) => {
1430 _serde::de::VariantAccess::unit_variant(__variant)?;
1431 _serde::__private::Ok(Type::TYPE_VARIANT)
1432 }
1433 (__Field::__field29, __variant) => {
1434 _serde::de::VariantAccess::unit_variant(__variant)?;
1435 _serde::__private::Ok(Type::TYPE_CSTRING)
1436 }
1437 (__Field::__field30, __variant) => {
1438 _serde::de::VariantAccess::unit_variant(__variant)?;
1439 _serde::__private::Ok(Type::TYPE_ULONG)
1440 }
1441 (__Field::__field31, __variant) => {
1442 _serde::de::VariantAccess::unit_variant(__variant)?;
1443 _serde::__private::Ok(Type::TYPE_FLAGS)
1444 }
1445 (__Field::__field32, __variant) => {
1446 _serde::de::VariantAccess::unit_variant(__variant)?;
1447 _serde::__private::Ok(Type::TYPE_HALF)
1448 }
1449 (__Field::__field33, __variant) => {
1450 _serde::de::VariantAccess::unit_variant(__variant)?;
1451 _serde::__private::Ok(Type::TYPE_STRINGPTR)
1452 }
1453 (__Field::__field34, __variant) => {
1454 _serde::de::VariantAccess::unit_variant(__variant)?;
1455 _serde::__private::Ok(Type::TYPE_RELARRAY)
1456 }
1457 (__Field::__field35, __variant) => {
1458 _serde::de::VariantAccess::unit_variant(__variant)?;
1459 _serde::__private::Ok(Type::TYPE_MAX)
1460 }
1461 }
1462 }
1463 }
1464 #[doc(hidden)]
1465 const VARIANTS: &'static [&'static str] = &[
1466 "TYPE_VOID",
1467 "TYPE_BOOL",
1468 "TYPE_CHAR",
1469 "TYPE_INT8",
1470 "TYPE_UINT8",
1471 "TYPE_INT16",
1472 "TYPE_UINT16",
1473 "TYPE_INT32",
1474 "TYPE_UINT32",
1475 "TYPE_INT64",
1476 "TYPE_UINT64",
1477 "TYPE_REAL",
1478 "TYPE_VECTOR4",
1479 "TYPE_QUATERNION",
1480 "TYPE_MATRIX3",
1481 "TYPE_ROTATION",
1482 "TYPE_QSTRANSFORM",
1483 "TYPE_MATRIX4",
1484 "TYPE_TRANSFORM",
1485 "TYPE_ZERO",
1486 "TYPE_POINTER",
1487 "TYPE_FUNCTIONPOINTER",
1488 "TYPE_ARRAY",
1489 "TYPE_INPLACEARRAY",
1490 "TYPE_ENUM",
1491 "TYPE_STRUCT",
1492 "TYPE_SIMPLEARRAY",
1493 "TYPE_HOMOGENEOUSARRAY",
1494 "TYPE_VARIANT",
1495 "TYPE_CSTRING",
1496 "TYPE_ULONG",
1497 "TYPE_FLAGS",
1498 "TYPE_HALF",
1499 "TYPE_STRINGPTR",
1500 "TYPE_RELARRAY",
1501 "TYPE_MAX",
1502 ];
1503 _serde::Deserializer::deserialize_enum(
1504 __deserializer,
1505 "Type",
1506 VARIANTS,
1507 __Visitor {
1508 marker: _serde::__private::PhantomData::<Type>,
1509 lifetime: _serde::__private::PhantomData,
1510 },
1511 )
1512 }
1513 }
1514};
1515#[doc(hidden)]
1516#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1517const _: () = {
1518 #[allow(unused_extern_crates, clippy::useless_attribute)]
1519 extern crate havok_serde as _serde;
1520 #[automatically_derived]
1521 impl<'de> _serde::Deserialize<'de> for FlagValues {
1522 fn deserialize<__D>(
1523 __deserializer: __D,
1524 ) -> _serde::__private::Result<Self, __D::Error>
1525 where
1526 __D: _serde::Deserializer<'de>,
1527 {
1528 #[doc(hidden)]
1529 struct __Visitor<'de> {
1530 marker: _serde::__private::PhantomData<FlagValues>,
1531 lifetime: _serde::__private::PhantomData<&'de ()>,
1532 }
1533 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1534 type Value = FlagValues;
1535 fn expecting(
1536 &self,
1537 __formatter: &mut _serde::__private::Formatter,
1538 ) -> _serde::__private::fmt::Result {
1539 _serde::__private::Formatter::write_str(
1540 __formatter,
1541 "struct FlagValues(flags)",
1542 )
1543 }
1544 #[inline]
1545 fn visit_uint32<__E>(
1546 self,
1547 __value: u32,
1548 ) -> _serde::__private::Result<Self::Value, __E>
1549 where
1550 __E: _serde::de::Error,
1551 {
1552 Ok(FlagValues::from_bits_retain(__value as _))
1553 }
1554 fn visit_stringptr<__E>(
1555 self,
1556 __value: StringPtr<'de>,
1557 ) -> _serde::__private::Result<Self::Value, __E>
1558 where
1559 __E: _serde::de::Error,
1560 {
1561 match <FlagValues as core::str::FromStr>::from_str(
1562 __value.into_inner().unwrap().as_ref(),
1563 ) {
1564 Ok(flags) => Ok(flags),
1565 Err(err) => Err(_serde::de::Error::custom(err)),
1566 }
1567 }
1568 }
1569 _serde::Deserializer::deserialize_flags(
1570 __deserializer,
1571 _serde::de::ReadEnumSize::Uint32,
1572 __Visitor {
1573 marker: _serde::__private::PhantomData::<FlagValues>,
1574 lifetime: _serde::__private::PhantomData,
1575 },
1576 )
1577 }
1578 }
1579};