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 hkbStateMachineInternalState {
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 = "activeTransitions"))]
35 #[cfg_attr(feature = "serde", serde(rename = "activeTransitions"))]
36 pub m_activeTransitions: Vec<hkbStateMachineActiveTransitionInfo>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "transitionFlags"))]
42 #[cfg_attr(feature = "serde", serde(rename = "transitionFlags"))]
43 pub m_transitionFlags: Vec<u8>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "wildcardTransitionFlags"))]
49 #[cfg_attr(feature = "serde", serde(rename = "wildcardTransitionFlags"))]
50 pub m_wildcardTransitionFlags: Vec<u8>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "delayedTransitions"))]
56 #[cfg_attr(feature = "serde", serde(rename = "delayedTransitions"))]
57 pub m_delayedTransitions: Vec<hkbStateMachineDelayedTransitionInfo>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "timeInState"))]
63 #[cfg_attr(feature = "serde", serde(rename = "timeInState"))]
64 pub m_timeInState: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "lastLocalTime"))]
70 #[cfg_attr(feature = "serde", serde(rename = "lastLocalTime"))]
71 pub m_lastLocalTime: f32,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "currentStateId"))]
77 #[cfg_attr(feature = "serde", serde(rename = "currentStateId"))]
78 pub m_currentStateId: i32,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "previousStateId"))]
84 #[cfg_attr(feature = "serde", serde(rename = "previousStateId"))]
85 pub m_previousStateId: i32,
86 #[cfg_attr(
91 feature = "json_schema",
92 schemars(rename = "nextStartStateIndexOverride")
93 )]
94 #[cfg_attr(feature = "serde", serde(rename = "nextStartStateIndexOverride"))]
95 pub m_nextStartStateIndexOverride: i32,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "stateOrTransitionChanged"))]
101 #[cfg_attr(feature = "serde", serde(rename = "stateOrTransitionChanged"))]
102 pub m_stateOrTransitionChanged: bool,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "echoNextUpdate"))]
108 #[cfg_attr(feature = "serde", serde(rename = "echoNextUpdate"))]
109 pub m_echoNextUpdate: bool,
110}
111const _: () = {
112 use havok_serde as _serde;
113 impl _serde::HavokClass for hkbStateMachineInternalState {
114 #[inline]
115 fn name(&self) -> &'static str {
116 "hkbStateMachineInternalState"
117 }
118 #[inline]
119 fn signature(&self) -> _serde::__private::Signature {
120 _serde::__private::Signature::new(0xbd1a7502)
121 }
122 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
123 fn deps_indexes(&self) -> Vec<usize> {
124 let mut v = Vec::new();
125 v.extend(
126 self
127 .m_activeTransitions
128 .iter()
129 .flat_map(|class| class.deps_indexes())
130 .collect::<Vec<usize>>(),
131 );
132 v.extend(
133 self
134 .m_delayedTransitions
135 .iter()
136 .flat_map(|class| class.deps_indexes())
137 .collect::<Vec<usize>>(),
138 );
139 v
140 }
141 }
142 impl _serde::Serialize for hkbStateMachineInternalState {
143 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
144 where
145 S: _serde::ser::Serializer,
146 {
147 let class_meta = self
148 .__ptr
149 .map(|name| (name, _serde::__private::Signature::new(0xbd1a7502)));
150 let mut serializer = __serializer
151 .serialize_struct(
152 "hkbStateMachineInternalState",
153 class_meta,
154 (80u64, 104u64),
155 )?;
156 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
157 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
158 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
159 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
160 serializer
161 .serialize_array_field(
162 "activeTransitions",
163 &self.m_activeTransitions,
164 TypeSize::Struct {
165 size_x86: 32u64,
166 size_x86_64: 40u64,
167 },
168 )?;
169 serializer
170 .serialize_array_field(
171 "transitionFlags",
172 &self.m_transitionFlags,
173 TypeSize::NonPtr,
174 )?;
175 serializer
176 .serialize_array_field(
177 "wildcardTransitionFlags",
178 &self.m_wildcardTransitionFlags,
179 TypeSize::NonPtr,
180 )?;
181 serializer
182 .serialize_array_field(
183 "delayedTransitions",
184 &self.m_delayedTransitions,
185 TypeSize::Struct {
186 size_x86: 24u64,
187 size_x86_64: 24u64,
188 },
189 )?;
190 serializer.serialize_field("timeInState", &self.m_timeInState)?;
191 serializer.serialize_field("lastLocalTime", &self.m_lastLocalTime)?;
192 serializer.serialize_field("currentStateId", &self.m_currentStateId)?;
193 serializer.serialize_field("previousStateId", &self.m_previousStateId)?;
194 serializer
195 .serialize_field(
196 "nextStartStateIndexOverride",
197 &self.m_nextStartStateIndexOverride,
198 )?;
199 serializer
200 .serialize_field(
201 "stateOrTransitionChanged",
202 &self.m_stateOrTransitionChanged,
203 )?;
204 serializer.serialize_field("echoNextUpdate", &self.m_echoNextUpdate)?;
205 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
206 serializer.end()
207 }
208 }
209};
210#[doc(hidden)]
211#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
212const _: () = {
213 use havok_serde as _serde;
214 #[automatically_derived]
215 impl<'de> _serde::Deserialize<'de> for hkbStateMachineInternalState {
216 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
217 where
218 __D: _serde::Deserializer<'de>,
219 {
220 #[allow(non_camel_case_types)]
221 enum __Field {
222 m_activeTransitions,
223 m_transitionFlags,
224 m_wildcardTransitionFlags,
225 m_delayedTransitions,
226 m_timeInState,
227 m_lastLocalTime,
228 m_currentStateId,
229 m_previousStateId,
230 m_nextStartStateIndexOverride,
231 m_stateOrTransitionChanged,
232 m_echoNextUpdate,
233 __ignore,
234 }
235 struct __FieldVisitor;
236 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
237 type Value = __Field;
238 fn expecting(
239 &self,
240 __formatter: &mut core::fmt::Formatter,
241 ) -> core::fmt::Result {
242 core::fmt::Formatter::write_str(__formatter, "field identifier")
243 }
244 #[allow(clippy::match_single_binding)]
246 #[allow(clippy::reversed_empty_ranges)]
247 #[allow(clippy::single_match)]
248 fn visit_key<__E>(
249 self,
250 __value: &str,
251 ) -> core::result::Result<Self::Value, __E>
252 where
253 __E: _serde::de::Error,
254 {
255 match __value {
256 "activeTransitions" => Ok(__Field::m_activeTransitions),
257 "transitionFlags" => Ok(__Field::m_transitionFlags),
258 "wildcardTransitionFlags" => {
259 Ok(__Field::m_wildcardTransitionFlags)
260 }
261 "delayedTransitions" => Ok(__Field::m_delayedTransitions),
262 "timeInState" => Ok(__Field::m_timeInState),
263 "lastLocalTime" => Ok(__Field::m_lastLocalTime),
264 "currentStateId" => Ok(__Field::m_currentStateId),
265 "previousStateId" => Ok(__Field::m_previousStateId),
266 "nextStartStateIndexOverride" => {
267 Ok(__Field::m_nextStartStateIndexOverride)
268 }
269 "stateOrTransitionChanged" => {
270 Ok(__Field::m_stateOrTransitionChanged)
271 }
272 "echoNextUpdate" => Ok(__Field::m_echoNextUpdate),
273 _ => Ok(__Field::__ignore),
274 }
275 }
276 }
277 impl<'de> _serde::Deserialize<'de> for __Field {
278 #[inline]
279 fn deserialize<__D>(
280 __deserializer: __D,
281 ) -> core::result::Result<Self, __D::Error>
282 where
283 __D: _serde::Deserializer<'de>,
284 {
285 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
286 }
287 }
288 struct __hkbStateMachineInternalStateVisitor<'de> {
289 marker: _serde::__private::PhantomData<hkbStateMachineInternalState>,
290 lifetime: _serde::__private::PhantomData<&'de ()>,
291 }
292 #[allow(clippy::match_single_binding)]
293 #[allow(clippy::reversed_empty_ranges)]
294 #[allow(clippy::single_match)]
295 impl<'de> _serde::de::Visitor<'de>
296 for __hkbStateMachineInternalStateVisitor<'de> {
297 type Value = hkbStateMachineInternalState;
298 fn expecting(
299 &self,
300 __formatter: &mut core::fmt::Formatter,
301 ) -> core::fmt::Result {
302 core::fmt::Formatter::write_str(
303 __formatter,
304 "struct hkbStateMachineInternalState",
305 )
306 }
307 fn visit_struct_for_bytes<__A>(
308 self,
309 mut __map: __A,
310 ) -> _serde::__private::Result<Self::Value, __A::Error>
311 where
312 __A: _serde::de::MapAccess<'de>,
313 {
314 let __ptr = __A::class_ptr(&mut __map);
315 let parent = __A::parent_value(&mut __map)?;
316 let mut m_activeTransitions: _serde::__private::Option<
317 Vec<hkbStateMachineActiveTransitionInfo>,
318 > = _serde::__private::None;
319 let mut m_transitionFlags: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
320 let mut m_wildcardTransitionFlags: _serde::__private::Option<
321 Vec<u8>,
322 > = _serde::__private::None;
323 let mut m_delayedTransitions: _serde::__private::Option<
324 Vec<hkbStateMachineDelayedTransitionInfo>,
325 > = _serde::__private::None;
326 let mut m_timeInState: _serde::__private::Option<f32> = _serde::__private::None;
327 let mut m_lastLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
328 let mut m_currentStateId: _serde::__private::Option<i32> = _serde::__private::None;
329 let mut m_previousStateId: _serde::__private::Option<i32> = _serde::__private::None;
330 let mut m_nextStartStateIndexOverride: _serde::__private::Option<
331 i32,
332 > = _serde::__private::None;
333 let mut m_stateOrTransitionChanged: _serde::__private::Option<
334 bool,
335 > = _serde::__private::None;
336 let mut m_echoNextUpdate: _serde::__private::Option<bool> = _serde::__private::None;
337 for i in 0..11usize {
338 match i {
339 0usize => {
340 if _serde::__private::Option::is_some(
341 &m_activeTransitions,
342 ) {
343 return _serde::__private::Err(
344 <__A::Error as _serde::de::Error>::duplicate_field(
345 "activeTransitions",
346 ),
347 );
348 }
349 m_activeTransitions = _serde::__private::Some(
350 match __A::next_value::<
351 Vec<hkbStateMachineActiveTransitionInfo>,
352 >(&mut __map) {
353 _serde::__private::Ok(__val) => __val,
354 _serde::__private::Err(__err) => {
355 return _serde::__private::Err(__err);
356 }
357 },
358 );
359 }
360 1usize => {
361 if _serde::__private::Option::is_some(&m_transitionFlags) {
362 return _serde::__private::Err(
363 <__A::Error as _serde::de::Error>::duplicate_field(
364 "transitionFlags",
365 ),
366 );
367 }
368 m_transitionFlags = _serde::__private::Some(
369 match __A::next_value::<Vec<u8>>(&mut __map) {
370 _serde::__private::Ok(__val) => __val,
371 _serde::__private::Err(__err) => {
372 return _serde::__private::Err(__err);
373 }
374 },
375 );
376 }
377 2usize => {
378 if _serde::__private::Option::is_some(
379 &m_wildcardTransitionFlags,
380 ) {
381 return _serde::__private::Err(
382 <__A::Error as _serde::de::Error>::duplicate_field(
383 "wildcardTransitionFlags",
384 ),
385 );
386 }
387 m_wildcardTransitionFlags = _serde::__private::Some(
388 match __A::next_value::<Vec<u8>>(&mut __map) {
389 _serde::__private::Ok(__val) => __val,
390 _serde::__private::Err(__err) => {
391 return _serde::__private::Err(__err);
392 }
393 },
394 );
395 }
396 3usize => {
397 if _serde::__private::Option::is_some(
398 &m_delayedTransitions,
399 ) {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::duplicate_field(
402 "delayedTransitions",
403 ),
404 );
405 }
406 m_delayedTransitions = _serde::__private::Some(
407 match __A::next_value::<
408 Vec<hkbStateMachineDelayedTransitionInfo>,
409 >(&mut __map) {
410 _serde::__private::Ok(__val) => __val,
411 _serde::__private::Err(__err) => {
412 return _serde::__private::Err(__err);
413 }
414 },
415 );
416 }
417 4usize => {
418 if _serde::__private::Option::is_some(&m_timeInState) {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::duplicate_field(
421 "timeInState",
422 ),
423 );
424 }
425 m_timeInState = _serde::__private::Some(
426 match __A::next_value::<f32>(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 5usize => {
435 if _serde::__private::Option::is_some(&m_lastLocalTime) {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::duplicate_field(
438 "lastLocalTime",
439 ),
440 );
441 }
442 m_lastLocalTime = _serde::__private::Some(
443 match __A::next_value::<f32>(&mut __map) {
444 _serde::__private::Ok(__val) => __val,
445 _serde::__private::Err(__err) => {
446 return _serde::__private::Err(__err);
447 }
448 },
449 );
450 }
451 6usize => {
452 if _serde::__private::Option::is_some(&m_currentStateId) {
453 return _serde::__private::Err(
454 <__A::Error as _serde::de::Error>::duplicate_field(
455 "currentStateId",
456 ),
457 );
458 }
459 m_currentStateId = _serde::__private::Some(
460 match __A::next_value::<i32>(&mut __map) {
461 _serde::__private::Ok(__val) => __val,
462 _serde::__private::Err(__err) => {
463 return _serde::__private::Err(__err);
464 }
465 },
466 );
467 }
468 7usize => {
469 if _serde::__private::Option::is_some(&m_previousStateId) {
470 return _serde::__private::Err(
471 <__A::Error as _serde::de::Error>::duplicate_field(
472 "previousStateId",
473 ),
474 );
475 }
476 m_previousStateId = _serde::__private::Some(
477 match __A::next_value::<i32>(&mut __map) {
478 _serde::__private::Ok(__val) => __val,
479 _serde::__private::Err(__err) => {
480 return _serde::__private::Err(__err);
481 }
482 },
483 );
484 }
485 8usize => {
486 if _serde::__private::Option::is_some(
487 &m_nextStartStateIndexOverride,
488 ) {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::duplicate_field(
491 "nextStartStateIndexOverride",
492 ),
493 );
494 }
495 m_nextStartStateIndexOverride = _serde::__private::Some(
496 match __A::next_value::<i32>(&mut __map) {
497 _serde::__private::Ok(__val) => __val,
498 _serde::__private::Err(__err) => {
499 return _serde::__private::Err(__err);
500 }
501 },
502 );
503 }
504 9usize => {
505 if _serde::__private::Option::is_some(
506 &m_stateOrTransitionChanged,
507 ) {
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "stateOrTransitionChanged",
511 ),
512 );
513 }
514 m_stateOrTransitionChanged = _serde::__private::Some(
515 match __A::next_value::<bool>(&mut __map) {
516 _serde::__private::Ok(__val) => __val,
517 _serde::__private::Err(__err) => {
518 return _serde::__private::Err(__err);
519 }
520 },
521 );
522 }
523 10usize => {
524 if _serde::__private::Option::is_some(&m_echoNextUpdate) {
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "echoNextUpdate",
528 ),
529 );
530 }
531 m_echoNextUpdate = _serde::__private::Some(
532 match __A::next_value::<bool>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 _ => {}
541 }
542 }
543 __A::pad(&mut __map, 2usize, 2usize)?;
544 let m_activeTransitions = match m_activeTransitions {
545 _serde::__private::Some(__field) => __field,
546 _serde::__private::None => {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field(
549 "activeTransitions",
550 ),
551 );
552 }
553 };
554 let m_transitionFlags = match m_transitionFlags {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field(
559 "transitionFlags",
560 ),
561 );
562 }
563 };
564 let m_wildcardTransitionFlags = match m_wildcardTransitionFlags {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "wildcardTransitionFlags",
570 ),
571 );
572 }
573 };
574 let m_delayedTransitions = match m_delayedTransitions {
575 _serde::__private::Some(__field) => __field,
576 _serde::__private::None => {
577 return _serde::__private::Err(
578 <__A::Error as _serde::de::Error>::missing_field(
579 "delayedTransitions",
580 ),
581 );
582 }
583 };
584 let m_timeInState = match m_timeInState {
585 _serde::__private::Some(__field) => __field,
586 _serde::__private::None => {
587 return _serde::__private::Err(
588 <__A::Error as _serde::de::Error>::missing_field(
589 "timeInState",
590 ),
591 );
592 }
593 };
594 let m_lastLocalTime = match m_lastLocalTime {
595 _serde::__private::Some(__field) => __field,
596 _serde::__private::None => {
597 return _serde::__private::Err(
598 <__A::Error as _serde::de::Error>::missing_field(
599 "lastLocalTime",
600 ),
601 );
602 }
603 };
604 let m_currentStateId = match m_currentStateId {
605 _serde::__private::Some(__field) => __field,
606 _serde::__private::None => {
607 return _serde::__private::Err(
608 <__A::Error as _serde::de::Error>::missing_field(
609 "currentStateId",
610 ),
611 );
612 }
613 };
614 let m_previousStateId = match m_previousStateId {
615 _serde::__private::Some(__field) => __field,
616 _serde::__private::None => {
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::missing_field(
619 "previousStateId",
620 ),
621 );
622 }
623 };
624 let m_nextStartStateIndexOverride = match m_nextStartStateIndexOverride {
625 _serde::__private::Some(__field) => __field,
626 _serde::__private::None => {
627 return _serde::__private::Err(
628 <__A::Error as _serde::de::Error>::missing_field(
629 "nextStartStateIndexOverride",
630 ),
631 );
632 }
633 };
634 let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
635 _serde::__private::Some(__field) => __field,
636 _serde::__private::None => {
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::missing_field(
639 "stateOrTransitionChanged",
640 ),
641 );
642 }
643 };
644 let m_echoNextUpdate = match m_echoNextUpdate {
645 _serde::__private::Some(__field) => __field,
646 _serde::__private::None => {
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::missing_field(
649 "echoNextUpdate",
650 ),
651 );
652 }
653 };
654 _serde::__private::Ok(hkbStateMachineInternalState {
655 __ptr,
656 parent,
657 m_activeTransitions,
658 m_transitionFlags,
659 m_wildcardTransitionFlags,
660 m_delayedTransitions,
661 m_timeInState,
662 m_lastLocalTime,
663 m_currentStateId,
664 m_previousStateId,
665 m_nextStartStateIndexOverride,
666 m_stateOrTransitionChanged,
667 m_echoNextUpdate,
668 })
669 }
670 #[allow(clippy::manual_unwrap_or_default)]
671 fn visit_struct<__A>(
672 self,
673 mut __map: __A,
674 ) -> _serde::__private::Result<Self::Value, __A::Error>
675 where
676 __A: _serde::de::MapAccess<'de>,
677 {
678 let mut m_activeTransitions: _serde::__private::Option<
679 Vec<hkbStateMachineActiveTransitionInfo>,
680 > = _serde::__private::None;
681 let mut m_transitionFlags: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
682 let mut m_wildcardTransitionFlags: _serde::__private::Option<
683 Vec<u8>,
684 > = _serde::__private::None;
685 let mut m_delayedTransitions: _serde::__private::Option<
686 Vec<hkbStateMachineDelayedTransitionInfo>,
687 > = _serde::__private::None;
688 let mut m_timeInState: _serde::__private::Option<f32> = _serde::__private::None;
689 let mut m_lastLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
690 let mut m_currentStateId: _serde::__private::Option<i32> = _serde::__private::None;
691 let mut m_previousStateId: _serde::__private::Option<i32> = _serde::__private::None;
692 let mut m_nextStartStateIndexOverride: _serde::__private::Option<
693 i32,
694 > = _serde::__private::None;
695 let mut m_stateOrTransitionChanged: _serde::__private::Option<
696 bool,
697 > = _serde::__private::None;
698 let mut m_echoNextUpdate: _serde::__private::Option<bool> = _serde::__private::None;
699 while let _serde::__private::Some(__key) = {
700 __A::next_key::<__Field>(&mut __map)?
701 } {
702 match __key {
703 __Field::m_activeTransitions => {
704 #[cfg(
705 any(feature = "strict", feature = "ignore_duplicates")
706 )]
707 if _serde::__private::Option::is_some(
708 &m_activeTransitions,
709 ) {
710 #[cfg(feature = "ignore_duplicates")]
711 {
712 __A::skip_value(&mut __map)?;
713 continue;
714 }
715 #[cfg(feature = "strict")]
716 return _serde::__private::Err(
717 <__A::Error as _serde::de::Error>::duplicate_field(
718 "activeTransitions",
719 ),
720 );
721 }
722 m_activeTransitions = _serde::__private::Some(
723 match __A::next_value::<
724 Vec<hkbStateMachineActiveTransitionInfo>,
725 >(&mut __map) {
726 _serde::__private::Ok(__val) => __val,
727 _serde::__private::Err(__err) => {
728 return _serde::__private::Err(__err);
729 }
730 },
731 );
732 }
733 __Field::m_transitionFlags => {
734 #[cfg(
735 any(feature = "strict", feature = "ignore_duplicates")
736 )]
737 if _serde::__private::Option::is_some(&m_transitionFlags) {
738 #[cfg(feature = "ignore_duplicates")]
739 {
740 __A::skip_value(&mut __map)?;
741 continue;
742 }
743 #[cfg(feature = "strict")]
744 return _serde::__private::Err(
745 <__A::Error as _serde::de::Error>::duplicate_field(
746 "transitionFlags",
747 ),
748 );
749 }
750 m_transitionFlags = _serde::__private::Some(
751 match __A::next_value::<Vec<u8>>(&mut __map) {
752 _serde::__private::Ok(__val) => __val,
753 _serde::__private::Err(__err) => {
754 return _serde::__private::Err(__err);
755 }
756 },
757 );
758 }
759 __Field::m_wildcardTransitionFlags => {
760 #[cfg(
761 any(feature = "strict", feature = "ignore_duplicates")
762 )]
763 if _serde::__private::Option::is_some(
764 &m_wildcardTransitionFlags,
765 ) {
766 #[cfg(feature = "ignore_duplicates")]
767 {
768 __A::skip_value(&mut __map)?;
769 continue;
770 }
771 #[cfg(feature = "strict")]
772 return _serde::__private::Err(
773 <__A::Error as _serde::de::Error>::duplicate_field(
774 "wildcardTransitionFlags",
775 ),
776 );
777 }
778 m_wildcardTransitionFlags = _serde::__private::Some(
779 match __A::next_value::<Vec<u8>>(&mut __map) {
780 _serde::__private::Ok(__val) => __val,
781 _serde::__private::Err(__err) => {
782 return _serde::__private::Err(__err);
783 }
784 },
785 );
786 }
787 __Field::m_delayedTransitions => {
788 #[cfg(
789 any(feature = "strict", feature = "ignore_duplicates")
790 )]
791 if _serde::__private::Option::is_some(
792 &m_delayedTransitions,
793 ) {
794 #[cfg(feature = "ignore_duplicates")]
795 {
796 __A::skip_value(&mut __map)?;
797 continue;
798 }
799 #[cfg(feature = "strict")]
800 return _serde::__private::Err(
801 <__A::Error as _serde::de::Error>::duplicate_field(
802 "delayedTransitions",
803 ),
804 );
805 }
806 m_delayedTransitions = _serde::__private::Some(
807 match __A::next_value::<
808 Vec<hkbStateMachineDelayedTransitionInfo>,
809 >(&mut __map) {
810 _serde::__private::Ok(__val) => __val,
811 _serde::__private::Err(__err) => {
812 return _serde::__private::Err(__err);
813 }
814 },
815 );
816 }
817 __Field::m_timeInState => {
818 #[cfg(
819 any(feature = "strict", feature = "ignore_duplicates")
820 )]
821 if _serde::__private::Option::is_some(&m_timeInState) {
822 #[cfg(feature = "ignore_duplicates")]
823 {
824 __A::skip_value(&mut __map)?;
825 continue;
826 }
827 #[cfg(feature = "strict")]
828 return _serde::__private::Err(
829 <__A::Error as _serde::de::Error>::duplicate_field(
830 "timeInState",
831 ),
832 );
833 }
834 m_timeInState = _serde::__private::Some(
835 match __A::next_value::<f32>(&mut __map) {
836 _serde::__private::Ok(__val) => __val,
837 _serde::__private::Err(__err) => {
838 return _serde::__private::Err(__err);
839 }
840 },
841 );
842 }
843 __Field::m_lastLocalTime => {
844 #[cfg(
845 any(feature = "strict", feature = "ignore_duplicates")
846 )]
847 if _serde::__private::Option::is_some(&m_lastLocalTime) {
848 #[cfg(feature = "ignore_duplicates")]
849 {
850 __A::skip_value(&mut __map)?;
851 continue;
852 }
853 #[cfg(feature = "strict")]
854 return _serde::__private::Err(
855 <__A::Error as _serde::de::Error>::duplicate_field(
856 "lastLocalTime",
857 ),
858 );
859 }
860 m_lastLocalTime = _serde::__private::Some(
861 match __A::next_value::<f32>(&mut __map) {
862 _serde::__private::Ok(__val) => __val,
863 _serde::__private::Err(__err) => {
864 return _serde::__private::Err(__err);
865 }
866 },
867 );
868 }
869 __Field::m_currentStateId => {
870 #[cfg(
871 any(feature = "strict", feature = "ignore_duplicates")
872 )]
873 if _serde::__private::Option::is_some(&m_currentStateId) {
874 #[cfg(feature = "ignore_duplicates")]
875 {
876 __A::skip_value(&mut __map)?;
877 continue;
878 }
879 #[cfg(feature = "strict")]
880 return _serde::__private::Err(
881 <__A::Error as _serde::de::Error>::duplicate_field(
882 "currentStateId",
883 ),
884 );
885 }
886 m_currentStateId = _serde::__private::Some(
887 match __A::next_value::<i32>(&mut __map) {
888 _serde::__private::Ok(__val) => __val,
889 _serde::__private::Err(__err) => {
890 return _serde::__private::Err(__err);
891 }
892 },
893 );
894 }
895 __Field::m_previousStateId => {
896 #[cfg(
897 any(feature = "strict", feature = "ignore_duplicates")
898 )]
899 if _serde::__private::Option::is_some(&m_previousStateId) {
900 #[cfg(feature = "ignore_duplicates")]
901 {
902 __A::skip_value(&mut __map)?;
903 continue;
904 }
905 #[cfg(feature = "strict")]
906 return _serde::__private::Err(
907 <__A::Error as _serde::de::Error>::duplicate_field(
908 "previousStateId",
909 ),
910 );
911 }
912 m_previousStateId = _serde::__private::Some(
913 match __A::next_value::<i32>(&mut __map) {
914 _serde::__private::Ok(__val) => __val,
915 _serde::__private::Err(__err) => {
916 return _serde::__private::Err(__err);
917 }
918 },
919 );
920 }
921 __Field::m_nextStartStateIndexOverride => {
922 #[cfg(
923 any(feature = "strict", feature = "ignore_duplicates")
924 )]
925 if _serde::__private::Option::is_some(
926 &m_nextStartStateIndexOverride,
927 ) {
928 #[cfg(feature = "ignore_duplicates")]
929 {
930 __A::skip_value(&mut __map)?;
931 continue;
932 }
933 #[cfg(feature = "strict")]
934 return _serde::__private::Err(
935 <__A::Error as _serde::de::Error>::duplicate_field(
936 "nextStartStateIndexOverride",
937 ),
938 );
939 }
940 m_nextStartStateIndexOverride = _serde::__private::Some(
941 match __A::next_value::<i32>(&mut __map) {
942 _serde::__private::Ok(__val) => __val,
943 _serde::__private::Err(__err) => {
944 return _serde::__private::Err(__err);
945 }
946 },
947 );
948 }
949 __Field::m_stateOrTransitionChanged => {
950 #[cfg(
951 any(feature = "strict", feature = "ignore_duplicates")
952 )]
953 if _serde::__private::Option::is_some(
954 &m_stateOrTransitionChanged,
955 ) {
956 #[cfg(feature = "ignore_duplicates")]
957 {
958 __A::skip_value(&mut __map)?;
959 continue;
960 }
961 #[cfg(feature = "strict")]
962 return _serde::__private::Err(
963 <__A::Error as _serde::de::Error>::duplicate_field(
964 "stateOrTransitionChanged",
965 ),
966 );
967 }
968 m_stateOrTransitionChanged = _serde::__private::Some(
969 match __A::next_value::<bool>(&mut __map) {
970 _serde::__private::Ok(__val) => __val,
971 _serde::__private::Err(__err) => {
972 return _serde::__private::Err(__err);
973 }
974 },
975 );
976 }
977 __Field::m_echoNextUpdate => {
978 #[cfg(
979 any(feature = "strict", feature = "ignore_duplicates")
980 )]
981 if _serde::__private::Option::is_some(&m_echoNextUpdate) {
982 #[cfg(feature = "ignore_duplicates")]
983 {
984 __A::skip_value(&mut __map)?;
985 continue;
986 }
987 #[cfg(feature = "strict")]
988 return _serde::__private::Err(
989 <__A::Error as _serde::de::Error>::duplicate_field(
990 "echoNextUpdate",
991 ),
992 );
993 }
994 m_echoNextUpdate = _serde::__private::Some(
995 match __A::next_value::<bool>(&mut __map) {
996 _serde::__private::Ok(__val) => __val,
997 _serde::__private::Err(__err) => {
998 return _serde::__private::Err(__err);
999 }
1000 },
1001 );
1002 }
1003 _ => __A::skip_value(&mut __map)?,
1004 }
1005 }
1006 let m_activeTransitions = match m_activeTransitions {
1007 _serde::__private::Some(__field) => __field,
1008 _serde::__private::None => {
1009 #[cfg(feature = "strict")]
1010 return _serde::__private::Err(
1011 <__A::Error as _serde::de::Error>::missing_field(
1012 "activeTransitions",
1013 ),
1014 );
1015 #[cfg(not(feature = "strict"))] Default::default()
1016 }
1017 };
1018 let m_transitionFlags = match m_transitionFlags {
1019 _serde::__private::Some(__field) => __field,
1020 _serde::__private::None => {
1021 #[cfg(feature = "strict")]
1022 return _serde::__private::Err(
1023 <__A::Error as _serde::de::Error>::missing_field(
1024 "transitionFlags",
1025 ),
1026 );
1027 #[cfg(not(feature = "strict"))] Default::default()
1028 }
1029 };
1030 let m_wildcardTransitionFlags = match m_wildcardTransitionFlags {
1031 _serde::__private::Some(__field) => __field,
1032 _serde::__private::None => {
1033 #[cfg(feature = "strict")]
1034 return _serde::__private::Err(
1035 <__A::Error as _serde::de::Error>::missing_field(
1036 "wildcardTransitionFlags",
1037 ),
1038 );
1039 #[cfg(not(feature = "strict"))] Default::default()
1040 }
1041 };
1042 let m_delayedTransitions = match m_delayedTransitions {
1043 _serde::__private::Some(__field) => __field,
1044 _serde::__private::None => {
1045 #[cfg(feature = "strict")]
1046 return _serde::__private::Err(
1047 <__A::Error as _serde::de::Error>::missing_field(
1048 "delayedTransitions",
1049 ),
1050 );
1051 #[cfg(not(feature = "strict"))] Default::default()
1052 }
1053 };
1054 let m_timeInState = match m_timeInState {
1055 _serde::__private::Some(__field) => __field,
1056 _serde::__private::None => {
1057 #[cfg(feature = "strict")]
1058 return _serde::__private::Err(
1059 <__A::Error as _serde::de::Error>::missing_field(
1060 "timeInState",
1061 ),
1062 );
1063 #[cfg(not(feature = "strict"))] Default::default()
1064 }
1065 };
1066 let m_lastLocalTime = match m_lastLocalTime {
1067 _serde::__private::Some(__field) => __field,
1068 _serde::__private::None => {
1069 #[cfg(feature = "strict")]
1070 return _serde::__private::Err(
1071 <__A::Error as _serde::de::Error>::missing_field(
1072 "lastLocalTime",
1073 ),
1074 );
1075 #[cfg(not(feature = "strict"))] Default::default()
1076 }
1077 };
1078 let m_currentStateId = match m_currentStateId {
1079 _serde::__private::Some(__field) => __field,
1080 _serde::__private::None => {
1081 #[cfg(feature = "strict")]
1082 return _serde::__private::Err(
1083 <__A::Error as _serde::de::Error>::missing_field(
1084 "currentStateId",
1085 ),
1086 );
1087 #[cfg(not(feature = "strict"))] Default::default()
1088 }
1089 };
1090 let m_previousStateId = match m_previousStateId {
1091 _serde::__private::Some(__field) => __field,
1092 _serde::__private::None => {
1093 #[cfg(feature = "strict")]
1094 return _serde::__private::Err(
1095 <__A::Error as _serde::de::Error>::missing_field(
1096 "previousStateId",
1097 ),
1098 );
1099 #[cfg(not(feature = "strict"))] Default::default()
1100 }
1101 };
1102 let m_nextStartStateIndexOverride = match m_nextStartStateIndexOverride {
1103 _serde::__private::Some(__field) => __field,
1104 _serde::__private::None => {
1105 #[cfg(feature = "strict")]
1106 return _serde::__private::Err(
1107 <__A::Error as _serde::de::Error>::missing_field(
1108 "nextStartStateIndexOverride",
1109 ),
1110 );
1111 #[cfg(not(feature = "strict"))] Default::default()
1112 }
1113 };
1114 let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
1115 _serde::__private::Some(__field) => __field,
1116 _serde::__private::None => {
1117 #[cfg(feature = "strict")]
1118 return _serde::__private::Err(
1119 <__A::Error as _serde::de::Error>::missing_field(
1120 "stateOrTransitionChanged",
1121 ),
1122 );
1123 #[cfg(not(feature = "strict"))] Default::default()
1124 }
1125 };
1126 let m_echoNextUpdate = match m_echoNextUpdate {
1127 _serde::__private::Some(__field) => __field,
1128 _serde::__private::None => {
1129 #[cfg(feature = "strict")]
1130 return _serde::__private::Err(
1131 <__A::Error as _serde::de::Error>::missing_field(
1132 "echoNextUpdate",
1133 ),
1134 );
1135 #[cfg(not(feature = "strict"))] Default::default()
1136 }
1137 };
1138 let __ptr = None;
1139 let parent = hkBaseObject { __ptr };
1140 let parent = hkReferencedObject {
1141 __ptr,
1142 parent,
1143 ..Default::default()
1144 };
1145 let __ptr = __A::class_ptr(&mut __map);
1146 _serde::__private::Ok(hkbStateMachineInternalState {
1147 __ptr,
1148 parent,
1149 m_activeTransitions,
1150 m_transitionFlags,
1151 m_wildcardTransitionFlags,
1152 m_delayedTransitions,
1153 m_timeInState,
1154 m_lastLocalTime,
1155 m_currentStateId,
1156 m_previousStateId,
1157 m_nextStartStateIndexOverride,
1158 m_stateOrTransitionChanged,
1159 m_echoNextUpdate,
1160 })
1161 }
1162 }
1163 const FIELDS: &[&str] = &[
1164 "activeTransitions",
1165 "transitionFlags",
1166 "wildcardTransitionFlags",
1167 "delayedTransitions",
1168 "timeInState",
1169 "lastLocalTime",
1170 "currentStateId",
1171 "previousStateId",
1172 "nextStartStateIndexOverride",
1173 "stateOrTransitionChanged",
1174 "echoNextUpdate",
1175 ];
1176 _serde::Deserializer::deserialize_struct(
1177 deserializer,
1178 "hkbStateMachineInternalState",
1179 FIELDS,
1180 __hkbStateMachineInternalStateVisitor {
1181 marker: _serde::__private::PhantomData::<
1182 hkbStateMachineInternalState,
1183 >,
1184 lifetime: _serde::__private::PhantomData,
1185 },
1186 )
1187 }
1188 }
1189};