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