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 hkbStateMachineActiveTransitionInfo {
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(rename = "transitionEffect"))]
32 #[cfg_attr(feature = "serde", serde(rename = "transitionEffect"))]
33 pub m_transitionEffect: Pointer,
34 #[cfg_attr(
39 feature = "json_schema",
40 schemars(rename = "transitionEffectInternalStateInfo")
41 )]
42 #[cfg_attr(feature = "serde", serde(rename = "transitionEffectInternalStateInfo"))]
43 pub m_transitionEffectInternalStateInfo: Pointer,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "transitionInfoReference"))]
49 #[cfg_attr(feature = "serde", serde(rename = "transitionInfoReference"))]
50 pub m_transitionInfoReference: hkbStateMachineTransitionInfoReference,
51 #[cfg_attr(
56 feature = "json_schema",
57 schemars(rename = "transitionInfoReferenceForTE")
58 )]
59 #[cfg_attr(feature = "serde", serde(rename = "transitionInfoReferenceForTE"))]
60 pub m_transitionInfoReferenceForTE: hkbStateMachineTransitionInfoReference,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "fromStateId"))]
66 #[cfg_attr(feature = "serde", serde(rename = "fromStateId"))]
67 pub m_fromStateId: i32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "toStateId"))]
73 #[cfg_attr(feature = "serde", serde(rename = "toStateId"))]
74 pub m_toStateId: i32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "isReturnToPreviousState"))]
80 #[cfg_attr(feature = "serde", serde(rename = "isReturnToPreviousState"))]
81 pub m_isReturnToPreviousState: bool,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl _serde::HavokClass for hkbStateMachineActiveTransitionInfo {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkbStateMachineActiveTransitionInfo"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0xbb90d54f)
93 }
94 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
95 fn deps_indexes(&self) -> Vec<usize> {
96 let mut v = Vec::new();
97 v.push(self.m_transitionEffect.get());
98 v.push(self.m_transitionEffectInternalStateInfo.get());
99 v.extend(self.m_transitionInfoReference.deps_indexes());
100 v.extend(self.m_transitionInfoReferenceForTE.deps_indexes());
101 v
102 }
103 }
104 impl _serde::Serialize for hkbStateMachineActiveTransitionInfo {
105 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
106 where
107 S: _serde::ser::Serializer,
108 {
109 let class_meta = self
110 .__ptr
111 .map(|name| (name, _serde::__private::Signature::new(0xbb90d54f)));
112 let mut serializer = __serializer
113 .serialize_struct(
114 "hkbStateMachineActiveTransitionInfo",
115 class_meta,
116 (32u64, 40u64),
117 )?;
118 serializer.skip_field("transitionEffect", &self.m_transitionEffect)?;
119 serializer
120 .serialize_field(
121 "transitionEffectInternalStateInfo",
122 &self.m_transitionEffectInternalStateInfo,
123 )?;
124 serializer
125 .serialize_field(
126 "transitionInfoReference",
127 &self.m_transitionInfoReference,
128 )?;
129 serializer
130 .serialize_field(
131 "transitionInfoReferenceForTE",
132 &self.m_transitionInfoReferenceForTE,
133 )?;
134 serializer.serialize_field("fromStateId", &self.m_fromStateId)?;
135 serializer.serialize_field("toStateId", &self.m_toStateId)?;
136 serializer
137 .serialize_field(
138 "isReturnToPreviousState",
139 &self.m_isReturnToPreviousState,
140 )?;
141 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
142 serializer.end()
143 }
144 }
145};
146#[doc(hidden)]
147#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
148const _: () = {
149 use havok_serde as _serde;
150 #[automatically_derived]
151 impl<'de> _serde::Deserialize<'de> for hkbStateMachineActiveTransitionInfo {
152 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
153 where
154 __D: _serde::Deserializer<'de>,
155 {
156 #[allow(non_camel_case_types)]
157 enum __Field {
158 m_transitionEffectInternalStateInfo,
159 m_transitionInfoReference,
160 m_transitionInfoReferenceForTE,
161 m_fromStateId,
162 m_toStateId,
163 m_isReturnToPreviousState,
164 __ignore,
165 }
166 struct __FieldVisitor;
167 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
168 type Value = __Field;
169 fn expecting(
170 &self,
171 __formatter: &mut core::fmt::Formatter,
172 ) -> core::fmt::Result {
173 core::fmt::Formatter::write_str(__formatter, "field identifier")
174 }
175 #[allow(clippy::match_single_binding)]
177 #[allow(clippy::reversed_empty_ranges)]
178 #[allow(clippy::single_match)]
179 fn visit_key<__E>(
180 self,
181 __value: &str,
182 ) -> core::result::Result<Self::Value, __E>
183 where
184 __E: _serde::de::Error,
185 {
186 match __value {
187 "transitionEffectInternalStateInfo" => {
188 Ok(__Field::m_transitionEffectInternalStateInfo)
189 }
190 "transitionInfoReference" => {
191 Ok(__Field::m_transitionInfoReference)
192 }
193 "transitionInfoReferenceForTE" => {
194 Ok(__Field::m_transitionInfoReferenceForTE)
195 }
196 "fromStateId" => Ok(__Field::m_fromStateId),
197 "toStateId" => Ok(__Field::m_toStateId),
198 "isReturnToPreviousState" => {
199 Ok(__Field::m_isReturnToPreviousState)
200 }
201 _ => Ok(__Field::__ignore),
202 }
203 }
204 }
205 impl<'de> _serde::Deserialize<'de> for __Field {
206 #[inline]
207 fn deserialize<__D>(
208 __deserializer: __D,
209 ) -> core::result::Result<Self, __D::Error>
210 where
211 __D: _serde::Deserializer<'de>,
212 {
213 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
214 }
215 }
216 struct __hkbStateMachineActiveTransitionInfoVisitor<'de> {
217 marker: _serde::__private::PhantomData<
218 hkbStateMachineActiveTransitionInfo,
219 >,
220 lifetime: _serde::__private::PhantomData<&'de ()>,
221 }
222 #[allow(clippy::match_single_binding)]
223 #[allow(clippy::reversed_empty_ranges)]
224 #[allow(clippy::single_match)]
225 impl<'de> _serde::de::Visitor<'de>
226 for __hkbStateMachineActiveTransitionInfoVisitor<'de> {
227 type Value = hkbStateMachineActiveTransitionInfo;
228 fn expecting(
229 &self,
230 __formatter: &mut core::fmt::Formatter,
231 ) -> core::fmt::Result {
232 core::fmt::Formatter::write_str(
233 __formatter,
234 "struct hkbStateMachineActiveTransitionInfo",
235 )
236 }
237 fn visit_struct_for_bytes<__A>(
238 self,
239 mut __map: __A,
240 ) -> _serde::__private::Result<Self::Value, __A::Error>
241 where
242 __A: _serde::de::MapAccess<'de>,
243 {
244 let __ptr = __A::class_ptr(&mut __map);
245 let mut m_transitionEffect: _serde::__private::Option<Pointer> = _serde::__private::None;
246 let mut m_transitionEffectInternalStateInfo: _serde::__private::Option<
247 Pointer,
248 > = _serde::__private::None;
249 let mut m_transitionInfoReference: _serde::__private::Option<
250 hkbStateMachineTransitionInfoReference,
251 > = _serde::__private::None;
252 let mut m_transitionInfoReferenceForTE: _serde::__private::Option<
253 hkbStateMachineTransitionInfoReference,
254 > = _serde::__private::None;
255 let mut m_fromStateId: _serde::__private::Option<i32> = _serde::__private::None;
256 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
257 let mut m_isReturnToPreviousState: _serde::__private::Option<bool> = _serde::__private::None;
258 for i in 0..7usize {
259 match i {
260 0usize => {
261 if _serde::__private::Option::is_some(&m_transitionEffect) {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::duplicate_field(
264 "transitionEffect",
265 ),
266 );
267 }
268 m_transitionEffect = _serde::__private::Some(
269 match __A::next_value::<Pointer>(&mut __map) {
270 _serde::__private::Ok(__val) => __val,
271 _serde::__private::Err(__err) => {
272 return _serde::__private::Err(__err);
273 }
274 },
275 );
276 }
277 1usize => {
278 if _serde::__private::Option::is_some(
279 &m_transitionEffectInternalStateInfo,
280 ) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "transitionEffectInternalStateInfo",
284 ),
285 );
286 }
287 m_transitionEffectInternalStateInfo = _serde::__private::Some(
288 match __A::next_value::<Pointer>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 2usize => {
297 if _serde::__private::Option::is_some(
298 &m_transitionInfoReference,
299 ) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "transitionInfoReference",
303 ),
304 );
305 }
306 m_transitionInfoReference = _serde::__private::Some(
307 match __A::next_value::<
308 hkbStateMachineTransitionInfoReference,
309 >(&mut __map) {
310 _serde::__private::Ok(__val) => __val,
311 _serde::__private::Err(__err) => {
312 return _serde::__private::Err(__err);
313 }
314 },
315 );
316 }
317 3usize => {
318 if _serde::__private::Option::is_some(
319 &m_transitionInfoReferenceForTE,
320 ) {
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::duplicate_field(
323 "transitionInfoReferenceForTE",
324 ),
325 );
326 }
327 m_transitionInfoReferenceForTE = _serde::__private::Some(
328 match __A::next_value::<
329 hkbStateMachineTransitionInfoReference,
330 >(&mut __map) {
331 _serde::__private::Ok(__val) => __val,
332 _serde::__private::Err(__err) => {
333 return _serde::__private::Err(__err);
334 }
335 },
336 );
337 }
338 4usize => {
339 if _serde::__private::Option::is_some(&m_fromStateId) {
340 return _serde::__private::Err(
341 <__A::Error as _serde::de::Error>::duplicate_field(
342 "fromStateId",
343 ),
344 );
345 }
346 m_fromStateId = _serde::__private::Some(
347 match __A::next_value::<i32>(&mut __map) {
348 _serde::__private::Ok(__val) => __val,
349 _serde::__private::Err(__err) => {
350 return _serde::__private::Err(__err);
351 }
352 },
353 );
354 }
355 5usize => {
356 if _serde::__private::Option::is_some(&m_toStateId) {
357 return _serde::__private::Err(
358 <__A::Error as _serde::de::Error>::duplicate_field(
359 "toStateId",
360 ),
361 );
362 }
363 m_toStateId = _serde::__private::Some(
364 match __A::next_value::<i32>(&mut __map) {
365 _serde::__private::Ok(__val) => __val,
366 _serde::__private::Err(__err) => {
367 return _serde::__private::Err(__err);
368 }
369 },
370 );
371 }
372 6usize => {
373 if _serde::__private::Option::is_some(
374 &m_isReturnToPreviousState,
375 ) {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::duplicate_field(
378 "isReturnToPreviousState",
379 ),
380 );
381 }
382 m_isReturnToPreviousState = _serde::__private::Some(
383 match __A::next_value::<bool>(&mut __map) {
384 _serde::__private::Ok(__val) => __val,
385 _serde::__private::Err(__err) => {
386 return _serde::__private::Err(__err);
387 }
388 },
389 );
390 }
391 _ => {}
392 }
393 }
394 __A::pad(&mut __map, 3usize, 3usize)?;
395 let m_transitionEffect = match m_transitionEffect {
396 _serde::__private::Some(__field) => __field,
397 _serde::__private::None => {
398 return _serde::__private::Err(
399 <__A::Error as _serde::de::Error>::missing_field(
400 "transitionEffect",
401 ),
402 );
403 }
404 };
405 let m_transitionEffectInternalStateInfo = match m_transitionEffectInternalStateInfo {
406 _serde::__private::Some(__field) => __field,
407 _serde::__private::None => {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::missing_field(
410 "transitionEffectInternalStateInfo",
411 ),
412 );
413 }
414 };
415 let m_transitionInfoReference = match m_transitionInfoReference {
416 _serde::__private::Some(__field) => __field,
417 _serde::__private::None => {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::missing_field(
420 "transitionInfoReference",
421 ),
422 );
423 }
424 };
425 let m_transitionInfoReferenceForTE = match m_transitionInfoReferenceForTE {
426 _serde::__private::Some(__field) => __field,
427 _serde::__private::None => {
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::missing_field(
430 "transitionInfoReferenceForTE",
431 ),
432 );
433 }
434 };
435 let m_fromStateId = match m_fromStateId {
436 _serde::__private::Some(__field) => __field,
437 _serde::__private::None => {
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::missing_field(
440 "fromStateId",
441 ),
442 );
443 }
444 };
445 let m_toStateId = match m_toStateId {
446 _serde::__private::Some(__field) => __field,
447 _serde::__private::None => {
448 return _serde::__private::Err(
449 <__A::Error as _serde::de::Error>::missing_field(
450 "toStateId",
451 ),
452 );
453 }
454 };
455 let m_isReturnToPreviousState = match m_isReturnToPreviousState {
456 _serde::__private::Some(__field) => __field,
457 _serde::__private::None => {
458 return _serde::__private::Err(
459 <__A::Error as _serde::de::Error>::missing_field(
460 "isReturnToPreviousState",
461 ),
462 );
463 }
464 };
465 _serde::__private::Ok(hkbStateMachineActiveTransitionInfo {
466 __ptr,
467 m_transitionEffect,
468 m_transitionEffectInternalStateInfo,
469 m_transitionInfoReference,
470 m_transitionInfoReferenceForTE,
471 m_fromStateId,
472 m_toStateId,
473 m_isReturnToPreviousState,
474 })
475 }
476 #[allow(clippy::manual_unwrap_or_default)]
477 fn visit_struct<__A>(
478 self,
479 mut __map: __A,
480 ) -> _serde::__private::Result<Self::Value, __A::Error>
481 where
482 __A: _serde::de::MapAccess<'de>,
483 {
484 let mut m_transitionEffectInternalStateInfo: _serde::__private::Option<
485 Pointer,
486 > = _serde::__private::None;
487 let mut m_transitionInfoReference: _serde::__private::Option<
488 hkbStateMachineTransitionInfoReference,
489 > = _serde::__private::None;
490 let mut m_transitionInfoReferenceForTE: _serde::__private::Option<
491 hkbStateMachineTransitionInfoReference,
492 > = _serde::__private::None;
493 let mut m_fromStateId: _serde::__private::Option<i32> = _serde::__private::None;
494 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
495 let mut m_isReturnToPreviousState: _serde::__private::Option<bool> = _serde::__private::None;
496 while let _serde::__private::Some(__key) = {
497 __A::next_key::<__Field>(&mut __map)?
498 } {
499 match __key {
500 __Field::m_transitionEffectInternalStateInfo => {
501 #[cfg(
502 any(feature = "strict", feature = "ignore_duplicates")
503 )]
504 if _serde::__private::Option::is_some(
505 &m_transitionEffectInternalStateInfo,
506 ) {
507 #[cfg(feature = "ignore_duplicates")]
508 {
509 __A::skip_value(&mut __map)?;
510 continue;
511 }
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "transitionEffectInternalStateInfo",
516 ),
517 );
518 }
519 m_transitionEffectInternalStateInfo = _serde::__private::Some(
520 match __A::next_value::<Pointer>(&mut __map) {
521 _serde::__private::Ok(__val) => __val,
522 _serde::__private::Err(__err) => {
523 return _serde::__private::Err(__err);
524 }
525 },
526 );
527 }
528 __Field::m_transitionInfoReference => {
529 #[cfg(
530 any(feature = "strict", feature = "ignore_duplicates")
531 )]
532 if _serde::__private::Option::is_some(
533 &m_transitionInfoReference,
534 ) {
535 #[cfg(feature = "ignore_duplicates")]
536 {
537 __A::skip_value(&mut __map)?;
538 continue;
539 }
540 #[cfg(feature = "strict")]
541 return _serde::__private::Err(
542 <__A::Error as _serde::de::Error>::duplicate_field(
543 "transitionInfoReference",
544 ),
545 );
546 }
547 m_transitionInfoReference = _serde::__private::Some(
548 match __A::next_value::<
549 hkbStateMachineTransitionInfoReference,
550 >(&mut __map) {
551 _serde::__private::Ok(__val) => __val,
552 _serde::__private::Err(__err) => {
553 return _serde::__private::Err(__err);
554 }
555 },
556 );
557 }
558 __Field::m_transitionInfoReferenceForTE => {
559 #[cfg(
560 any(feature = "strict", feature = "ignore_duplicates")
561 )]
562 if _serde::__private::Option::is_some(
563 &m_transitionInfoReferenceForTE,
564 ) {
565 #[cfg(feature = "ignore_duplicates")]
566 {
567 __A::skip_value(&mut __map)?;
568 continue;
569 }
570 #[cfg(feature = "strict")]
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::duplicate_field(
573 "transitionInfoReferenceForTE",
574 ),
575 );
576 }
577 m_transitionInfoReferenceForTE = _serde::__private::Some(
578 match __A::next_value::<
579 hkbStateMachineTransitionInfoReference,
580 >(&mut __map) {
581 _serde::__private::Ok(__val) => __val,
582 _serde::__private::Err(__err) => {
583 return _serde::__private::Err(__err);
584 }
585 },
586 );
587 }
588 __Field::m_fromStateId => {
589 #[cfg(
590 any(feature = "strict", feature = "ignore_duplicates")
591 )]
592 if _serde::__private::Option::is_some(&m_fromStateId) {
593 #[cfg(feature = "ignore_duplicates")]
594 {
595 __A::skip_value(&mut __map)?;
596 continue;
597 }
598 #[cfg(feature = "strict")]
599 return _serde::__private::Err(
600 <__A::Error as _serde::de::Error>::duplicate_field(
601 "fromStateId",
602 ),
603 );
604 }
605 m_fromStateId = _serde::__private::Some(
606 match __A::next_value::<i32>(&mut __map) {
607 _serde::__private::Ok(__val) => __val,
608 _serde::__private::Err(__err) => {
609 return _serde::__private::Err(__err);
610 }
611 },
612 );
613 }
614 __Field::m_toStateId => {
615 #[cfg(
616 any(feature = "strict", feature = "ignore_duplicates")
617 )]
618 if _serde::__private::Option::is_some(&m_toStateId) {
619 #[cfg(feature = "ignore_duplicates")]
620 {
621 __A::skip_value(&mut __map)?;
622 continue;
623 }
624 #[cfg(feature = "strict")]
625 return _serde::__private::Err(
626 <__A::Error as _serde::de::Error>::duplicate_field(
627 "toStateId",
628 ),
629 );
630 }
631 m_toStateId = _serde::__private::Some(
632 match __A::next_value::<i32>(&mut __map) {
633 _serde::__private::Ok(__val) => __val,
634 _serde::__private::Err(__err) => {
635 return _serde::__private::Err(__err);
636 }
637 },
638 );
639 }
640 __Field::m_isReturnToPreviousState => {
641 #[cfg(
642 any(feature = "strict", feature = "ignore_duplicates")
643 )]
644 if _serde::__private::Option::is_some(
645 &m_isReturnToPreviousState,
646 ) {
647 #[cfg(feature = "ignore_duplicates")]
648 {
649 __A::skip_value(&mut __map)?;
650 continue;
651 }
652 #[cfg(feature = "strict")]
653 return _serde::__private::Err(
654 <__A::Error as _serde::de::Error>::duplicate_field(
655 "isReturnToPreviousState",
656 ),
657 );
658 }
659 m_isReturnToPreviousState = _serde::__private::Some(
660 match __A::next_value::<bool>(&mut __map) {
661 _serde::__private::Ok(__val) => __val,
662 _serde::__private::Err(__err) => {
663 return _serde::__private::Err(__err);
664 }
665 },
666 );
667 }
668 _ => __A::skip_value(&mut __map)?,
669 }
670 }
671 let m_transitionEffectInternalStateInfo = match m_transitionEffectInternalStateInfo {
672 _serde::__private::Some(__field) => __field,
673 _serde::__private::None => {
674 #[cfg(feature = "strict")]
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::missing_field(
677 "transitionEffectInternalStateInfo",
678 ),
679 );
680 #[cfg(not(feature = "strict"))] Default::default()
681 }
682 };
683 let m_transitionInfoReference = match m_transitionInfoReference {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 #[cfg(feature = "strict")]
687 return _serde::__private::Err(
688 <__A::Error as _serde::de::Error>::missing_field(
689 "transitionInfoReference",
690 ),
691 );
692 #[cfg(not(feature = "strict"))] Default::default()
693 }
694 };
695 let m_transitionInfoReferenceForTE = match m_transitionInfoReferenceForTE {
696 _serde::__private::Some(__field) => __field,
697 _serde::__private::None => {
698 #[cfg(feature = "strict")]
699 return _serde::__private::Err(
700 <__A::Error as _serde::de::Error>::missing_field(
701 "transitionInfoReferenceForTE",
702 ),
703 );
704 #[cfg(not(feature = "strict"))] Default::default()
705 }
706 };
707 let m_fromStateId = match m_fromStateId {
708 _serde::__private::Some(__field) => __field,
709 _serde::__private::None => {
710 #[cfg(feature = "strict")]
711 return _serde::__private::Err(
712 <__A::Error as _serde::de::Error>::missing_field(
713 "fromStateId",
714 ),
715 );
716 #[cfg(not(feature = "strict"))] Default::default()
717 }
718 };
719 let m_toStateId = match m_toStateId {
720 _serde::__private::Some(__field) => __field,
721 _serde::__private::None => {
722 #[cfg(feature = "strict")]
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::missing_field(
725 "toStateId",
726 ),
727 );
728 #[cfg(not(feature = "strict"))] Default::default()
729 }
730 };
731 let m_isReturnToPreviousState = match m_isReturnToPreviousState {
732 _serde::__private::Some(__field) => __field,
733 _serde::__private::None => {
734 #[cfg(feature = "strict")]
735 return _serde::__private::Err(
736 <__A::Error as _serde::de::Error>::missing_field(
737 "isReturnToPreviousState",
738 ),
739 );
740 #[cfg(not(feature = "strict"))] Default::default()
741 }
742 };
743 let __ptr = __A::class_ptr(&mut __map);
744 _serde::__private::Ok(hkbStateMachineActiveTransitionInfo {
745 __ptr,
746 m_transitionEffectInternalStateInfo,
747 m_transitionInfoReference,
748 m_transitionInfoReferenceForTE,
749 m_fromStateId,
750 m_toStateId,
751 m_isReturnToPreviousState,
752 ..Default::default()
753 })
754 }
755 }
756 const FIELDS: &[&str] = &[
757 "transitionEffect",
758 "transitionEffectInternalStateInfo",
759 "transitionInfoReference",
760 "transitionInfoReferenceForTE",
761 "fromStateId",
762 "toStateId",
763 "isReturnToPreviousState",
764 ];
765 _serde::Deserializer::deserialize_struct(
766 deserializer,
767 "hkbStateMachineActiveTransitionInfo",
768 FIELDS,
769 __hkbStateMachineActiveTransitionInfoVisitor {
770 marker: _serde::__private::PhantomData::<
771 hkbStateMachineActiveTransitionInfo,
772 >,
773 lifetime: _serde::__private::PhantomData,
774 },
775 )
776 }
777 }
778};