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 hkbStateMachine<'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(
36 feature = "json_schema",
37 schemars(rename = "eventToSendWhenStateOrTransitionChanges")
38 )]
39 #[cfg_attr(
40 feature = "serde",
41 serde(rename = "eventToSendWhenStateOrTransitionChanges")
42 )]
43 pub m_eventToSendWhenStateOrTransitionChanges: hkbEvent,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "startStateChooser"))]
49 #[cfg_attr(feature = "serde", serde(rename = "startStateChooser"))]
50 pub m_startStateChooser: Pointer,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "startStateId"))]
56 #[cfg_attr(feature = "serde", serde(rename = "startStateId"))]
57 pub m_startStateId: i32,
58 #[cfg_attr(
63 feature = "json_schema",
64 schemars(rename = "returnToPreviousStateEventId")
65 )]
66 #[cfg_attr(feature = "serde", serde(rename = "returnToPreviousStateEventId"))]
67 pub m_returnToPreviousStateEventId: i32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "randomTransitionEventId"))]
73 #[cfg_attr(feature = "serde", serde(rename = "randomTransitionEventId"))]
74 pub m_randomTransitionEventId: i32,
75 #[cfg_attr(
80 feature = "json_schema",
81 schemars(rename = "transitionToNextHigherStateEventId")
82 )]
83 #[cfg_attr(feature = "serde", serde(rename = "transitionToNextHigherStateEventId"))]
84 pub m_transitionToNextHigherStateEventId: i32,
85 #[cfg_attr(
90 feature = "json_schema",
91 schemars(rename = "transitionToNextLowerStateEventId")
92 )]
93 #[cfg_attr(feature = "serde", serde(rename = "transitionToNextLowerStateEventId"))]
94 pub m_transitionToNextLowerStateEventId: i32,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "syncVariableIndex"))]
100 #[cfg_attr(feature = "serde", serde(rename = "syncVariableIndex"))]
101 pub m_syncVariableIndex: i32,
102 #[cfg_attr(feature = "json_schema", schemars(rename = "currentStateId"))]
108 #[cfg_attr(feature = "serde", serde(rename = "currentStateId"))]
109 pub m_currentStateId: i32,
110 #[cfg_attr(feature = "json_schema", schemars(rename = "wrapAroundStateId"))]
115 #[cfg_attr(feature = "serde", serde(rename = "wrapAroundStateId"))]
116 pub m_wrapAroundStateId: bool,
117 #[cfg_attr(feature = "json_schema", schemars(rename = "maxSimultaneousTransitions"))]
122 #[cfg_attr(feature = "serde", serde(rename = "maxSimultaneousTransitions"))]
123 pub m_maxSimultaneousTransitions: i8,
124 #[cfg_attr(feature = "json_schema", schemars(rename = "startStateMode"))]
129 #[cfg_attr(feature = "serde", serde(rename = "startStateMode"))]
130 pub m_startStateMode: StartStateMode,
131 #[cfg_attr(feature = "json_schema", schemars(rename = "selfTransitionMode"))]
136 #[cfg_attr(feature = "serde", serde(rename = "selfTransitionMode"))]
137 pub m_selfTransitionMode: StateMachineSelfTransitionMode,
138 #[cfg_attr(feature = "json_schema", schemars(rename = "isActive"))]
144 #[cfg_attr(feature = "serde", serde(rename = "isActive"))]
145 pub m_isActive: bool,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "states"))]
151 #[cfg_attr(feature = "serde", serde(rename = "states"))]
152 pub m_states: Vec<Pointer>,
153 #[cfg_attr(feature = "json_schema", schemars(rename = "wildcardTransitions"))]
158 #[cfg_attr(feature = "serde", serde(rename = "wildcardTransitions"))]
159 pub m_wildcardTransitions: Pointer,
160 #[cfg_attr(feature = "json_schema", schemars(rename = "stateIdToIndexMap"))]
166 #[cfg_attr(feature = "serde", serde(rename = "stateIdToIndexMap"))]
167 pub m_stateIdToIndexMap: Pointer,
168 #[cfg_attr(feature = "json_schema", schemars(rename = "activeTransitions"))]
174 #[cfg_attr(feature = "serde", serde(rename = "activeTransitions"))]
175 pub m_activeTransitions: Vec<()>,
176 #[cfg_attr(feature = "json_schema", schemars(rename = "transitionFlags"))]
182 #[cfg_attr(feature = "serde", serde(rename = "transitionFlags"))]
183 pub m_transitionFlags: Vec<()>,
184 #[cfg_attr(feature = "json_schema", schemars(rename = "wildcardTransitionFlags"))]
190 #[cfg_attr(feature = "serde", serde(rename = "wildcardTransitionFlags"))]
191 pub m_wildcardTransitionFlags: Vec<()>,
192 #[cfg_attr(feature = "json_schema", schemars(rename = "delayedTransitions"))]
198 #[cfg_attr(feature = "serde", serde(rename = "delayedTransitions"))]
199 pub m_delayedTransitions: Vec<()>,
200 #[cfg_attr(feature = "json_schema", schemars(rename = "timeInState"))]
206 #[cfg_attr(feature = "serde", serde(rename = "timeInState"))]
207 pub m_timeInState: f32,
208 #[cfg_attr(feature = "json_schema", schemars(rename = "lastLocalTime"))]
214 #[cfg_attr(feature = "serde", serde(rename = "lastLocalTime"))]
215 pub m_lastLocalTime: f32,
216 #[cfg_attr(feature = "json_schema", schemars(rename = "previousStateId"))]
222 #[cfg_attr(feature = "serde", serde(rename = "previousStateId"))]
223 pub m_previousStateId: i32,
224 #[cfg_attr(
230 feature = "json_schema",
231 schemars(rename = "nextStartStateIndexOverride")
232 )]
233 #[cfg_attr(feature = "serde", serde(rename = "nextStartStateIndexOverride"))]
234 pub m_nextStartStateIndexOverride: i32,
235 #[cfg_attr(feature = "json_schema", schemars(rename = "stateOrTransitionChanged"))]
241 #[cfg_attr(feature = "serde", serde(rename = "stateOrTransitionChanged"))]
242 pub m_stateOrTransitionChanged: bool,
243 #[cfg_attr(feature = "json_schema", schemars(rename = "echoNextUpdate"))]
249 #[cfg_attr(feature = "serde", serde(rename = "echoNextUpdate"))]
250 pub m_echoNextUpdate: bool,
251 #[cfg_attr(
257 feature = "json_schema",
258 schemars(rename = "sCurrentStateIndexAndEntered")
259 )]
260 #[cfg_attr(feature = "serde", serde(rename = "sCurrentStateIndexAndEntered"))]
261 pub m_sCurrentStateIndexAndEntered: u16,
262}
263const _: () = {
264 use havok_serde as _serde;
265 impl<'a> _serde::HavokClass for hkbStateMachine<'a> {
266 #[inline]
267 fn name(&self) -> &'static str {
268 "hkbStateMachine"
269 }
270 #[inline]
271 fn signature(&self) -> _serde::__private::Signature {
272 _serde::__private::Signature::new(0x816c1dcb)
273 }
274 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
275 fn deps_indexes(&self) -> Vec<usize> {
276 let mut v = Vec::new();
277 v.push(self.parent.parent.parent.m_variableBindingSet.get());
278 v.extend(self.m_eventToSendWhenStateOrTransitionChanges.deps_indexes());
279 v.push(self.m_startStateChooser.get());
280 v.extend(self.m_states.iter().map(|ptr| ptr.get()));
281 v.push(self.m_wildcardTransitions.get());
282 v.push(self.m_stateIdToIndexMap.get());
283 v
284 }
285 }
286 impl<'a> _serde::Serialize for hkbStateMachine<'a> {
287 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
288 where
289 S: _serde::ser::Serializer,
290 {
291 let class_meta = self
292 .__ptr
293 .map(|name| (name, _serde::__private::Signature::new(0x816c1dcb)));
294 let mut serializer = __serializer
295 .serialize_struct("hkbStateMachine", class_meta, (180u64, 264u64))?;
296 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
297 serializer
298 .skip_field(
299 "memSizeAndFlags",
300 &self.parent.parent.parent.parent.m_memSizeAndFlags,
301 )?;
302 serializer
303 .skip_field(
304 "referenceCount",
305 &self.parent.parent.parent.parent.m_referenceCount,
306 )?;
307 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
308 serializer
309 .serialize_field(
310 "variableBindingSet",
311 &self.parent.parent.parent.m_variableBindingSet,
312 )?;
313 serializer
314 .skip_array_field(
315 "cachedBindables",
316 &self.parent.parent.parent.m_cachedBindables,
317 TypeSize::NonPtr,
318 )?;
319 serializer
320 .skip_field(
321 "areBindablesCached",
322 &self.parent.parent.parent.m_areBindablesCached,
323 )?;
324 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
325 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
326 serializer.serialize_field("name", &self.parent.parent.m_name)?;
327 serializer.skip_field("id", &self.parent.parent.m_id)?;
328 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
329 serializer
330 .skip_fixed_array_field(
331 "padNode",
332 self.parent.parent.m_padNode.as_slice(),
333 TypeSize::NonPtr,
334 )?;
335 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
336 serializer
337 .serialize_field(
338 "eventToSendWhenStateOrTransitionChanges",
339 &self.m_eventToSendWhenStateOrTransitionChanges,
340 )?;
341 serializer.serialize_field("startStateChooser", &self.m_startStateChooser)?;
342 serializer.serialize_field("startStateId", &self.m_startStateId)?;
343 serializer
344 .serialize_field(
345 "returnToPreviousStateEventId",
346 &self.m_returnToPreviousStateEventId,
347 )?;
348 serializer
349 .serialize_field(
350 "randomTransitionEventId",
351 &self.m_randomTransitionEventId,
352 )?;
353 serializer
354 .serialize_field(
355 "transitionToNextHigherStateEventId",
356 &self.m_transitionToNextHigherStateEventId,
357 )?;
358 serializer
359 .serialize_field(
360 "transitionToNextLowerStateEventId",
361 &self.m_transitionToNextLowerStateEventId,
362 )?;
363 serializer.serialize_field("syncVariableIndex", &self.m_syncVariableIndex)?;
364 serializer.skip_field("currentStateId", &self.m_currentStateId)?;
365 serializer.serialize_field("wrapAroundStateId", &self.m_wrapAroundStateId)?;
366 serializer
367 .serialize_field(
368 "maxSimultaneousTransitions",
369 &self.m_maxSimultaneousTransitions,
370 )?;
371 serializer.serialize_field("startStateMode", &self.m_startStateMode)?;
372 serializer
373 .serialize_field("selfTransitionMode", &self.m_selfTransitionMode)?;
374 serializer.skip_field("isActive", &self.m_isActive)?;
375 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
376 serializer
377 .serialize_array_field("states", &self.m_states, TypeSize::NonPtr)?;
378 serializer
379 .serialize_field("wildcardTransitions", &self.m_wildcardTransitions)?;
380 serializer.skip_field("stateIdToIndexMap", &self.m_stateIdToIndexMap)?;
381 serializer
382 .skip_array_field(
383 "activeTransitions",
384 &self.m_activeTransitions,
385 TypeSize::NonPtr,
386 )?;
387 serializer
388 .skip_array_field(
389 "transitionFlags",
390 &self.m_transitionFlags,
391 TypeSize::NonPtr,
392 )?;
393 serializer
394 .skip_array_field(
395 "wildcardTransitionFlags",
396 &self.m_wildcardTransitionFlags,
397 TypeSize::NonPtr,
398 )?;
399 serializer
400 .skip_array_field(
401 "delayedTransitions",
402 &self.m_delayedTransitions,
403 TypeSize::NonPtr,
404 )?;
405 serializer.skip_field("timeInState", &self.m_timeInState)?;
406 serializer.skip_field("lastLocalTime", &self.m_lastLocalTime)?;
407 serializer.skip_field("previousStateId", &self.m_previousStateId)?;
408 serializer
409 .skip_field(
410 "nextStartStateIndexOverride",
411 &self.m_nextStartStateIndexOverride,
412 )?;
413 serializer
414 .skip_field(
415 "stateOrTransitionChanged",
416 &self.m_stateOrTransitionChanged,
417 )?;
418 serializer.skip_field("echoNextUpdate", &self.m_echoNextUpdate)?;
419 serializer
420 .skip_field(
421 "sCurrentStateIndexAndEntered",
422 &self.m_sCurrentStateIndexAndEntered,
423 )?;
424 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
425 serializer.end()
426 }
427 }
428};
429#[doc(hidden)]
430#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
431const _: () = {
432 use havok_serde as _serde;
433 #[automatically_derived]
434 impl<'de> _serde::Deserialize<'de> for hkbStateMachine<'de> {
435 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
436 where
437 __D: _serde::Deserializer<'de>,
438 {
439 #[allow(non_camel_case_types)]
440 enum __Field {
441 m_variableBindingSet,
442 m_userData,
443 m_name,
444 m_eventToSendWhenStateOrTransitionChanges,
445 m_startStateChooser,
446 m_startStateId,
447 m_returnToPreviousStateEventId,
448 m_randomTransitionEventId,
449 m_transitionToNextHigherStateEventId,
450 m_transitionToNextLowerStateEventId,
451 m_syncVariableIndex,
452 m_wrapAroundStateId,
453 m_maxSimultaneousTransitions,
454 m_startStateMode,
455 m_selfTransitionMode,
456 m_states,
457 m_wildcardTransitions,
458 __ignore,
459 }
460 struct __FieldVisitor;
461 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
462 type Value = __Field;
463 fn expecting(
464 &self,
465 __formatter: &mut core::fmt::Formatter,
466 ) -> core::fmt::Result {
467 core::fmt::Formatter::write_str(__formatter, "field identifier")
468 }
469 #[allow(clippy::match_single_binding)]
471 #[allow(clippy::reversed_empty_ranges)]
472 #[allow(clippy::single_match)]
473 fn visit_key<__E>(
474 self,
475 __value: &str,
476 ) -> core::result::Result<Self::Value, __E>
477 where
478 __E: _serde::de::Error,
479 {
480 match __value {
481 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
482 "userData" => Ok(__Field::m_userData),
483 "name" => Ok(__Field::m_name),
484 "eventToSendWhenStateOrTransitionChanges" => {
485 Ok(__Field::m_eventToSendWhenStateOrTransitionChanges)
486 }
487 "startStateChooser" => Ok(__Field::m_startStateChooser),
488 "startStateId" => Ok(__Field::m_startStateId),
489 "returnToPreviousStateEventId" => {
490 Ok(__Field::m_returnToPreviousStateEventId)
491 }
492 "randomTransitionEventId" => {
493 Ok(__Field::m_randomTransitionEventId)
494 }
495 "transitionToNextHigherStateEventId" => {
496 Ok(__Field::m_transitionToNextHigherStateEventId)
497 }
498 "transitionToNextLowerStateEventId" => {
499 Ok(__Field::m_transitionToNextLowerStateEventId)
500 }
501 "syncVariableIndex" => Ok(__Field::m_syncVariableIndex),
502 "wrapAroundStateId" => Ok(__Field::m_wrapAroundStateId),
503 "maxSimultaneousTransitions" => {
504 Ok(__Field::m_maxSimultaneousTransitions)
505 }
506 "startStateMode" => Ok(__Field::m_startStateMode),
507 "selfTransitionMode" => Ok(__Field::m_selfTransitionMode),
508 "states" => Ok(__Field::m_states),
509 "wildcardTransitions" => Ok(__Field::m_wildcardTransitions),
510 _ => Ok(__Field::__ignore),
511 }
512 }
513 }
514 impl<'de> _serde::Deserialize<'de> for __Field {
515 #[inline]
516 fn deserialize<__D>(
517 __deserializer: __D,
518 ) -> core::result::Result<Self, __D::Error>
519 where
520 __D: _serde::Deserializer<'de>,
521 {
522 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
523 }
524 }
525 struct __hkbStateMachineVisitor<'de> {
526 marker: _serde::__private::PhantomData<hkbStateMachine<'de>>,
527 lifetime: _serde::__private::PhantomData<&'de ()>,
528 }
529 #[allow(clippy::match_single_binding)]
530 #[allow(clippy::reversed_empty_ranges)]
531 #[allow(clippy::single_match)]
532 impl<'de> _serde::de::Visitor<'de> for __hkbStateMachineVisitor<'de> {
533 type Value = hkbStateMachine<'de>;
534 fn expecting(
535 &self,
536 __formatter: &mut core::fmt::Formatter,
537 ) -> core::fmt::Result {
538 core::fmt::Formatter::write_str(
539 __formatter,
540 "struct hkbStateMachine",
541 )
542 }
543 fn visit_struct_for_bytes<__A>(
544 self,
545 mut __map: __A,
546 ) -> _serde::__private::Result<Self::Value, __A::Error>
547 where
548 __A: _serde::de::MapAccess<'de>,
549 {
550 let __ptr = __A::class_ptr(&mut __map);
551 let parent = __A::parent_value(&mut __map)?;
552 let mut m_eventToSendWhenStateOrTransitionChanges: _serde::__private::Option<
553 hkbEvent,
554 > = _serde::__private::None;
555 let mut m_startStateChooser: _serde::__private::Option<Pointer> = _serde::__private::None;
556 let mut m_startStateId: _serde::__private::Option<i32> = _serde::__private::None;
557 let mut m_returnToPreviousStateEventId: _serde::__private::Option<
558 i32,
559 > = _serde::__private::None;
560 let mut m_randomTransitionEventId: _serde::__private::Option<i32> = _serde::__private::None;
561 let mut m_transitionToNextHigherStateEventId: _serde::__private::Option<
562 i32,
563 > = _serde::__private::None;
564 let mut m_transitionToNextLowerStateEventId: _serde::__private::Option<
565 i32,
566 > = _serde::__private::None;
567 let mut m_syncVariableIndex: _serde::__private::Option<i32> = _serde::__private::None;
568 let mut m_currentStateId: _serde::__private::Option<i32> = _serde::__private::None;
569 let mut m_wrapAroundStateId: _serde::__private::Option<bool> = _serde::__private::None;
570 let mut m_maxSimultaneousTransitions: _serde::__private::Option<
571 i8,
572 > = _serde::__private::None;
573 let mut m_startStateMode: _serde::__private::Option<
574 StartStateMode,
575 > = _serde::__private::None;
576 let mut m_selfTransitionMode: _serde::__private::Option<
577 StateMachineSelfTransitionMode,
578 > = _serde::__private::None;
579 let mut m_isActive: _serde::__private::Option<bool> = _serde::__private::None;
580 let mut m_states: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
581 let mut m_wildcardTransitions: _serde::__private::Option<Pointer> = _serde::__private::None;
582 let mut m_stateIdToIndexMap: _serde::__private::Option<Pointer> = _serde::__private::None;
583 let mut m_activeTransitions: _serde::__private::Option<Vec<()>> = _serde::__private::None;
584 let mut m_transitionFlags: _serde::__private::Option<Vec<()>> = _serde::__private::None;
585 let mut m_wildcardTransitionFlags: _serde::__private::Option<
586 Vec<()>,
587 > = _serde::__private::None;
588 let mut m_delayedTransitions: _serde::__private::Option<Vec<()>> = _serde::__private::None;
589 let mut m_timeInState: _serde::__private::Option<f32> = _serde::__private::None;
590 let mut m_lastLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
591 let mut m_previousStateId: _serde::__private::Option<i32> = _serde::__private::None;
592 let mut m_nextStartStateIndexOverride: _serde::__private::Option<
593 i32,
594 > = _serde::__private::None;
595 let mut m_stateOrTransitionChanged: _serde::__private::Option<
596 bool,
597 > = _serde::__private::None;
598 let mut m_echoNextUpdate: _serde::__private::Option<bool> = _serde::__private::None;
599 let mut m_sCurrentStateIndexAndEntered: _serde::__private::Option<
600 u16,
601 > = _serde::__private::None;
602 for i in 0..28usize {
603 match i {
604 0usize => {
605 if _serde::__private::Option::is_some(
606 &m_eventToSendWhenStateOrTransitionChanges,
607 ) {
608 return _serde::__private::Err(
609 <__A::Error as _serde::de::Error>::duplicate_field(
610 "eventToSendWhenStateOrTransitionChanges",
611 ),
612 );
613 }
614 m_eventToSendWhenStateOrTransitionChanges = _serde::__private::Some(
615 match __A::next_value::<hkbEvent>(&mut __map) {
616 _serde::__private::Ok(__val) => __val,
617 _serde::__private::Err(__err) => {
618 return _serde::__private::Err(__err);
619 }
620 },
621 );
622 }
623 1usize => {
624 if _serde::__private::Option::is_some(
625 &m_startStateChooser,
626 ) {
627 return _serde::__private::Err(
628 <__A::Error as _serde::de::Error>::duplicate_field(
629 "startStateChooser",
630 ),
631 );
632 }
633 m_startStateChooser = _serde::__private::Some(
634 match __A::next_value::<Pointer>(&mut __map) {
635 _serde::__private::Ok(__val) => __val,
636 _serde::__private::Err(__err) => {
637 return _serde::__private::Err(__err);
638 }
639 },
640 );
641 }
642 2usize => {
643 if _serde::__private::Option::is_some(&m_startStateId) {
644 return _serde::__private::Err(
645 <__A::Error as _serde::de::Error>::duplicate_field(
646 "startStateId",
647 ),
648 );
649 }
650 m_startStateId = _serde::__private::Some(
651 match __A::next_value::<i32>(&mut __map) {
652 _serde::__private::Ok(__val) => __val,
653 _serde::__private::Err(__err) => {
654 return _serde::__private::Err(__err);
655 }
656 },
657 );
658 }
659 3usize => {
660 if _serde::__private::Option::is_some(
661 &m_returnToPreviousStateEventId,
662 ) {
663 return _serde::__private::Err(
664 <__A::Error as _serde::de::Error>::duplicate_field(
665 "returnToPreviousStateEventId",
666 ),
667 );
668 }
669 m_returnToPreviousStateEventId = _serde::__private::Some(
670 match __A::next_value::<i32>(&mut __map) {
671 _serde::__private::Ok(__val) => __val,
672 _serde::__private::Err(__err) => {
673 return _serde::__private::Err(__err);
674 }
675 },
676 );
677 }
678 4usize => {
679 if _serde::__private::Option::is_some(
680 &m_randomTransitionEventId,
681 ) {
682 return _serde::__private::Err(
683 <__A::Error as _serde::de::Error>::duplicate_field(
684 "randomTransitionEventId",
685 ),
686 );
687 }
688 m_randomTransitionEventId = _serde::__private::Some(
689 match __A::next_value::<i32>(&mut __map) {
690 _serde::__private::Ok(__val) => __val,
691 _serde::__private::Err(__err) => {
692 return _serde::__private::Err(__err);
693 }
694 },
695 );
696 }
697 5usize => {
698 if _serde::__private::Option::is_some(
699 &m_transitionToNextHigherStateEventId,
700 ) {
701 return _serde::__private::Err(
702 <__A::Error as _serde::de::Error>::duplicate_field(
703 "transitionToNextHigherStateEventId",
704 ),
705 );
706 }
707 m_transitionToNextHigherStateEventId = _serde::__private::Some(
708 match __A::next_value::<i32>(&mut __map) {
709 _serde::__private::Ok(__val) => __val,
710 _serde::__private::Err(__err) => {
711 return _serde::__private::Err(__err);
712 }
713 },
714 );
715 }
716 6usize => {
717 if _serde::__private::Option::is_some(
718 &m_transitionToNextLowerStateEventId,
719 ) {
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::duplicate_field(
722 "transitionToNextLowerStateEventId",
723 ),
724 );
725 }
726 m_transitionToNextLowerStateEventId = _serde::__private::Some(
727 match __A::next_value::<i32>(&mut __map) {
728 _serde::__private::Ok(__val) => __val,
729 _serde::__private::Err(__err) => {
730 return _serde::__private::Err(__err);
731 }
732 },
733 );
734 }
735 7usize => {
736 if _serde::__private::Option::is_some(
737 &m_syncVariableIndex,
738 ) {
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::duplicate_field(
741 "syncVariableIndex",
742 ),
743 );
744 }
745 m_syncVariableIndex = _serde::__private::Some(
746 match __A::next_value::<i32>(&mut __map) {
747 _serde::__private::Ok(__val) => __val,
748 _serde::__private::Err(__err) => {
749 return _serde::__private::Err(__err);
750 }
751 },
752 );
753 }
754 8usize => {
755 if _serde::__private::Option::is_some(&m_currentStateId) {
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::duplicate_field(
758 "currentStateId",
759 ),
760 );
761 }
762 m_currentStateId = _serde::__private::Some(
763 match __A::next_value::<i32>(&mut __map) {
764 _serde::__private::Ok(__val) => __val,
765 _serde::__private::Err(__err) => {
766 return _serde::__private::Err(__err);
767 }
768 },
769 );
770 }
771 9usize => {
772 if _serde::__private::Option::is_some(
773 &m_wrapAroundStateId,
774 ) {
775 return _serde::__private::Err(
776 <__A::Error as _serde::de::Error>::duplicate_field(
777 "wrapAroundStateId",
778 ),
779 );
780 }
781 m_wrapAroundStateId = _serde::__private::Some(
782 match __A::next_value::<bool>(&mut __map) {
783 _serde::__private::Ok(__val) => __val,
784 _serde::__private::Err(__err) => {
785 return _serde::__private::Err(__err);
786 }
787 },
788 );
789 }
790 10usize => {
791 if _serde::__private::Option::is_some(
792 &m_maxSimultaneousTransitions,
793 ) {
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::duplicate_field(
796 "maxSimultaneousTransitions",
797 ),
798 );
799 }
800 m_maxSimultaneousTransitions = _serde::__private::Some(
801 match __A::next_value::<i8>(&mut __map) {
802 _serde::__private::Ok(__val) => __val,
803 _serde::__private::Err(__err) => {
804 return _serde::__private::Err(__err);
805 }
806 },
807 );
808 }
809 11usize => {
810 if _serde::__private::Option::is_some(&m_startStateMode) {
811 return _serde::__private::Err(
812 <__A::Error as _serde::de::Error>::duplicate_field(
813 "startStateMode",
814 ),
815 );
816 }
817 m_startStateMode = _serde::__private::Some(
818 match __A::next_value::<StartStateMode>(&mut __map) {
819 _serde::__private::Ok(__val) => __val,
820 _serde::__private::Err(__err) => {
821 return _serde::__private::Err(__err);
822 }
823 },
824 );
825 }
826 12usize => {
827 if _serde::__private::Option::is_some(
828 &m_selfTransitionMode,
829 ) {
830 return _serde::__private::Err(
831 <__A::Error as _serde::de::Error>::duplicate_field(
832 "selfTransitionMode",
833 ),
834 );
835 }
836 m_selfTransitionMode = _serde::__private::Some(
837 match __A::next_value::<
838 StateMachineSelfTransitionMode,
839 >(&mut __map) {
840 _serde::__private::Ok(__val) => __val,
841 _serde::__private::Err(__err) => {
842 return _serde::__private::Err(__err);
843 }
844 },
845 );
846 }
847 13usize => {
848 if _serde::__private::Option::is_some(&m_isActive) {
849 return _serde::__private::Err(
850 <__A::Error as _serde::de::Error>::duplicate_field(
851 "isActive",
852 ),
853 );
854 }
855 m_isActive = _serde::__private::Some(
856 match __A::next_value::<bool>(&mut __map) {
857 _serde::__private::Ok(__val) => __val,
858 _serde::__private::Err(__err) => {
859 return _serde::__private::Err(__err);
860 }
861 },
862 );
863 }
864 14usize => {
865 if _serde::__private::Option::is_some(&m_states) {
866 return _serde::__private::Err(
867 <__A::Error as _serde::de::Error>::duplicate_field("states"),
868 );
869 }
870 __A::pad(&mut __map, 3usize, 7usize)?;
871 m_states = _serde::__private::Some(
872 match __A::next_value::<Vec<Pointer>>(&mut __map) {
873 _serde::__private::Ok(__val) => __val,
874 _serde::__private::Err(__err) => {
875 return _serde::__private::Err(__err);
876 }
877 },
878 );
879 }
880 15usize => {
881 if _serde::__private::Option::is_some(
882 &m_wildcardTransitions,
883 ) {
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::duplicate_field(
886 "wildcardTransitions",
887 ),
888 );
889 }
890 m_wildcardTransitions = _serde::__private::Some(
891 match __A::next_value::<Pointer>(&mut __map) {
892 _serde::__private::Ok(__val) => __val,
893 _serde::__private::Err(__err) => {
894 return _serde::__private::Err(__err);
895 }
896 },
897 );
898 }
899 16usize => {
900 if _serde::__private::Option::is_some(
901 &m_stateIdToIndexMap,
902 ) {
903 return _serde::__private::Err(
904 <__A::Error as _serde::de::Error>::duplicate_field(
905 "stateIdToIndexMap",
906 ),
907 );
908 }
909 m_stateIdToIndexMap = _serde::__private::Some(
910 match __A::next_value::<Pointer>(&mut __map) {
911 _serde::__private::Ok(__val) => __val,
912 _serde::__private::Err(__err) => {
913 return _serde::__private::Err(__err);
914 }
915 },
916 );
917 }
918 17usize => {
919 if _serde::__private::Option::is_some(
920 &m_activeTransitions,
921 ) {
922 return _serde::__private::Err(
923 <__A::Error as _serde::de::Error>::duplicate_field(
924 "activeTransitions",
925 ),
926 );
927 }
928 m_activeTransitions = _serde::__private::Some(
929 match __A::next_value::<Vec<()>>(&mut __map) {
930 _serde::__private::Ok(__val) => __val,
931 _serde::__private::Err(__err) => {
932 return _serde::__private::Err(__err);
933 }
934 },
935 );
936 }
937 18usize => {
938 if _serde::__private::Option::is_some(&m_transitionFlags) {
939 return _serde::__private::Err(
940 <__A::Error as _serde::de::Error>::duplicate_field(
941 "transitionFlags",
942 ),
943 );
944 }
945 m_transitionFlags = _serde::__private::Some(
946 match __A::next_value::<Vec<()>>(&mut __map) {
947 _serde::__private::Ok(__val) => __val,
948 _serde::__private::Err(__err) => {
949 return _serde::__private::Err(__err);
950 }
951 },
952 );
953 }
954 19usize => {
955 if _serde::__private::Option::is_some(
956 &m_wildcardTransitionFlags,
957 ) {
958 return _serde::__private::Err(
959 <__A::Error as _serde::de::Error>::duplicate_field(
960 "wildcardTransitionFlags",
961 ),
962 );
963 }
964 m_wildcardTransitionFlags = _serde::__private::Some(
965 match __A::next_value::<Vec<()>>(&mut __map) {
966 _serde::__private::Ok(__val) => __val,
967 _serde::__private::Err(__err) => {
968 return _serde::__private::Err(__err);
969 }
970 },
971 );
972 }
973 20usize => {
974 if _serde::__private::Option::is_some(
975 &m_delayedTransitions,
976 ) {
977 return _serde::__private::Err(
978 <__A::Error as _serde::de::Error>::duplicate_field(
979 "delayedTransitions",
980 ),
981 );
982 }
983 m_delayedTransitions = _serde::__private::Some(
984 match __A::next_value::<Vec<()>>(&mut __map) {
985 _serde::__private::Ok(__val) => __val,
986 _serde::__private::Err(__err) => {
987 return _serde::__private::Err(__err);
988 }
989 },
990 );
991 }
992 21usize => {
993 if _serde::__private::Option::is_some(&m_timeInState) {
994 return _serde::__private::Err(
995 <__A::Error as _serde::de::Error>::duplicate_field(
996 "timeInState",
997 ),
998 );
999 }
1000 m_timeInState = _serde::__private::Some(
1001 match __A::next_value::<f32>(&mut __map) {
1002 _serde::__private::Ok(__val) => __val,
1003 _serde::__private::Err(__err) => {
1004 return _serde::__private::Err(__err);
1005 }
1006 },
1007 );
1008 }
1009 22usize => {
1010 if _serde::__private::Option::is_some(&m_lastLocalTime) {
1011 return _serde::__private::Err(
1012 <__A::Error as _serde::de::Error>::duplicate_field(
1013 "lastLocalTime",
1014 ),
1015 );
1016 }
1017 m_lastLocalTime = _serde::__private::Some(
1018 match __A::next_value::<f32>(&mut __map) {
1019 _serde::__private::Ok(__val) => __val,
1020 _serde::__private::Err(__err) => {
1021 return _serde::__private::Err(__err);
1022 }
1023 },
1024 );
1025 }
1026 23usize => {
1027 if _serde::__private::Option::is_some(&m_previousStateId) {
1028 return _serde::__private::Err(
1029 <__A::Error as _serde::de::Error>::duplicate_field(
1030 "previousStateId",
1031 ),
1032 );
1033 }
1034 m_previousStateId = _serde::__private::Some(
1035 match __A::next_value::<i32>(&mut __map) {
1036 _serde::__private::Ok(__val) => __val,
1037 _serde::__private::Err(__err) => {
1038 return _serde::__private::Err(__err);
1039 }
1040 },
1041 );
1042 }
1043 24usize => {
1044 if _serde::__private::Option::is_some(
1045 &m_nextStartStateIndexOverride,
1046 ) {
1047 return _serde::__private::Err(
1048 <__A::Error as _serde::de::Error>::duplicate_field(
1049 "nextStartStateIndexOverride",
1050 ),
1051 );
1052 }
1053 m_nextStartStateIndexOverride = _serde::__private::Some(
1054 match __A::next_value::<i32>(&mut __map) {
1055 _serde::__private::Ok(__val) => __val,
1056 _serde::__private::Err(__err) => {
1057 return _serde::__private::Err(__err);
1058 }
1059 },
1060 );
1061 }
1062 25usize => {
1063 if _serde::__private::Option::is_some(
1064 &m_stateOrTransitionChanged,
1065 ) {
1066 return _serde::__private::Err(
1067 <__A::Error as _serde::de::Error>::duplicate_field(
1068 "stateOrTransitionChanged",
1069 ),
1070 );
1071 }
1072 m_stateOrTransitionChanged = _serde::__private::Some(
1073 match __A::next_value::<bool>(&mut __map) {
1074 _serde::__private::Ok(__val) => __val,
1075 _serde::__private::Err(__err) => {
1076 return _serde::__private::Err(__err);
1077 }
1078 },
1079 );
1080 }
1081 26usize => {
1082 if _serde::__private::Option::is_some(&m_echoNextUpdate) {
1083 return _serde::__private::Err(
1084 <__A::Error as _serde::de::Error>::duplicate_field(
1085 "echoNextUpdate",
1086 ),
1087 );
1088 }
1089 m_echoNextUpdate = _serde::__private::Some(
1090 match __A::next_value::<bool>(&mut __map) {
1091 _serde::__private::Ok(__val) => __val,
1092 _serde::__private::Err(__err) => {
1093 return _serde::__private::Err(__err);
1094 }
1095 },
1096 );
1097 }
1098 27usize => {
1099 if _serde::__private::Option::is_some(
1100 &m_sCurrentStateIndexAndEntered,
1101 ) {
1102 return _serde::__private::Err(
1103 <__A::Error as _serde::de::Error>::duplicate_field(
1104 "sCurrentStateIndexAndEntered",
1105 ),
1106 );
1107 }
1108 m_sCurrentStateIndexAndEntered = _serde::__private::Some(
1109 match __A::next_value::<u16>(&mut __map) {
1110 _serde::__private::Ok(__val) => __val,
1111 _serde::__private::Err(__err) => {
1112 return _serde::__private::Err(__err);
1113 }
1114 },
1115 );
1116 }
1117 _ => {}
1118 }
1119 }
1120 __A::pad(&mut __map, 0usize, 4usize)?;
1121 let m_eventToSendWhenStateOrTransitionChanges = match m_eventToSendWhenStateOrTransitionChanges {
1122 _serde::__private::Some(__field) => __field,
1123 _serde::__private::None => {
1124 return _serde::__private::Err(
1125 <__A::Error as _serde::de::Error>::missing_field(
1126 "eventToSendWhenStateOrTransitionChanges",
1127 ),
1128 );
1129 }
1130 };
1131 let m_startStateChooser = match m_startStateChooser {
1132 _serde::__private::Some(__field) => __field,
1133 _serde::__private::None => {
1134 return _serde::__private::Err(
1135 <__A::Error as _serde::de::Error>::missing_field(
1136 "startStateChooser",
1137 ),
1138 );
1139 }
1140 };
1141 let m_startStateId = match m_startStateId {
1142 _serde::__private::Some(__field) => __field,
1143 _serde::__private::None => {
1144 return _serde::__private::Err(
1145 <__A::Error as _serde::de::Error>::missing_field(
1146 "startStateId",
1147 ),
1148 );
1149 }
1150 };
1151 let m_returnToPreviousStateEventId = match m_returnToPreviousStateEventId {
1152 _serde::__private::Some(__field) => __field,
1153 _serde::__private::None => {
1154 return _serde::__private::Err(
1155 <__A::Error as _serde::de::Error>::missing_field(
1156 "returnToPreviousStateEventId",
1157 ),
1158 );
1159 }
1160 };
1161 let m_randomTransitionEventId = match m_randomTransitionEventId {
1162 _serde::__private::Some(__field) => __field,
1163 _serde::__private::None => {
1164 return _serde::__private::Err(
1165 <__A::Error as _serde::de::Error>::missing_field(
1166 "randomTransitionEventId",
1167 ),
1168 );
1169 }
1170 };
1171 let m_transitionToNextHigherStateEventId = match m_transitionToNextHigherStateEventId {
1172 _serde::__private::Some(__field) => __field,
1173 _serde::__private::None => {
1174 return _serde::__private::Err(
1175 <__A::Error as _serde::de::Error>::missing_field(
1176 "transitionToNextHigherStateEventId",
1177 ),
1178 );
1179 }
1180 };
1181 let m_transitionToNextLowerStateEventId = match m_transitionToNextLowerStateEventId {
1182 _serde::__private::Some(__field) => __field,
1183 _serde::__private::None => {
1184 return _serde::__private::Err(
1185 <__A::Error as _serde::de::Error>::missing_field(
1186 "transitionToNextLowerStateEventId",
1187 ),
1188 );
1189 }
1190 };
1191 let m_syncVariableIndex = match m_syncVariableIndex {
1192 _serde::__private::Some(__field) => __field,
1193 _serde::__private::None => {
1194 return _serde::__private::Err(
1195 <__A::Error as _serde::de::Error>::missing_field(
1196 "syncVariableIndex",
1197 ),
1198 );
1199 }
1200 };
1201 let m_currentStateId = match m_currentStateId {
1202 _serde::__private::Some(__field) => __field,
1203 _serde::__private::None => {
1204 return _serde::__private::Err(
1205 <__A::Error as _serde::de::Error>::missing_field(
1206 "currentStateId",
1207 ),
1208 );
1209 }
1210 };
1211 let m_wrapAroundStateId = match m_wrapAroundStateId {
1212 _serde::__private::Some(__field) => __field,
1213 _serde::__private::None => {
1214 return _serde::__private::Err(
1215 <__A::Error as _serde::de::Error>::missing_field(
1216 "wrapAroundStateId",
1217 ),
1218 );
1219 }
1220 };
1221 let m_maxSimultaneousTransitions = match m_maxSimultaneousTransitions {
1222 _serde::__private::Some(__field) => __field,
1223 _serde::__private::None => {
1224 return _serde::__private::Err(
1225 <__A::Error as _serde::de::Error>::missing_field(
1226 "maxSimultaneousTransitions",
1227 ),
1228 );
1229 }
1230 };
1231 let m_startStateMode = match m_startStateMode {
1232 _serde::__private::Some(__field) => __field,
1233 _serde::__private::None => {
1234 return _serde::__private::Err(
1235 <__A::Error as _serde::de::Error>::missing_field(
1236 "startStateMode",
1237 ),
1238 );
1239 }
1240 };
1241 let m_selfTransitionMode = match m_selfTransitionMode {
1242 _serde::__private::Some(__field) => __field,
1243 _serde::__private::None => {
1244 return _serde::__private::Err(
1245 <__A::Error as _serde::de::Error>::missing_field(
1246 "selfTransitionMode",
1247 ),
1248 );
1249 }
1250 };
1251 let m_isActive = match m_isActive {
1252 _serde::__private::Some(__field) => __field,
1253 _serde::__private::None => {
1254 return _serde::__private::Err(
1255 <__A::Error as _serde::de::Error>::missing_field("isActive"),
1256 );
1257 }
1258 };
1259 let m_states = match m_states {
1260 _serde::__private::Some(__field) => __field,
1261 _serde::__private::None => {
1262 return _serde::__private::Err(
1263 <__A::Error as _serde::de::Error>::missing_field("states"),
1264 );
1265 }
1266 };
1267 let m_wildcardTransitions = match m_wildcardTransitions {
1268 _serde::__private::Some(__field) => __field,
1269 _serde::__private::None => {
1270 return _serde::__private::Err(
1271 <__A::Error as _serde::de::Error>::missing_field(
1272 "wildcardTransitions",
1273 ),
1274 );
1275 }
1276 };
1277 let m_stateIdToIndexMap = match m_stateIdToIndexMap {
1278 _serde::__private::Some(__field) => __field,
1279 _serde::__private::None => {
1280 return _serde::__private::Err(
1281 <__A::Error as _serde::de::Error>::missing_field(
1282 "stateIdToIndexMap",
1283 ),
1284 );
1285 }
1286 };
1287 let m_activeTransitions = match m_activeTransitions {
1288 _serde::__private::Some(__field) => __field,
1289 _serde::__private::None => {
1290 return _serde::__private::Err(
1291 <__A::Error as _serde::de::Error>::missing_field(
1292 "activeTransitions",
1293 ),
1294 );
1295 }
1296 };
1297 let m_transitionFlags = match m_transitionFlags {
1298 _serde::__private::Some(__field) => __field,
1299 _serde::__private::None => {
1300 return _serde::__private::Err(
1301 <__A::Error as _serde::de::Error>::missing_field(
1302 "transitionFlags",
1303 ),
1304 );
1305 }
1306 };
1307 let m_wildcardTransitionFlags = match m_wildcardTransitionFlags {
1308 _serde::__private::Some(__field) => __field,
1309 _serde::__private::None => {
1310 return _serde::__private::Err(
1311 <__A::Error as _serde::de::Error>::missing_field(
1312 "wildcardTransitionFlags",
1313 ),
1314 );
1315 }
1316 };
1317 let m_delayedTransitions = match m_delayedTransitions {
1318 _serde::__private::Some(__field) => __field,
1319 _serde::__private::None => {
1320 return _serde::__private::Err(
1321 <__A::Error as _serde::de::Error>::missing_field(
1322 "delayedTransitions",
1323 ),
1324 );
1325 }
1326 };
1327 let m_timeInState = match m_timeInState {
1328 _serde::__private::Some(__field) => __field,
1329 _serde::__private::None => {
1330 return _serde::__private::Err(
1331 <__A::Error as _serde::de::Error>::missing_field(
1332 "timeInState",
1333 ),
1334 );
1335 }
1336 };
1337 let m_lastLocalTime = match m_lastLocalTime {
1338 _serde::__private::Some(__field) => __field,
1339 _serde::__private::None => {
1340 return _serde::__private::Err(
1341 <__A::Error as _serde::de::Error>::missing_field(
1342 "lastLocalTime",
1343 ),
1344 );
1345 }
1346 };
1347 let m_previousStateId = match m_previousStateId {
1348 _serde::__private::Some(__field) => __field,
1349 _serde::__private::None => {
1350 return _serde::__private::Err(
1351 <__A::Error as _serde::de::Error>::missing_field(
1352 "previousStateId",
1353 ),
1354 );
1355 }
1356 };
1357 let m_nextStartStateIndexOverride = match m_nextStartStateIndexOverride {
1358 _serde::__private::Some(__field) => __field,
1359 _serde::__private::None => {
1360 return _serde::__private::Err(
1361 <__A::Error as _serde::de::Error>::missing_field(
1362 "nextStartStateIndexOverride",
1363 ),
1364 );
1365 }
1366 };
1367 let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
1368 _serde::__private::Some(__field) => __field,
1369 _serde::__private::None => {
1370 return _serde::__private::Err(
1371 <__A::Error as _serde::de::Error>::missing_field(
1372 "stateOrTransitionChanged",
1373 ),
1374 );
1375 }
1376 };
1377 let m_echoNextUpdate = match m_echoNextUpdate {
1378 _serde::__private::Some(__field) => __field,
1379 _serde::__private::None => {
1380 return _serde::__private::Err(
1381 <__A::Error as _serde::de::Error>::missing_field(
1382 "echoNextUpdate",
1383 ),
1384 );
1385 }
1386 };
1387 let m_sCurrentStateIndexAndEntered = match m_sCurrentStateIndexAndEntered {
1388 _serde::__private::Some(__field) => __field,
1389 _serde::__private::None => {
1390 return _serde::__private::Err(
1391 <__A::Error as _serde::de::Error>::missing_field(
1392 "sCurrentStateIndexAndEntered",
1393 ),
1394 );
1395 }
1396 };
1397 _serde::__private::Ok(hkbStateMachine {
1398 __ptr,
1399 parent,
1400 m_eventToSendWhenStateOrTransitionChanges,
1401 m_startStateChooser,
1402 m_startStateId,
1403 m_returnToPreviousStateEventId,
1404 m_randomTransitionEventId,
1405 m_transitionToNextHigherStateEventId,
1406 m_transitionToNextLowerStateEventId,
1407 m_syncVariableIndex,
1408 m_currentStateId,
1409 m_wrapAroundStateId,
1410 m_maxSimultaneousTransitions,
1411 m_startStateMode,
1412 m_selfTransitionMode,
1413 m_isActive,
1414 m_states,
1415 m_wildcardTransitions,
1416 m_stateIdToIndexMap,
1417 m_activeTransitions,
1418 m_transitionFlags,
1419 m_wildcardTransitionFlags,
1420 m_delayedTransitions,
1421 m_timeInState,
1422 m_lastLocalTime,
1423 m_previousStateId,
1424 m_nextStartStateIndexOverride,
1425 m_stateOrTransitionChanged,
1426 m_echoNextUpdate,
1427 m_sCurrentStateIndexAndEntered,
1428 })
1429 }
1430 #[allow(clippy::manual_unwrap_or_default)]
1431 fn visit_struct<__A>(
1432 self,
1433 mut __map: __A,
1434 ) -> _serde::__private::Result<Self::Value, __A::Error>
1435 where
1436 __A: _serde::de::MapAccess<'de>,
1437 {
1438 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1439 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1440 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1441 let mut m_eventToSendWhenStateOrTransitionChanges: _serde::__private::Option<
1442 hkbEvent,
1443 > = _serde::__private::None;
1444 let mut m_startStateChooser: _serde::__private::Option<Pointer> = _serde::__private::None;
1445 let mut m_startStateId: _serde::__private::Option<i32> = _serde::__private::None;
1446 let mut m_returnToPreviousStateEventId: _serde::__private::Option<
1447 i32,
1448 > = _serde::__private::None;
1449 let mut m_randomTransitionEventId: _serde::__private::Option<i32> = _serde::__private::None;
1450 let mut m_transitionToNextHigherStateEventId: _serde::__private::Option<
1451 i32,
1452 > = _serde::__private::None;
1453 let mut m_transitionToNextLowerStateEventId: _serde::__private::Option<
1454 i32,
1455 > = _serde::__private::None;
1456 let mut m_syncVariableIndex: _serde::__private::Option<i32> = _serde::__private::None;
1457 let mut m_wrapAroundStateId: _serde::__private::Option<bool> = _serde::__private::None;
1458 let mut m_maxSimultaneousTransitions: _serde::__private::Option<
1459 i8,
1460 > = _serde::__private::None;
1461 let mut m_startStateMode: _serde::__private::Option<
1462 StartStateMode,
1463 > = _serde::__private::None;
1464 let mut m_selfTransitionMode: _serde::__private::Option<
1465 StateMachineSelfTransitionMode,
1466 > = _serde::__private::None;
1467 let mut m_states: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
1468 let mut m_wildcardTransitions: _serde::__private::Option<Pointer> = _serde::__private::None;
1469 while let _serde::__private::Some(__key) = {
1470 __A::next_key::<__Field>(&mut __map)?
1471 } {
1472 match __key {
1473 __Field::m_variableBindingSet => {
1474 #[cfg(
1475 any(feature = "strict", feature = "ignore_duplicates")
1476 )]
1477 if _serde::__private::Option::is_some(
1478 &m_variableBindingSet,
1479 ) {
1480 #[cfg(feature = "ignore_duplicates")]
1481 {
1482 __A::skip_value(&mut __map)?;
1483 continue;
1484 }
1485 #[cfg(feature = "strict")]
1486 return _serde::__private::Err(
1487 <__A::Error as _serde::de::Error>::duplicate_field(
1488 "variableBindingSet",
1489 ),
1490 );
1491 }
1492 m_variableBindingSet = _serde::__private::Some(
1493 match __A::next_value::<Pointer>(&mut __map) {
1494 _serde::__private::Ok(__val) => __val,
1495 _serde::__private::Err(__err) => {
1496 return _serde::__private::Err(__err);
1497 }
1498 },
1499 );
1500 }
1501 __Field::m_userData => {
1502 #[cfg(
1503 any(feature = "strict", feature = "ignore_duplicates")
1504 )]
1505 if _serde::__private::Option::is_some(&m_userData) {
1506 #[cfg(feature = "ignore_duplicates")]
1507 {
1508 __A::skip_value(&mut __map)?;
1509 continue;
1510 }
1511 #[cfg(feature = "strict")]
1512 return _serde::__private::Err(
1513 <__A::Error as _serde::de::Error>::duplicate_field(
1514 "userData",
1515 ),
1516 );
1517 }
1518 m_userData = _serde::__private::Some(
1519 match __A::next_value::<Ulong>(&mut __map) {
1520 _serde::__private::Ok(__val) => __val,
1521 _serde::__private::Err(__err) => {
1522 return _serde::__private::Err(__err);
1523 }
1524 },
1525 );
1526 }
1527 __Field::m_name => {
1528 #[cfg(
1529 any(feature = "strict", feature = "ignore_duplicates")
1530 )]
1531 if _serde::__private::Option::is_some(&m_name) {
1532 #[cfg(feature = "ignore_duplicates")]
1533 {
1534 __A::skip_value(&mut __map)?;
1535 continue;
1536 }
1537 #[cfg(feature = "strict")]
1538 return _serde::__private::Err(
1539 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1540 );
1541 }
1542 m_name = _serde::__private::Some(
1543 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1544 _serde::__private::Ok(__val) => __val,
1545 _serde::__private::Err(__err) => {
1546 return _serde::__private::Err(__err);
1547 }
1548 },
1549 );
1550 }
1551 __Field::m_eventToSendWhenStateOrTransitionChanges => {
1552 #[cfg(
1553 any(feature = "strict", feature = "ignore_duplicates")
1554 )]
1555 if _serde::__private::Option::is_some(
1556 &m_eventToSendWhenStateOrTransitionChanges,
1557 ) {
1558 #[cfg(feature = "ignore_duplicates")]
1559 {
1560 __A::skip_value(&mut __map)?;
1561 continue;
1562 }
1563 #[cfg(feature = "strict")]
1564 return _serde::__private::Err(
1565 <__A::Error as _serde::de::Error>::duplicate_field(
1566 "eventToSendWhenStateOrTransitionChanges",
1567 ),
1568 );
1569 }
1570 m_eventToSendWhenStateOrTransitionChanges = _serde::__private::Some(
1571 match __A::next_value::<hkbEvent>(&mut __map) {
1572 _serde::__private::Ok(__val) => __val,
1573 _serde::__private::Err(__err) => {
1574 return _serde::__private::Err(__err);
1575 }
1576 },
1577 );
1578 }
1579 __Field::m_startStateChooser => {
1580 #[cfg(
1581 any(feature = "strict", feature = "ignore_duplicates")
1582 )]
1583 if _serde::__private::Option::is_some(
1584 &m_startStateChooser,
1585 ) {
1586 #[cfg(feature = "ignore_duplicates")]
1587 {
1588 __A::skip_value(&mut __map)?;
1589 continue;
1590 }
1591 #[cfg(feature = "strict")]
1592 return _serde::__private::Err(
1593 <__A::Error as _serde::de::Error>::duplicate_field(
1594 "startStateChooser",
1595 ),
1596 );
1597 }
1598 m_startStateChooser = _serde::__private::Some(
1599 match __A::next_value::<Pointer>(&mut __map) {
1600 _serde::__private::Ok(__val) => __val,
1601 _serde::__private::Err(__err) => {
1602 return _serde::__private::Err(__err);
1603 }
1604 },
1605 );
1606 }
1607 __Field::m_startStateId => {
1608 #[cfg(
1609 any(feature = "strict", feature = "ignore_duplicates")
1610 )]
1611 if _serde::__private::Option::is_some(&m_startStateId) {
1612 #[cfg(feature = "ignore_duplicates")]
1613 {
1614 __A::skip_value(&mut __map)?;
1615 continue;
1616 }
1617 #[cfg(feature = "strict")]
1618 return _serde::__private::Err(
1619 <__A::Error as _serde::de::Error>::duplicate_field(
1620 "startStateId",
1621 ),
1622 );
1623 }
1624 m_startStateId = _serde::__private::Some(
1625 match __A::next_value::<i32>(&mut __map) {
1626 _serde::__private::Ok(__val) => __val,
1627 _serde::__private::Err(__err) => {
1628 return _serde::__private::Err(__err);
1629 }
1630 },
1631 );
1632 }
1633 __Field::m_returnToPreviousStateEventId => {
1634 #[cfg(
1635 any(feature = "strict", feature = "ignore_duplicates")
1636 )]
1637 if _serde::__private::Option::is_some(
1638 &m_returnToPreviousStateEventId,
1639 ) {
1640 #[cfg(feature = "ignore_duplicates")]
1641 {
1642 __A::skip_value(&mut __map)?;
1643 continue;
1644 }
1645 #[cfg(feature = "strict")]
1646 return _serde::__private::Err(
1647 <__A::Error as _serde::de::Error>::duplicate_field(
1648 "returnToPreviousStateEventId",
1649 ),
1650 );
1651 }
1652 m_returnToPreviousStateEventId = _serde::__private::Some(
1653 match __A::next_value::<i32>(&mut __map) {
1654 _serde::__private::Ok(__val) => __val,
1655 _serde::__private::Err(__err) => {
1656 return _serde::__private::Err(__err);
1657 }
1658 },
1659 );
1660 }
1661 __Field::m_randomTransitionEventId => {
1662 #[cfg(
1663 any(feature = "strict", feature = "ignore_duplicates")
1664 )]
1665 if _serde::__private::Option::is_some(
1666 &m_randomTransitionEventId,
1667 ) {
1668 #[cfg(feature = "ignore_duplicates")]
1669 {
1670 __A::skip_value(&mut __map)?;
1671 continue;
1672 }
1673 #[cfg(feature = "strict")]
1674 return _serde::__private::Err(
1675 <__A::Error as _serde::de::Error>::duplicate_field(
1676 "randomTransitionEventId",
1677 ),
1678 );
1679 }
1680 m_randomTransitionEventId = _serde::__private::Some(
1681 match __A::next_value::<i32>(&mut __map) {
1682 _serde::__private::Ok(__val) => __val,
1683 _serde::__private::Err(__err) => {
1684 return _serde::__private::Err(__err);
1685 }
1686 },
1687 );
1688 }
1689 __Field::m_transitionToNextHigherStateEventId => {
1690 #[cfg(
1691 any(feature = "strict", feature = "ignore_duplicates")
1692 )]
1693 if _serde::__private::Option::is_some(
1694 &m_transitionToNextHigherStateEventId,
1695 ) {
1696 #[cfg(feature = "ignore_duplicates")]
1697 {
1698 __A::skip_value(&mut __map)?;
1699 continue;
1700 }
1701 #[cfg(feature = "strict")]
1702 return _serde::__private::Err(
1703 <__A::Error as _serde::de::Error>::duplicate_field(
1704 "transitionToNextHigherStateEventId",
1705 ),
1706 );
1707 }
1708 m_transitionToNextHigherStateEventId = _serde::__private::Some(
1709 match __A::next_value::<i32>(&mut __map) {
1710 _serde::__private::Ok(__val) => __val,
1711 _serde::__private::Err(__err) => {
1712 return _serde::__private::Err(__err);
1713 }
1714 },
1715 );
1716 }
1717 __Field::m_transitionToNextLowerStateEventId => {
1718 #[cfg(
1719 any(feature = "strict", feature = "ignore_duplicates")
1720 )]
1721 if _serde::__private::Option::is_some(
1722 &m_transitionToNextLowerStateEventId,
1723 ) {
1724 #[cfg(feature = "ignore_duplicates")]
1725 {
1726 __A::skip_value(&mut __map)?;
1727 continue;
1728 }
1729 #[cfg(feature = "strict")]
1730 return _serde::__private::Err(
1731 <__A::Error as _serde::de::Error>::duplicate_field(
1732 "transitionToNextLowerStateEventId",
1733 ),
1734 );
1735 }
1736 m_transitionToNextLowerStateEventId = _serde::__private::Some(
1737 match __A::next_value::<i32>(&mut __map) {
1738 _serde::__private::Ok(__val) => __val,
1739 _serde::__private::Err(__err) => {
1740 return _serde::__private::Err(__err);
1741 }
1742 },
1743 );
1744 }
1745 __Field::m_syncVariableIndex => {
1746 #[cfg(
1747 any(feature = "strict", feature = "ignore_duplicates")
1748 )]
1749 if _serde::__private::Option::is_some(
1750 &m_syncVariableIndex,
1751 ) {
1752 #[cfg(feature = "ignore_duplicates")]
1753 {
1754 __A::skip_value(&mut __map)?;
1755 continue;
1756 }
1757 #[cfg(feature = "strict")]
1758 return _serde::__private::Err(
1759 <__A::Error as _serde::de::Error>::duplicate_field(
1760 "syncVariableIndex",
1761 ),
1762 );
1763 }
1764 m_syncVariableIndex = _serde::__private::Some(
1765 match __A::next_value::<i32>(&mut __map) {
1766 _serde::__private::Ok(__val) => __val,
1767 _serde::__private::Err(__err) => {
1768 return _serde::__private::Err(__err);
1769 }
1770 },
1771 );
1772 }
1773 __Field::m_wrapAroundStateId => {
1774 #[cfg(
1775 any(feature = "strict", feature = "ignore_duplicates")
1776 )]
1777 if _serde::__private::Option::is_some(
1778 &m_wrapAroundStateId,
1779 ) {
1780 #[cfg(feature = "ignore_duplicates")]
1781 {
1782 __A::skip_value(&mut __map)?;
1783 continue;
1784 }
1785 #[cfg(feature = "strict")]
1786 return _serde::__private::Err(
1787 <__A::Error as _serde::de::Error>::duplicate_field(
1788 "wrapAroundStateId",
1789 ),
1790 );
1791 }
1792 m_wrapAroundStateId = _serde::__private::Some(
1793 match __A::next_value::<bool>(&mut __map) {
1794 _serde::__private::Ok(__val) => __val,
1795 _serde::__private::Err(__err) => {
1796 return _serde::__private::Err(__err);
1797 }
1798 },
1799 );
1800 }
1801 __Field::m_maxSimultaneousTransitions => {
1802 #[cfg(
1803 any(feature = "strict", feature = "ignore_duplicates")
1804 )]
1805 if _serde::__private::Option::is_some(
1806 &m_maxSimultaneousTransitions,
1807 ) {
1808 #[cfg(feature = "ignore_duplicates")]
1809 {
1810 __A::skip_value(&mut __map)?;
1811 continue;
1812 }
1813 #[cfg(feature = "strict")]
1814 return _serde::__private::Err(
1815 <__A::Error as _serde::de::Error>::duplicate_field(
1816 "maxSimultaneousTransitions",
1817 ),
1818 );
1819 }
1820 m_maxSimultaneousTransitions = _serde::__private::Some(
1821 match __A::next_value::<i8>(&mut __map) {
1822 _serde::__private::Ok(__val) => __val,
1823 _serde::__private::Err(__err) => {
1824 return _serde::__private::Err(__err);
1825 }
1826 },
1827 );
1828 }
1829 __Field::m_startStateMode => {
1830 #[cfg(
1831 any(feature = "strict", feature = "ignore_duplicates")
1832 )]
1833 if _serde::__private::Option::is_some(&m_startStateMode) {
1834 #[cfg(feature = "ignore_duplicates")]
1835 {
1836 __A::skip_value(&mut __map)?;
1837 continue;
1838 }
1839 #[cfg(feature = "strict")]
1840 return _serde::__private::Err(
1841 <__A::Error as _serde::de::Error>::duplicate_field(
1842 "startStateMode",
1843 ),
1844 );
1845 }
1846 m_startStateMode = _serde::__private::Some(
1847 match __A::next_value::<StartStateMode>(&mut __map) {
1848 _serde::__private::Ok(__val) => __val,
1849 _serde::__private::Err(__err) => {
1850 return _serde::__private::Err(__err);
1851 }
1852 },
1853 );
1854 }
1855 __Field::m_selfTransitionMode => {
1856 #[cfg(
1857 any(feature = "strict", feature = "ignore_duplicates")
1858 )]
1859 if _serde::__private::Option::is_some(
1860 &m_selfTransitionMode,
1861 ) {
1862 #[cfg(feature = "ignore_duplicates")]
1863 {
1864 __A::skip_value(&mut __map)?;
1865 continue;
1866 }
1867 #[cfg(feature = "strict")]
1868 return _serde::__private::Err(
1869 <__A::Error as _serde::de::Error>::duplicate_field(
1870 "selfTransitionMode",
1871 ),
1872 );
1873 }
1874 m_selfTransitionMode = _serde::__private::Some(
1875 match __A::next_value::<
1876 StateMachineSelfTransitionMode,
1877 >(&mut __map) {
1878 _serde::__private::Ok(__val) => __val,
1879 _serde::__private::Err(__err) => {
1880 return _serde::__private::Err(__err);
1881 }
1882 },
1883 );
1884 }
1885 __Field::m_states => {
1886 #[cfg(
1887 any(feature = "strict", feature = "ignore_duplicates")
1888 )]
1889 if _serde::__private::Option::is_some(&m_states) {
1890 #[cfg(feature = "ignore_duplicates")]
1891 {
1892 __A::skip_value(&mut __map)?;
1893 continue;
1894 }
1895 #[cfg(feature = "strict")]
1896 return _serde::__private::Err(
1897 <__A::Error as _serde::de::Error>::duplicate_field("states"),
1898 );
1899 }
1900 m_states = _serde::__private::Some(
1901 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1902 _serde::__private::Ok(__val) => __val,
1903 _serde::__private::Err(__err) => {
1904 return _serde::__private::Err(__err);
1905 }
1906 },
1907 );
1908 }
1909 __Field::m_wildcardTransitions => {
1910 #[cfg(
1911 any(feature = "strict", feature = "ignore_duplicates")
1912 )]
1913 if _serde::__private::Option::is_some(
1914 &m_wildcardTransitions,
1915 ) {
1916 #[cfg(feature = "ignore_duplicates")]
1917 {
1918 __A::skip_value(&mut __map)?;
1919 continue;
1920 }
1921 #[cfg(feature = "strict")]
1922 return _serde::__private::Err(
1923 <__A::Error as _serde::de::Error>::duplicate_field(
1924 "wildcardTransitions",
1925 ),
1926 );
1927 }
1928 m_wildcardTransitions = _serde::__private::Some(
1929 match __A::next_value::<Pointer>(&mut __map) {
1930 _serde::__private::Ok(__val) => __val,
1931 _serde::__private::Err(__err) => {
1932 return _serde::__private::Err(__err);
1933 }
1934 },
1935 );
1936 }
1937 _ => __A::skip_value(&mut __map)?,
1938 }
1939 }
1940 let m_variableBindingSet = match m_variableBindingSet {
1941 _serde::__private::Some(__field) => __field,
1942 _serde::__private::None => {
1943 #[cfg(feature = "strict")]
1944 return _serde::__private::Err(
1945 <__A::Error as _serde::de::Error>::missing_field(
1946 "variableBindingSet",
1947 ),
1948 );
1949 #[cfg(not(feature = "strict"))] Default::default()
1950 }
1951 };
1952 let m_userData = match m_userData {
1953 _serde::__private::Some(__field) => __field,
1954 _serde::__private::None => {
1955 #[cfg(feature = "strict")]
1956 return _serde::__private::Err(
1957 <__A::Error as _serde::de::Error>::missing_field("userData"),
1958 );
1959 #[cfg(not(feature = "strict"))] Default::default()
1960 }
1961 };
1962 let m_name = match m_name {
1963 _serde::__private::Some(__field) => __field,
1964 _serde::__private::None => {
1965 #[cfg(feature = "strict")]
1966 return _serde::__private::Err(
1967 <__A::Error as _serde::de::Error>::missing_field("name"),
1968 );
1969 #[cfg(not(feature = "strict"))] Default::default()
1970 }
1971 };
1972 let m_eventToSendWhenStateOrTransitionChanges = match m_eventToSendWhenStateOrTransitionChanges {
1973 _serde::__private::Some(__field) => __field,
1974 _serde::__private::None => {
1975 #[cfg(feature = "strict")]
1976 return _serde::__private::Err(
1977 <__A::Error as _serde::de::Error>::missing_field(
1978 "eventToSendWhenStateOrTransitionChanges",
1979 ),
1980 );
1981 #[cfg(not(feature = "strict"))] Default::default()
1982 }
1983 };
1984 let m_startStateChooser = match m_startStateChooser {
1985 _serde::__private::Some(__field) => __field,
1986 _serde::__private::None => {
1987 #[cfg(feature = "strict")]
1988 return _serde::__private::Err(
1989 <__A::Error as _serde::de::Error>::missing_field(
1990 "startStateChooser",
1991 ),
1992 );
1993 #[cfg(not(feature = "strict"))] Default::default()
1994 }
1995 };
1996 let m_startStateId = match m_startStateId {
1997 _serde::__private::Some(__field) => __field,
1998 _serde::__private::None => {
1999 #[cfg(feature = "strict")]
2000 return _serde::__private::Err(
2001 <__A::Error as _serde::de::Error>::missing_field(
2002 "startStateId",
2003 ),
2004 );
2005 #[cfg(not(feature = "strict"))] Default::default()
2006 }
2007 };
2008 let m_returnToPreviousStateEventId = match m_returnToPreviousStateEventId {
2009 _serde::__private::Some(__field) => __field,
2010 _serde::__private::None => {
2011 #[cfg(feature = "strict")]
2012 return _serde::__private::Err(
2013 <__A::Error as _serde::de::Error>::missing_field(
2014 "returnToPreviousStateEventId",
2015 ),
2016 );
2017 #[cfg(not(feature = "strict"))] Default::default()
2018 }
2019 };
2020 let m_randomTransitionEventId = match m_randomTransitionEventId {
2021 _serde::__private::Some(__field) => __field,
2022 _serde::__private::None => {
2023 #[cfg(feature = "strict")]
2024 return _serde::__private::Err(
2025 <__A::Error as _serde::de::Error>::missing_field(
2026 "randomTransitionEventId",
2027 ),
2028 );
2029 #[cfg(not(feature = "strict"))] Default::default()
2030 }
2031 };
2032 let m_transitionToNextHigherStateEventId = match m_transitionToNextHigherStateEventId {
2033 _serde::__private::Some(__field) => __field,
2034 _serde::__private::None => {
2035 #[cfg(feature = "strict")]
2036 return _serde::__private::Err(
2037 <__A::Error as _serde::de::Error>::missing_field(
2038 "transitionToNextHigherStateEventId",
2039 ),
2040 );
2041 #[cfg(not(feature = "strict"))] Default::default()
2042 }
2043 };
2044 let m_transitionToNextLowerStateEventId = match m_transitionToNextLowerStateEventId {
2045 _serde::__private::Some(__field) => __field,
2046 _serde::__private::None => {
2047 #[cfg(feature = "strict")]
2048 return _serde::__private::Err(
2049 <__A::Error as _serde::de::Error>::missing_field(
2050 "transitionToNextLowerStateEventId",
2051 ),
2052 );
2053 #[cfg(not(feature = "strict"))] Default::default()
2054 }
2055 };
2056 let m_syncVariableIndex = match m_syncVariableIndex {
2057 _serde::__private::Some(__field) => __field,
2058 _serde::__private::None => {
2059 #[cfg(feature = "strict")]
2060 return _serde::__private::Err(
2061 <__A::Error as _serde::de::Error>::missing_field(
2062 "syncVariableIndex",
2063 ),
2064 );
2065 #[cfg(not(feature = "strict"))] Default::default()
2066 }
2067 };
2068 let m_wrapAroundStateId = match m_wrapAroundStateId {
2069 _serde::__private::Some(__field) => __field,
2070 _serde::__private::None => {
2071 #[cfg(feature = "strict")]
2072 return _serde::__private::Err(
2073 <__A::Error as _serde::de::Error>::missing_field(
2074 "wrapAroundStateId",
2075 ),
2076 );
2077 #[cfg(not(feature = "strict"))] Default::default()
2078 }
2079 };
2080 let m_maxSimultaneousTransitions = match m_maxSimultaneousTransitions {
2081 _serde::__private::Some(__field) => __field,
2082 _serde::__private::None => {
2083 #[cfg(feature = "strict")]
2084 return _serde::__private::Err(
2085 <__A::Error as _serde::de::Error>::missing_field(
2086 "maxSimultaneousTransitions",
2087 ),
2088 );
2089 #[cfg(not(feature = "strict"))] Default::default()
2090 }
2091 };
2092 let m_startStateMode = match m_startStateMode {
2093 _serde::__private::Some(__field) => __field,
2094 _serde::__private::None => {
2095 #[cfg(feature = "strict")]
2096 return _serde::__private::Err(
2097 <__A::Error as _serde::de::Error>::missing_field(
2098 "startStateMode",
2099 ),
2100 );
2101 #[cfg(not(feature = "strict"))] Default::default()
2102 }
2103 };
2104 let m_selfTransitionMode = match m_selfTransitionMode {
2105 _serde::__private::Some(__field) => __field,
2106 _serde::__private::None => {
2107 #[cfg(feature = "strict")]
2108 return _serde::__private::Err(
2109 <__A::Error as _serde::de::Error>::missing_field(
2110 "selfTransitionMode",
2111 ),
2112 );
2113 #[cfg(not(feature = "strict"))] Default::default()
2114 }
2115 };
2116 let m_states = match m_states {
2117 _serde::__private::Some(__field) => __field,
2118 _serde::__private::None => {
2119 #[cfg(feature = "strict")]
2120 return _serde::__private::Err(
2121 <__A::Error as _serde::de::Error>::missing_field("states"),
2122 );
2123 #[cfg(not(feature = "strict"))] Default::default()
2124 }
2125 };
2126 let m_wildcardTransitions = match m_wildcardTransitions {
2127 _serde::__private::Some(__field) => __field,
2128 _serde::__private::None => {
2129 #[cfg(feature = "strict")]
2130 return _serde::__private::Err(
2131 <__A::Error as _serde::de::Error>::missing_field(
2132 "wildcardTransitions",
2133 ),
2134 );
2135 #[cfg(not(feature = "strict"))] Default::default()
2136 }
2137 };
2138 let __ptr = None;
2139 let parent = hkBaseObject { __ptr };
2140 let parent = hkReferencedObject {
2141 __ptr,
2142 parent,
2143 ..Default::default()
2144 };
2145 let parent = hkbBindable {
2146 __ptr,
2147 parent,
2148 m_variableBindingSet,
2149 ..Default::default()
2150 };
2151 let parent = hkbNode {
2152 __ptr,
2153 parent,
2154 m_userData,
2155 m_name,
2156 ..Default::default()
2157 };
2158 let parent = hkbGenerator { __ptr, parent };
2159 let __ptr = __A::class_ptr(&mut __map);
2160 _serde::__private::Ok(hkbStateMachine {
2161 __ptr,
2162 parent,
2163 m_eventToSendWhenStateOrTransitionChanges,
2164 m_startStateChooser,
2165 m_startStateId,
2166 m_returnToPreviousStateEventId,
2167 m_randomTransitionEventId,
2168 m_transitionToNextHigherStateEventId,
2169 m_transitionToNextLowerStateEventId,
2170 m_syncVariableIndex,
2171 m_wrapAroundStateId,
2172 m_maxSimultaneousTransitions,
2173 m_startStateMode,
2174 m_selfTransitionMode,
2175 m_states,
2176 m_wildcardTransitions,
2177 ..Default::default()
2178 })
2179 }
2180 }
2181 const FIELDS: &[&str] = &[
2182 "eventToSendWhenStateOrTransitionChanges",
2183 "startStateChooser",
2184 "startStateId",
2185 "returnToPreviousStateEventId",
2186 "randomTransitionEventId",
2187 "transitionToNextHigherStateEventId",
2188 "transitionToNextLowerStateEventId",
2189 "syncVariableIndex",
2190 "currentStateId",
2191 "wrapAroundStateId",
2192 "maxSimultaneousTransitions",
2193 "startStateMode",
2194 "selfTransitionMode",
2195 "isActive",
2196 "states",
2197 "wildcardTransitions",
2198 "stateIdToIndexMap",
2199 "activeTransitions",
2200 "transitionFlags",
2201 "wildcardTransitionFlags",
2202 "delayedTransitions",
2203 "timeInState",
2204 "lastLocalTime",
2205 "previousStateId",
2206 "nextStartStateIndexOverride",
2207 "stateOrTransitionChanged",
2208 "echoNextUpdate",
2209 "sCurrentStateIndexAndEntered",
2210 ];
2211 _serde::Deserializer::deserialize_struct(
2212 deserializer,
2213 "hkbStateMachine",
2214 FIELDS,
2215 __hkbStateMachineVisitor {
2216 marker: _serde::__private::PhantomData::<hkbStateMachine>,
2217 lifetime: _serde::__private::PhantomData,
2218 },
2219 )
2220 }
2221 }
2222};
2223#[allow(non_upper_case_globals, non_snake_case)]
2226#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2227#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2228#[derive(
2229 Debug,
2230 Clone,
2231 Default,
2232 PartialEq,
2233 Eq,
2234 PartialOrd,
2235 Ord,
2236 num_derive::ToPrimitive,
2237 num_derive::FromPrimitive,
2238)]
2239pub enum StartStateMode {
2240 #[default]
2241 START_STATE_MODE_DEFAULT = 0isize,
2242 START_STATE_MODE_SYNC = 1isize,
2243 START_STATE_MODE_RANDOM = 2isize,
2244 START_STATE_MODE_CHOOSER = 3isize,
2245}
2246#[allow(non_upper_case_globals, non_snake_case)]
2249#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2250#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2251#[derive(
2252 Debug,
2253 Clone,
2254 Default,
2255 PartialEq,
2256 Eq,
2257 PartialOrd,
2258 Ord,
2259 num_derive::ToPrimitive,
2260 num_derive::FromPrimitive,
2261)]
2262pub enum StateMachineSelfTransitionMode {
2263 #[default]
2264 SELF_TRANSITION_MODE_NO_TRANSITION = 0isize,
2265 SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE = 1isize,
2266 SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE = 2isize,
2267}
2268const _: () = {
2269 use havok_serde as __serde;
2270 impl __serde::Serialize for StartStateMode {
2271 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2272 where
2273 S: __serde::ser::Serializer,
2274 {
2275 let mut __serializer = __serializer.serialize_enum_flags()?;
2276 match self {
2277 Self::START_STATE_MODE_DEFAULT => {
2278 __serializer.serialize_field("START_STATE_MODE_DEFAULT", &0u64)
2279 }
2280 Self::START_STATE_MODE_SYNC => {
2281 __serializer.serialize_field("START_STATE_MODE_SYNC", &1u64)
2282 }
2283 Self::START_STATE_MODE_RANDOM => {
2284 __serializer.serialize_field("START_STATE_MODE_RANDOM", &2u64)
2285 }
2286 Self::START_STATE_MODE_CHOOSER => {
2287 __serializer.serialize_field("START_STATE_MODE_CHOOSER", &3u64)
2288 }
2289 }?;
2290 use num_traits::ToPrimitive as _;
2291 let num = self
2292 .to_i8()
2293 .ok_or(S::Error::custom("Failed enum StartStateMode to_i8"))?;
2294 __serializer.serialize_bits(&num)?;
2295 __serializer.end()
2296 }
2297 }
2298};
2299const _: () = {
2300 use havok_serde as __serde;
2301 impl __serde::Serialize for StateMachineSelfTransitionMode {
2302 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2303 where
2304 S: __serde::ser::Serializer,
2305 {
2306 let mut __serializer = __serializer.serialize_enum_flags()?;
2307 match self {
2308 Self::SELF_TRANSITION_MODE_NO_TRANSITION => {
2309 __serializer
2310 .serialize_field("SELF_TRANSITION_MODE_NO_TRANSITION", &0u64)
2311 }
2312 Self::SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE => {
2313 __serializer
2314 .serialize_field(
2315 "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2316 &1u64,
2317 )
2318 }
2319 Self::SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE => {
2320 __serializer
2321 .serialize_field(
2322 "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2323 &2u64,
2324 )
2325 }
2326 }?;
2327 use num_traits::ToPrimitive as _;
2328 let num = self
2329 .to_i8()
2330 .ok_or(
2331 S::Error::custom("Failed enum StateMachineSelfTransitionMode to_i8"),
2332 )?;
2333 __serializer.serialize_bits(&num)?;
2334 __serializer.end()
2335 }
2336 }
2337};
2338#[doc(hidden)]
2339#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2340const _: () = {
2341 #[allow(unused_extern_crates, clippy::useless_attribute)]
2342 extern crate havok_serde as _serde;
2343 #[automatically_derived]
2344 impl<'de> _serde::Deserialize<'de> for StartStateMode {
2345 fn deserialize<__D>(
2346 __deserializer: __D,
2347 ) -> _serde::__private::Result<Self, __D::Error>
2348 where
2349 __D: _serde::Deserializer<'de>,
2350 {
2351 #[allow(non_camel_case_types)]
2352 #[doc(hidden)]
2353 enum __Field {
2354 __field0,
2355 __field1,
2356 __field2,
2357 __field3,
2358 }
2359 #[doc(hidden)]
2360 struct __FieldVisitor;
2361 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2362 type Value = __Field;
2363 fn expecting(
2364 &self,
2365 __formatter: &mut _serde::__private::Formatter,
2366 ) -> _serde::__private::fmt::Result {
2367 _serde::__private::Formatter::write_str(
2368 __formatter,
2369 "variant identifier",
2370 )
2371 }
2372 fn visit_int8<__E>(
2373 self,
2374 __value: i8,
2375 ) -> _serde::__private::Result<Self::Value, __E>
2376 where
2377 __E: _serde::de::Error,
2378 {
2379 match __value {
2380 0i8 => _serde::__private::Ok(__Field::__field0),
2381 1i8 => _serde::__private::Ok(__Field::__field1),
2382 2i8 => _serde::__private::Ok(__Field::__field2),
2383 3i8 => _serde::__private::Ok(__Field::__field3),
2384 _ => {
2385 _serde::__private::Err(
2386 _serde::de::Error::invalid_value(
2387 _serde::de::Unexpected::Int8(__value),
2388 &"value(i8) of variant is one of 0, 1, 2, 3",
2389 ),
2390 )
2391 }
2392 }
2393 }
2394 fn visit_stringptr<__E>(
2395 self,
2396 __value: StringPtr<'de>,
2397 ) -> _serde::__private::Result<Self::Value, __E>
2398 where
2399 __E: _serde::de::Error,
2400 {
2401 if let Some(__value) = __value.into_inner() {
2402 match __value.as_ref() {
2403 v if v == "0"
2404 || v.eq_ignore_ascii_case("START_STATE_MODE_DEFAULT") => {
2405 _serde::__private::Ok(__Field::__field0)
2406 }
2407 v if v == "1"
2408 || v.eq_ignore_ascii_case("START_STATE_MODE_SYNC") => {
2409 _serde::__private::Ok(__Field::__field1)
2410 }
2411 v if v == "2"
2412 || v.eq_ignore_ascii_case("START_STATE_MODE_RANDOM") => {
2413 _serde::__private::Ok(__Field::__field2)
2414 }
2415 v if v == "3"
2416 || v.eq_ignore_ascii_case("START_STATE_MODE_CHOOSER") => {
2417 _serde::__private::Ok(__Field::__field3)
2418 }
2419 _ => {
2420 _serde::__private::Err(
2421 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2422 )
2423 }
2424 }
2425 } else {
2426 _serde::__private::Err(
2427 _serde::de::Error::unknown_variant("None", VARIANTS),
2428 )
2429 }
2430 }
2431 }
2432 impl<'de> _serde::Deserialize<'de> for __Field {
2433 #[inline]
2434 fn deserialize<__D>(
2435 __deserializer: __D,
2436 ) -> _serde::__private::Result<Self, __D::Error>
2437 where
2438 __D: _serde::Deserializer<'de>,
2439 {
2440 _serde::Deserializer::deserialize_identifier(
2441 __deserializer,
2442 _serde::de::ReadEnumSize::Int8,
2443 __FieldVisitor,
2444 )
2445 }
2446 }
2447 #[doc(hidden)]
2448 struct __Visitor<'de> {
2449 marker: _serde::__private::PhantomData<StartStateMode>,
2450 lifetime: _serde::__private::PhantomData<&'de ()>,
2451 }
2452 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2453 type Value = StartStateMode;
2454 fn expecting(
2455 &self,
2456 __formatter: &mut _serde::__private::Formatter,
2457 ) -> _serde::__private::fmt::Result {
2458 _serde::__private::Formatter::write_str(
2459 __formatter,
2460 "enum StartStateMode",
2461 )
2462 }
2463 fn visit_enum<__A>(
2464 self,
2465 __data: __A,
2466 ) -> _serde::__private::Result<Self::Value, __A::Error>
2467 where
2468 __A: _serde::de::EnumAccess<'de>,
2469 {
2470 match _serde::de::EnumAccess::variant(__data)? {
2471 (__Field::__field0, __variant) => {
2472 _serde::de::VariantAccess::unit_variant(__variant)?;
2473 _serde::__private::Ok(
2474 StartStateMode::START_STATE_MODE_DEFAULT,
2475 )
2476 }
2477 (__Field::__field1, __variant) => {
2478 _serde::de::VariantAccess::unit_variant(__variant)?;
2479 _serde::__private::Ok(StartStateMode::START_STATE_MODE_SYNC)
2480 }
2481 (__Field::__field2, __variant) => {
2482 _serde::de::VariantAccess::unit_variant(__variant)?;
2483 _serde::__private::Ok(
2484 StartStateMode::START_STATE_MODE_RANDOM,
2485 )
2486 }
2487 (__Field::__field3, __variant) => {
2488 _serde::de::VariantAccess::unit_variant(__variant)?;
2489 _serde::__private::Ok(
2490 StartStateMode::START_STATE_MODE_CHOOSER,
2491 )
2492 }
2493 }
2494 }
2495 }
2496 #[doc(hidden)]
2497 const VARIANTS: &'static [&'static str] = &[
2498 "START_STATE_MODE_DEFAULT",
2499 "START_STATE_MODE_SYNC",
2500 "START_STATE_MODE_RANDOM",
2501 "START_STATE_MODE_CHOOSER",
2502 ];
2503 _serde::Deserializer::deserialize_enum(
2504 __deserializer,
2505 "StartStateMode",
2506 VARIANTS,
2507 __Visitor {
2508 marker: _serde::__private::PhantomData::<StartStateMode>,
2509 lifetime: _serde::__private::PhantomData,
2510 },
2511 )
2512 }
2513 }
2514};
2515#[doc(hidden)]
2516#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2517const _: () = {
2518 #[allow(unused_extern_crates, clippy::useless_attribute)]
2519 extern crate havok_serde as _serde;
2520 #[automatically_derived]
2521 impl<'de> _serde::Deserialize<'de> for StateMachineSelfTransitionMode {
2522 fn deserialize<__D>(
2523 __deserializer: __D,
2524 ) -> _serde::__private::Result<Self, __D::Error>
2525 where
2526 __D: _serde::Deserializer<'de>,
2527 {
2528 #[allow(non_camel_case_types)]
2529 #[doc(hidden)]
2530 enum __Field {
2531 __field0,
2532 __field1,
2533 __field2,
2534 }
2535 #[doc(hidden)]
2536 struct __FieldVisitor;
2537 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2538 type Value = __Field;
2539 fn expecting(
2540 &self,
2541 __formatter: &mut _serde::__private::Formatter,
2542 ) -> _serde::__private::fmt::Result {
2543 _serde::__private::Formatter::write_str(
2544 __formatter,
2545 "variant identifier",
2546 )
2547 }
2548 fn visit_int8<__E>(
2549 self,
2550 __value: i8,
2551 ) -> _serde::__private::Result<Self::Value, __E>
2552 where
2553 __E: _serde::de::Error,
2554 {
2555 match __value {
2556 0i8 => _serde::__private::Ok(__Field::__field0),
2557 1i8 => _serde::__private::Ok(__Field::__field1),
2558 2i8 => _serde::__private::Ok(__Field::__field2),
2559 _ => {
2560 _serde::__private::Err(
2561 _serde::de::Error::invalid_value(
2562 _serde::de::Unexpected::Int8(__value),
2563 &"value(i8) of variant is one of 0, 1, 2",
2564 ),
2565 )
2566 }
2567 }
2568 }
2569 fn visit_stringptr<__E>(
2570 self,
2571 __value: StringPtr<'de>,
2572 ) -> _serde::__private::Result<Self::Value, __E>
2573 where
2574 __E: _serde::de::Error,
2575 {
2576 if let Some(__value) = __value.into_inner() {
2577 match __value.as_ref() {
2578 v if v == "0"
2579 || v
2580 .eq_ignore_ascii_case(
2581 "SELF_TRANSITION_MODE_NO_TRANSITION",
2582 ) => _serde::__private::Ok(__Field::__field0),
2583 v if v == "1"
2584 || v
2585 .eq_ignore_ascii_case(
2586 "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2587 ) => _serde::__private::Ok(__Field::__field1),
2588 v if v == "2"
2589 || v
2590 .eq_ignore_ascii_case(
2591 "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2592 ) => _serde::__private::Ok(__Field::__field2),
2593 _ => {
2594 _serde::__private::Err(
2595 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2596 )
2597 }
2598 }
2599 } else {
2600 _serde::__private::Err(
2601 _serde::de::Error::unknown_variant("None", VARIANTS),
2602 )
2603 }
2604 }
2605 }
2606 impl<'de> _serde::Deserialize<'de> for __Field {
2607 #[inline]
2608 fn deserialize<__D>(
2609 __deserializer: __D,
2610 ) -> _serde::__private::Result<Self, __D::Error>
2611 where
2612 __D: _serde::Deserializer<'de>,
2613 {
2614 _serde::Deserializer::deserialize_identifier(
2615 __deserializer,
2616 _serde::de::ReadEnumSize::Int8,
2617 __FieldVisitor,
2618 )
2619 }
2620 }
2621 #[doc(hidden)]
2622 struct __Visitor<'de> {
2623 marker: _serde::__private::PhantomData<StateMachineSelfTransitionMode>,
2624 lifetime: _serde::__private::PhantomData<&'de ()>,
2625 }
2626 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2627 type Value = StateMachineSelfTransitionMode;
2628 fn expecting(
2629 &self,
2630 __formatter: &mut _serde::__private::Formatter,
2631 ) -> _serde::__private::fmt::Result {
2632 _serde::__private::Formatter::write_str(
2633 __formatter,
2634 "enum StateMachineSelfTransitionMode",
2635 )
2636 }
2637 fn visit_enum<__A>(
2638 self,
2639 __data: __A,
2640 ) -> _serde::__private::Result<Self::Value, __A::Error>
2641 where
2642 __A: _serde::de::EnumAccess<'de>,
2643 {
2644 match _serde::de::EnumAccess::variant(__data)? {
2645 (__Field::__field0, __variant) => {
2646 _serde::de::VariantAccess::unit_variant(__variant)?;
2647 _serde::__private::Ok(
2648 StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_NO_TRANSITION,
2649 )
2650 }
2651 (__Field::__field1, __variant) => {
2652 _serde::de::VariantAccess::unit_variant(__variant)?;
2653 _serde::__private::Ok(
2654 StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE,
2655 )
2656 }
2657 (__Field::__field2, __variant) => {
2658 _serde::de::VariantAccess::unit_variant(__variant)?;
2659 _serde::__private::Ok(
2660 StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE,
2661 )
2662 }
2663 }
2664 }
2665 }
2666 #[doc(hidden)]
2667 const VARIANTS: &'static [&'static str] = &[
2668 "SELF_TRANSITION_MODE_NO_TRANSITION",
2669 "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2670 "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2671 ];
2672 _serde::Deserializer::deserialize_enum(
2673 __deserializer,
2674 "StateMachineSelfTransitionMode",
2675 VARIANTS,
2676 __Visitor {
2677 marker: _serde::__private::PhantomData::<
2678 StateMachineSelfTransitionMode,
2679 >,
2680 lifetime: _serde::__private::PhantomData,
2681 },
2682 )
2683 }
2684 }
2685};