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 hkpMoppCode {
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(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "info"))]
35 #[cfg_attr(feature = "serde", serde(rename = "info"))]
36 pub m_info: hkpMoppCodeCodeInfo,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
42 #[cfg_attr(feature = "serde", serde(rename = "data"))]
43 pub m_data: Vec<u8>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "buildType"))]
49 #[cfg_attr(feature = "serde", serde(rename = "buildType"))]
50 pub m_buildType: BuildType,
51}
52const _: () = {
53 use havok_serde as _serde;
54 impl _serde::HavokClass for hkpMoppCode {
55 #[inline]
56 fn name(&self) -> &'static str {
57 "hkpMoppCode"
58 }
59 #[inline]
60 fn signature(&self) -> _serde::__private::Signature {
61 _serde::__private::Signature::new(0x924c2661)
62 }
63 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
64 fn deps_indexes(&self) -> Vec<usize> {
65 let mut v = Vec::new();
66 v.extend(self.m_info.deps_indexes());
67 v
68 }
69 }
70 impl _serde::Serialize for hkpMoppCode {
71 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
72 where
73 S: _serde::ser::Serializer,
74 {
75 let class_meta = self
76 .__ptr
77 .map(|name| (name, _serde::__private::Signature::new(0x924c2661)));
78 let mut serializer = __serializer
79 .serialize_struct("hkpMoppCode", class_meta, (48u64, 64u64))?;
80 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
81 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
82 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
83 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
84 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
85 serializer.serialize_field("info", &self.m_info)?;
86 serializer.serialize_array_field("data", &self.m_data, TypeSize::NonPtr)?;
87 serializer.serialize_field("buildType", &self.m_buildType)?;
88 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 15usize].as_slice())?;
89 serializer.end()
90 }
91 }
92};
93#[doc(hidden)]
94#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
95const _: () = {
96 use havok_serde as _serde;
97 #[automatically_derived]
98 impl<'de> _serde::Deserialize<'de> for hkpMoppCode {
99 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
100 where
101 __D: _serde::Deserializer<'de>,
102 {
103 #[allow(non_camel_case_types)]
104 enum __Field {
105 m_info,
106 m_data,
107 m_buildType,
108 __ignore,
109 }
110 struct __FieldVisitor;
111 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
112 type Value = __Field;
113 fn expecting(
114 &self,
115 __formatter: &mut core::fmt::Formatter,
116 ) -> core::fmt::Result {
117 core::fmt::Formatter::write_str(__formatter, "field identifier")
118 }
119 #[allow(clippy::match_single_binding)]
121 #[allow(clippy::reversed_empty_ranges)]
122 #[allow(clippy::single_match)]
123 fn visit_key<__E>(
124 self,
125 __value: &str,
126 ) -> core::result::Result<Self::Value, __E>
127 where
128 __E: _serde::de::Error,
129 {
130 match __value {
131 "info" => Ok(__Field::m_info),
132 "data" => Ok(__Field::m_data),
133 "buildType" => Ok(__Field::m_buildType),
134 _ => Ok(__Field::__ignore),
135 }
136 }
137 }
138 impl<'de> _serde::Deserialize<'de> for __Field {
139 #[inline]
140 fn deserialize<__D>(
141 __deserializer: __D,
142 ) -> core::result::Result<Self, __D::Error>
143 where
144 __D: _serde::Deserializer<'de>,
145 {
146 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
147 }
148 }
149 struct __hkpMoppCodeVisitor<'de> {
150 marker: _serde::__private::PhantomData<hkpMoppCode>,
151 lifetime: _serde::__private::PhantomData<&'de ()>,
152 }
153 #[allow(clippy::match_single_binding)]
154 #[allow(clippy::reversed_empty_ranges)]
155 #[allow(clippy::single_match)]
156 impl<'de> _serde::de::Visitor<'de> for __hkpMoppCodeVisitor<'de> {
157 type Value = hkpMoppCode;
158 fn expecting(
159 &self,
160 __formatter: &mut core::fmt::Formatter,
161 ) -> core::fmt::Result {
162 core::fmt::Formatter::write_str(__formatter, "struct hkpMoppCode")
163 }
164 fn visit_struct_for_bytes<__A>(
165 self,
166 mut __map: __A,
167 ) -> _serde::__private::Result<Self::Value, __A::Error>
168 where
169 __A: _serde::de::MapAccess<'de>,
170 {
171 let __ptr = __A::class_ptr(&mut __map);
172 let parent = __A::parent_value(&mut __map)?;
173 let mut m_info: _serde::__private::Option<hkpMoppCodeCodeInfo> = _serde::__private::None;
174 let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
175 let mut m_buildType: _serde::__private::Option<BuildType> = _serde::__private::None;
176 for i in 0..3usize {
177 match i {
178 0usize => {
179 if _serde::__private::Option::is_some(&m_info) {
180 return _serde::__private::Err(
181 <__A::Error as _serde::de::Error>::duplicate_field("info"),
182 );
183 }
184 __A::pad(&mut __map, 8usize, 0usize)?;
185 m_info = _serde::__private::Some(
186 match __A::next_value::<hkpMoppCodeCodeInfo>(&mut __map) {
187 _serde::__private::Ok(__val) => __val,
188 _serde::__private::Err(__err) => {
189 return _serde::__private::Err(__err);
190 }
191 },
192 );
193 }
194 1usize => {
195 if _serde::__private::Option::is_some(&m_data) {
196 return _serde::__private::Err(
197 <__A::Error as _serde::de::Error>::duplicate_field("data"),
198 );
199 }
200 m_data = _serde::__private::Some(
201 match __A::next_value::<Vec<u8>>(&mut __map) {
202 _serde::__private::Ok(__val) => __val,
203 _serde::__private::Err(__err) => {
204 return _serde::__private::Err(__err);
205 }
206 },
207 );
208 }
209 2usize => {
210 if _serde::__private::Option::is_some(&m_buildType) {
211 return _serde::__private::Err(
212 <__A::Error as _serde::de::Error>::duplicate_field(
213 "buildType",
214 ),
215 );
216 }
217 m_buildType = _serde::__private::Some(
218 match __A::next_value::<BuildType>(&mut __map) {
219 _serde::__private::Ok(__val) => __val,
220 _serde::__private::Err(__err) => {
221 return _serde::__private::Err(__err);
222 }
223 },
224 );
225 }
226 _ => {}
227 }
228 }
229 __A::pad(&mut __map, 3usize, 15usize)?;
230 let m_info = match m_info {
231 _serde::__private::Some(__field) => __field,
232 _serde::__private::None => {
233 return _serde::__private::Err(
234 <__A::Error as _serde::de::Error>::missing_field("info"),
235 );
236 }
237 };
238 let m_data = match m_data {
239 _serde::__private::Some(__field) => __field,
240 _serde::__private::None => {
241 return _serde::__private::Err(
242 <__A::Error as _serde::de::Error>::missing_field("data"),
243 );
244 }
245 };
246 let m_buildType = match m_buildType {
247 _serde::__private::Some(__field) => __field,
248 _serde::__private::None => {
249 return _serde::__private::Err(
250 <__A::Error as _serde::de::Error>::missing_field(
251 "buildType",
252 ),
253 );
254 }
255 };
256 _serde::__private::Ok(hkpMoppCode {
257 __ptr,
258 parent,
259 m_info,
260 m_data,
261 m_buildType,
262 })
263 }
264 #[allow(clippy::manual_unwrap_or_default)]
265 fn visit_struct<__A>(
266 self,
267 mut __map: __A,
268 ) -> _serde::__private::Result<Self::Value, __A::Error>
269 where
270 __A: _serde::de::MapAccess<'de>,
271 {
272 let mut m_info: _serde::__private::Option<hkpMoppCodeCodeInfo> = _serde::__private::None;
273 let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
274 let mut m_buildType: _serde::__private::Option<BuildType> = _serde::__private::None;
275 while let _serde::__private::Some(__key) = {
276 __A::next_key::<__Field>(&mut __map)?
277 } {
278 match __key {
279 __Field::m_info => {
280 #[cfg(
281 any(feature = "strict", feature = "ignore_duplicates")
282 )]
283 if _serde::__private::Option::is_some(&m_info) {
284 #[cfg(feature = "ignore_duplicates")]
285 {
286 __A::skip_value(&mut __map)?;
287 continue;
288 }
289 #[cfg(feature = "strict")]
290 return _serde::__private::Err(
291 <__A::Error as _serde::de::Error>::duplicate_field("info"),
292 );
293 }
294 m_info = _serde::__private::Some(
295 match __A::next_value::<hkpMoppCodeCodeInfo>(&mut __map) {
296 _serde::__private::Ok(__val) => __val,
297 _serde::__private::Err(__err) => {
298 return _serde::__private::Err(__err);
299 }
300 },
301 );
302 }
303 __Field::m_data => {
304 #[cfg(
305 any(feature = "strict", feature = "ignore_duplicates")
306 )]
307 if _serde::__private::Option::is_some(&m_data) {
308 #[cfg(feature = "ignore_duplicates")]
309 {
310 __A::skip_value(&mut __map)?;
311 continue;
312 }
313 #[cfg(feature = "strict")]
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field("data"),
316 );
317 }
318 m_data = _serde::__private::Some(
319 match __A::next_value::<Vec<u8>>(&mut __map) {
320 _serde::__private::Ok(__val) => __val,
321 _serde::__private::Err(__err) => {
322 return _serde::__private::Err(__err);
323 }
324 },
325 );
326 }
327 __Field::m_buildType => {
328 #[cfg(
329 any(feature = "strict", feature = "ignore_duplicates")
330 )]
331 if _serde::__private::Option::is_some(&m_buildType) {
332 #[cfg(feature = "ignore_duplicates")]
333 {
334 __A::skip_value(&mut __map)?;
335 continue;
336 }
337 #[cfg(feature = "strict")]
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::duplicate_field(
340 "buildType",
341 ),
342 );
343 }
344 m_buildType = _serde::__private::Some(
345 match __A::next_value::<BuildType>(&mut __map) {
346 _serde::__private::Ok(__val) => __val,
347 _serde::__private::Err(__err) => {
348 return _serde::__private::Err(__err);
349 }
350 },
351 );
352 }
353 _ => __A::skip_value(&mut __map)?,
354 }
355 }
356 let m_info = match m_info {
357 _serde::__private::Some(__field) => __field,
358 _serde::__private::None => {
359 #[cfg(feature = "strict")]
360 return _serde::__private::Err(
361 <__A::Error as _serde::de::Error>::missing_field("info"),
362 );
363 #[cfg(not(feature = "strict"))] Default::default()
364 }
365 };
366 let m_data = match m_data {
367 _serde::__private::Some(__field) => __field,
368 _serde::__private::None => {
369 #[cfg(feature = "strict")]
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::missing_field("data"),
372 );
373 #[cfg(not(feature = "strict"))] Default::default()
374 }
375 };
376 let m_buildType = match m_buildType {
377 _serde::__private::Some(__field) => __field,
378 _serde::__private::None => {
379 #[cfg(feature = "strict")]
380 return _serde::__private::Err(
381 <__A::Error as _serde::de::Error>::missing_field(
382 "buildType",
383 ),
384 );
385 #[cfg(not(feature = "strict"))] Default::default()
386 }
387 };
388 let __ptr = None;
389 let parent = hkBaseObject { __ptr };
390 let parent = hkReferencedObject {
391 __ptr,
392 parent,
393 ..Default::default()
394 };
395 let __ptr = __A::class_ptr(&mut __map);
396 _serde::__private::Ok(hkpMoppCode {
397 __ptr,
398 parent,
399 m_info,
400 m_data,
401 m_buildType,
402 })
403 }
404 }
405 const FIELDS: &[&str] = &["info", "data", "buildType"];
406 _serde::Deserializer::deserialize_struct(
407 deserializer,
408 "hkpMoppCode",
409 FIELDS,
410 __hkpMoppCodeVisitor {
411 marker: _serde::__private::PhantomData::<hkpMoppCode>,
412 lifetime: _serde::__private::PhantomData,
413 },
414 )
415 }
416 }
417};
418#[allow(non_upper_case_globals, non_snake_case)]
421#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
422#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
423#[derive(
424 Debug,
425 Clone,
426 Default,
427 PartialEq,
428 Eq,
429 PartialOrd,
430 Ord,
431 num_derive::ToPrimitive,
432 num_derive::FromPrimitive,
433)]
434pub enum BuildType {
435 #[default]
436 BUILT_WITH_CHUNK_SUBDIVISION = 0isize,
437 BUILT_WITHOUT_CHUNK_SUBDIVISION = 1isize,
438 BUILD_NOT_SET = 2isize,
439}
440const _: () = {
441 use havok_serde as __serde;
442 impl __serde::Serialize for BuildType {
443 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
444 where
445 S: __serde::ser::Serializer,
446 {
447 let mut __serializer = __serializer.serialize_enum_flags()?;
448 match self {
449 Self::BUILT_WITH_CHUNK_SUBDIVISION => {
450 __serializer.serialize_field("BUILT_WITH_CHUNK_SUBDIVISION", &0u64)
451 }
452 Self::BUILT_WITHOUT_CHUNK_SUBDIVISION => {
453 __serializer
454 .serialize_field("BUILT_WITHOUT_CHUNK_SUBDIVISION", &1u64)
455 }
456 Self::BUILD_NOT_SET => {
457 __serializer.serialize_field("BUILD_NOT_SET", &2u64)
458 }
459 }?;
460 use num_traits::ToPrimitive as _;
461 let num = self
462 .to_i8()
463 .ok_or(S::Error::custom("Failed enum BuildType to_i8"))?;
464 __serializer.serialize_bits(&num)?;
465 __serializer.end()
466 }
467 }
468};
469#[doc(hidden)]
470#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
471const _: () = {
472 #[allow(unused_extern_crates, clippy::useless_attribute)]
473 extern crate havok_serde as _serde;
474 #[automatically_derived]
475 impl<'de> _serde::Deserialize<'de> for BuildType {
476 fn deserialize<__D>(
477 __deserializer: __D,
478 ) -> _serde::__private::Result<Self, __D::Error>
479 where
480 __D: _serde::Deserializer<'de>,
481 {
482 #[allow(non_camel_case_types)]
483 #[doc(hidden)]
484 enum __Field {
485 __field0,
486 __field1,
487 __field2,
488 }
489 #[doc(hidden)]
490 struct __FieldVisitor;
491 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
492 type Value = __Field;
493 fn expecting(
494 &self,
495 __formatter: &mut _serde::__private::Formatter,
496 ) -> _serde::__private::fmt::Result {
497 _serde::__private::Formatter::write_str(
498 __formatter,
499 "variant identifier",
500 )
501 }
502 fn visit_int8<__E>(
503 self,
504 __value: i8,
505 ) -> _serde::__private::Result<Self::Value, __E>
506 where
507 __E: _serde::de::Error,
508 {
509 match __value {
510 0i8 => _serde::__private::Ok(__Field::__field0),
511 1i8 => _serde::__private::Ok(__Field::__field1),
512 2i8 => _serde::__private::Ok(__Field::__field2),
513 _ => {
514 _serde::__private::Err(
515 _serde::de::Error::invalid_value(
516 _serde::de::Unexpected::Int8(__value),
517 &"value(i8) of variant is one of 0, 1, 2",
518 ),
519 )
520 }
521 }
522 }
523 fn visit_stringptr<__E>(
524 self,
525 __value: StringPtr<'de>,
526 ) -> _serde::__private::Result<Self::Value, __E>
527 where
528 __E: _serde::de::Error,
529 {
530 if let Some(__value) = __value.into_inner() {
531 match __value.as_ref() {
532 v if v == "0"
533 || v
534 .eq_ignore_ascii_case("BUILT_WITH_CHUNK_SUBDIVISION") => {
535 _serde::__private::Ok(__Field::__field0)
536 }
537 v if v == "1"
538 || v
539 .eq_ignore_ascii_case("BUILT_WITHOUT_CHUNK_SUBDIVISION") => {
540 _serde::__private::Ok(__Field::__field1)
541 }
542 v if v == "2" || v.eq_ignore_ascii_case("BUILD_NOT_SET") => {
543 _serde::__private::Ok(__Field::__field2)
544 }
545 _ => {
546 _serde::__private::Err(
547 _serde::de::Error::unknown_variant(&__value, VARIANTS),
548 )
549 }
550 }
551 } else {
552 _serde::__private::Err(
553 _serde::de::Error::unknown_variant("None", VARIANTS),
554 )
555 }
556 }
557 }
558 impl<'de> _serde::Deserialize<'de> for __Field {
559 #[inline]
560 fn deserialize<__D>(
561 __deserializer: __D,
562 ) -> _serde::__private::Result<Self, __D::Error>
563 where
564 __D: _serde::Deserializer<'de>,
565 {
566 _serde::Deserializer::deserialize_identifier(
567 __deserializer,
568 _serde::de::ReadEnumSize::Int8,
569 __FieldVisitor,
570 )
571 }
572 }
573 #[doc(hidden)]
574 struct __Visitor<'de> {
575 marker: _serde::__private::PhantomData<BuildType>,
576 lifetime: _serde::__private::PhantomData<&'de ()>,
577 }
578 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
579 type Value = BuildType;
580 fn expecting(
581 &self,
582 __formatter: &mut _serde::__private::Formatter,
583 ) -> _serde::__private::fmt::Result {
584 _serde::__private::Formatter::write_str(
585 __formatter,
586 "enum BuildType",
587 )
588 }
589 fn visit_enum<__A>(
590 self,
591 __data: __A,
592 ) -> _serde::__private::Result<Self::Value, __A::Error>
593 where
594 __A: _serde::de::EnumAccess<'de>,
595 {
596 match _serde::de::EnumAccess::variant(__data)? {
597 (__Field::__field0, __variant) => {
598 _serde::de::VariantAccess::unit_variant(__variant)?;
599 _serde::__private::Ok(
600 BuildType::BUILT_WITH_CHUNK_SUBDIVISION,
601 )
602 }
603 (__Field::__field1, __variant) => {
604 _serde::de::VariantAccess::unit_variant(__variant)?;
605 _serde::__private::Ok(
606 BuildType::BUILT_WITHOUT_CHUNK_SUBDIVISION,
607 )
608 }
609 (__Field::__field2, __variant) => {
610 _serde::de::VariantAccess::unit_variant(__variant)?;
611 _serde::__private::Ok(BuildType::BUILD_NOT_SET)
612 }
613 }
614 }
615 }
616 #[doc(hidden)]
617 const VARIANTS: &'static [&'static str] = &[
618 "BUILT_WITH_CHUNK_SUBDIVISION",
619 "BUILT_WITHOUT_CHUNK_SUBDIVISION",
620 "BUILD_NOT_SET",
621 ];
622 _serde::Deserializer::deserialize_enum(
623 __deserializer,
624 "BuildType",
625 VARIANTS,
626 __Visitor {
627 marker: _serde::__private::PhantomData::<BuildType>,
628 lifetime: _serde::__private::PhantomData,
629 },
630 )
631 }
632 }
633};