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 hkbStateMachineStateInfo<'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 pub parent: hkbBindable,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "listeners"))]
35 #[cfg_attr(feature = "serde", serde(rename = "listeners"))]
36 pub m_listeners: Vec<Pointer>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "enterNotifyEvents"))]
42 #[cfg_attr(feature = "serde", serde(rename = "enterNotifyEvents"))]
43 pub m_enterNotifyEvents: Pointer,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "exitNotifyEvents"))]
49 #[cfg_attr(feature = "serde", serde(rename = "exitNotifyEvents"))]
50 pub m_exitNotifyEvents: Pointer,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "transitions"))]
56 #[cfg_attr(feature = "serde", serde(rename = "transitions"))]
57 pub m_transitions: Pointer,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "generator"))]
63 #[cfg_attr(feature = "serde", serde(rename = "generator"))]
64 pub m_generator: Pointer,
65 #[cfg_attr(feature = "serde", serde(borrow))]
70 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
71 #[cfg_attr(feature = "serde", serde(rename = "name"))]
72 pub m_name: StringPtr<'a>,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "stateId"))]
78 #[cfg_attr(feature = "serde", serde(rename = "stateId"))]
79 pub m_stateId: i32,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "probability"))]
85 #[cfg_attr(feature = "serde", serde(rename = "probability"))]
86 pub m_probability: f32,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "enable"))]
92 #[cfg_attr(feature = "serde", serde(rename = "enable"))]
93 pub m_enable: bool,
94}
95const _: () = {
96 use havok_serde as _serde;
97 impl<'a> _serde::HavokClass for hkbStateMachineStateInfo<'a> {
98 #[inline]
99 fn name(&self) -> &'static str {
100 "hkbStateMachineStateInfo"
101 }
102 #[inline]
103 fn signature(&self) -> _serde::__private::Signature {
104 _serde::__private::Signature::new(0xed7f9d0)
105 }
106 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
107 fn deps_indexes(&self) -> Vec<usize> {
108 let mut v = Vec::new();
109 v.push(self.parent.m_variableBindingSet.get());
110 v.extend(self.m_listeners.iter().map(|ptr| ptr.get()));
111 v.push(self.m_enterNotifyEvents.get());
112 v.push(self.m_exitNotifyEvents.get());
113 v.push(self.m_transitions.get());
114 v.push(self.m_generator.get());
115 v
116 }
117 }
118 impl<'a> _serde::Serialize for hkbStateMachineStateInfo<'a> {
119 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
120 where
121 S: _serde::ser::Serializer,
122 {
123 let class_meta = self
124 .__ptr
125 .map(|name| (name, _serde::__private::Signature::new(0xed7f9d0)));
126 let mut serializer = __serializer
127 .serialize_struct(
128 "hkbStateMachineStateInfo",
129 class_meta,
130 (72u64, 120u64),
131 )?;
132 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
133 serializer
134 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
135 serializer
136 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
137 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
138 serializer
139 .serialize_field(
140 "variableBindingSet",
141 &self.parent.m_variableBindingSet,
142 )?;
143 serializer
144 .skip_array_field(
145 "cachedBindables",
146 &self.parent.m_cachedBindables,
147 TypeSize::NonPtr,
148 )?;
149 serializer
150 .skip_field("areBindablesCached", &self.parent.m_areBindablesCached)?;
151 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
152 serializer
153 .serialize_array_field(
154 "listeners",
155 &self.m_listeners,
156 TypeSize::NonPtr,
157 )?;
158 serializer.serialize_field("enterNotifyEvents", &self.m_enterNotifyEvents)?;
159 serializer.serialize_field("exitNotifyEvents", &self.m_exitNotifyEvents)?;
160 serializer.serialize_field("transitions", &self.m_transitions)?;
161 serializer.serialize_field("generator", &self.m_generator)?;
162 serializer.serialize_field("name", &self.m_name)?;
163 serializer.serialize_field("stateId", &self.m_stateId)?;
164 serializer.serialize_field("probability", &self.m_probability)?;
165 serializer.serialize_field("enable", &self.m_enable)?;
166 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
167 serializer.end()
168 }
169 }
170};
171#[doc(hidden)]
172#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
173const _: () = {
174 use havok_serde as _serde;
175 #[automatically_derived]
176 impl<'de> _serde::Deserialize<'de> for hkbStateMachineStateInfo<'de> {
177 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
178 where
179 __D: _serde::Deserializer<'de>,
180 {
181 #[allow(non_camel_case_types)]
182 enum __Field {
183 m_variableBindingSet,
184 m_listeners,
185 m_enterNotifyEvents,
186 m_exitNotifyEvents,
187 m_transitions,
188 m_generator,
189 m_name,
190 m_stateId,
191 m_probability,
192 m_enable,
193 __ignore,
194 }
195 struct __FieldVisitor;
196 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
197 type Value = __Field;
198 fn expecting(
199 &self,
200 __formatter: &mut core::fmt::Formatter,
201 ) -> core::fmt::Result {
202 core::fmt::Formatter::write_str(__formatter, "field identifier")
203 }
204 #[allow(clippy::match_single_binding)]
206 #[allow(clippy::reversed_empty_ranges)]
207 #[allow(clippy::single_match)]
208 fn visit_key<__E>(
209 self,
210 __value: &str,
211 ) -> core::result::Result<Self::Value, __E>
212 where
213 __E: _serde::de::Error,
214 {
215 match __value {
216 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
217 "listeners" => Ok(__Field::m_listeners),
218 "enterNotifyEvents" => Ok(__Field::m_enterNotifyEvents),
219 "exitNotifyEvents" => Ok(__Field::m_exitNotifyEvents),
220 "transitions" => Ok(__Field::m_transitions),
221 "generator" => Ok(__Field::m_generator),
222 "name" => Ok(__Field::m_name),
223 "stateId" => Ok(__Field::m_stateId),
224 "probability" => Ok(__Field::m_probability),
225 "enable" => Ok(__Field::m_enable),
226 _ => Ok(__Field::__ignore),
227 }
228 }
229 }
230 impl<'de> _serde::Deserialize<'de> for __Field {
231 #[inline]
232 fn deserialize<__D>(
233 __deserializer: __D,
234 ) -> core::result::Result<Self, __D::Error>
235 where
236 __D: _serde::Deserializer<'de>,
237 {
238 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
239 }
240 }
241 struct __hkbStateMachineStateInfoVisitor<'de> {
242 marker: _serde::__private::PhantomData<hkbStateMachineStateInfo<'de>>,
243 lifetime: _serde::__private::PhantomData<&'de ()>,
244 }
245 #[allow(clippy::match_single_binding)]
246 #[allow(clippy::reversed_empty_ranges)]
247 #[allow(clippy::single_match)]
248 impl<'de> _serde::de::Visitor<'de>
249 for __hkbStateMachineStateInfoVisitor<'de> {
250 type Value = hkbStateMachineStateInfo<'de>;
251 fn expecting(
252 &self,
253 __formatter: &mut core::fmt::Formatter,
254 ) -> core::fmt::Result {
255 core::fmt::Formatter::write_str(
256 __formatter,
257 "struct hkbStateMachineStateInfo",
258 )
259 }
260 fn visit_struct_for_bytes<__A>(
261 self,
262 mut __map: __A,
263 ) -> _serde::__private::Result<Self::Value, __A::Error>
264 where
265 __A: _serde::de::MapAccess<'de>,
266 {
267 let __ptr = __A::class_ptr(&mut __map);
268 let parent = __A::parent_value(&mut __map)?;
269 let mut m_listeners: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
270 let mut m_enterNotifyEvents: _serde::__private::Option<Pointer> = _serde::__private::None;
271 let mut m_exitNotifyEvents: _serde::__private::Option<Pointer> = _serde::__private::None;
272 let mut m_transitions: _serde::__private::Option<Pointer> = _serde::__private::None;
273 let mut m_generator: _serde::__private::Option<Pointer> = _serde::__private::None;
274 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
275 let mut m_stateId: _serde::__private::Option<i32> = _serde::__private::None;
276 let mut m_probability: _serde::__private::Option<f32> = _serde::__private::None;
277 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
278 for i in 0..9usize {
279 match i {
280 0usize => {
281 if _serde::__private::Option::is_some(&m_listeners) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "listeners",
285 ),
286 );
287 }
288 m_listeners = _serde::__private::Some(
289 match __A::next_value::<Vec<Pointer>>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 1usize => {
298 if _serde::__private::Option::is_some(
299 &m_enterNotifyEvents,
300 ) {
301 return _serde::__private::Err(
302 <__A::Error as _serde::de::Error>::duplicate_field(
303 "enterNotifyEvents",
304 ),
305 );
306 }
307 m_enterNotifyEvents = _serde::__private::Some(
308 match __A::next_value::<Pointer>(&mut __map) {
309 _serde::__private::Ok(__val) => __val,
310 _serde::__private::Err(__err) => {
311 return _serde::__private::Err(__err);
312 }
313 },
314 );
315 }
316 2usize => {
317 if _serde::__private::Option::is_some(&m_exitNotifyEvents) {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::duplicate_field(
320 "exitNotifyEvents",
321 ),
322 );
323 }
324 m_exitNotifyEvents = _serde::__private::Some(
325 match __A::next_value::<Pointer>(&mut __map) {
326 _serde::__private::Ok(__val) => __val,
327 _serde::__private::Err(__err) => {
328 return _serde::__private::Err(__err);
329 }
330 },
331 );
332 }
333 3usize => {
334 if _serde::__private::Option::is_some(&m_transitions) {
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::duplicate_field(
337 "transitions",
338 ),
339 );
340 }
341 m_transitions = _serde::__private::Some(
342 match __A::next_value::<Pointer>(&mut __map) {
343 _serde::__private::Ok(__val) => __val,
344 _serde::__private::Err(__err) => {
345 return _serde::__private::Err(__err);
346 }
347 },
348 );
349 }
350 4usize => {
351 if _serde::__private::Option::is_some(&m_generator) {
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "generator",
355 ),
356 );
357 }
358 m_generator = _serde::__private::Some(
359 match __A::next_value::<Pointer>(&mut __map) {
360 _serde::__private::Ok(__val) => __val,
361 _serde::__private::Err(__err) => {
362 return _serde::__private::Err(__err);
363 }
364 },
365 );
366 }
367 5usize => {
368 if _serde::__private::Option::is_some(&m_name) {
369 return _serde::__private::Err(
370 <__A::Error as _serde::de::Error>::duplicate_field("name"),
371 );
372 }
373 m_name = _serde::__private::Some(
374 match __A::next_value::<StringPtr<'de>>(&mut __map) {
375 _serde::__private::Ok(__val) => __val,
376 _serde::__private::Err(__err) => {
377 return _serde::__private::Err(__err);
378 }
379 },
380 );
381 }
382 6usize => {
383 if _serde::__private::Option::is_some(&m_stateId) {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field(
386 "stateId",
387 ),
388 );
389 }
390 m_stateId = _serde::__private::Some(
391 match __A::next_value::<i32>(&mut __map) {
392 _serde::__private::Ok(__val) => __val,
393 _serde::__private::Err(__err) => {
394 return _serde::__private::Err(__err);
395 }
396 },
397 );
398 }
399 7usize => {
400 if _serde::__private::Option::is_some(&m_probability) {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "probability",
404 ),
405 );
406 }
407 m_probability = _serde::__private::Some(
408 match __A::next_value::<f32>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 8usize => {
417 if _serde::__private::Option::is_some(&m_enable) {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
420 );
421 }
422 m_enable = _serde::__private::Some(
423 match __A::next_value::<bool>(&mut __map) {
424 _serde::__private::Ok(__val) => __val,
425 _serde::__private::Err(__err) => {
426 return _serde::__private::Err(__err);
427 }
428 },
429 );
430 }
431 _ => {}
432 }
433 }
434 __A::pad(&mut __map, 3usize, 7usize)?;
435 let m_listeners = match m_listeners {
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 "listeners",
441 ),
442 );
443 }
444 };
445 let m_enterNotifyEvents = match m_enterNotifyEvents {
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 "enterNotifyEvents",
451 ),
452 );
453 }
454 };
455 let m_exitNotifyEvents = match m_exitNotifyEvents {
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 "exitNotifyEvents",
461 ),
462 );
463 }
464 };
465 let m_transitions = match m_transitions {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::missing_field(
470 "transitions",
471 ),
472 );
473 }
474 };
475 let m_generator = match m_generator {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field(
480 "generator",
481 ),
482 );
483 }
484 };
485 let m_name = match m_name {
486 _serde::__private::Some(__field) => __field,
487 _serde::__private::None => {
488 return _serde::__private::Err(
489 <__A::Error as _serde::de::Error>::missing_field("name"),
490 );
491 }
492 };
493 let m_stateId = match m_stateId {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::missing_field("stateId"),
498 );
499 }
500 };
501 let m_probability = match m_probability {
502 _serde::__private::Some(__field) => __field,
503 _serde::__private::None => {
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::missing_field(
506 "probability",
507 ),
508 );
509 }
510 };
511 let m_enable = match m_enable {
512 _serde::__private::Some(__field) => __field,
513 _serde::__private::None => {
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::missing_field("enable"),
516 );
517 }
518 };
519 _serde::__private::Ok(hkbStateMachineStateInfo {
520 __ptr,
521 parent,
522 m_listeners,
523 m_enterNotifyEvents,
524 m_exitNotifyEvents,
525 m_transitions,
526 m_generator,
527 m_name,
528 m_stateId,
529 m_probability,
530 m_enable,
531 })
532 }
533 #[allow(clippy::manual_unwrap_or_default)]
534 fn visit_struct<__A>(
535 self,
536 mut __map: __A,
537 ) -> _serde::__private::Result<Self::Value, __A::Error>
538 where
539 __A: _serde::de::MapAccess<'de>,
540 {
541 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
542 let mut m_listeners: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
543 let mut m_enterNotifyEvents: _serde::__private::Option<Pointer> = _serde::__private::None;
544 let mut m_exitNotifyEvents: _serde::__private::Option<Pointer> = _serde::__private::None;
545 let mut m_transitions: _serde::__private::Option<Pointer> = _serde::__private::None;
546 let mut m_generator: _serde::__private::Option<Pointer> = _serde::__private::None;
547 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
548 let mut m_stateId: _serde::__private::Option<i32> = _serde::__private::None;
549 let mut m_probability: _serde::__private::Option<f32> = _serde::__private::None;
550 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
551 while let _serde::__private::Some(__key) = {
552 __A::next_key::<__Field>(&mut __map)?
553 } {
554 match __key {
555 __Field::m_variableBindingSet => {
556 #[cfg(
557 any(feature = "strict", feature = "ignore_duplicates")
558 )]
559 if _serde::__private::Option::is_some(
560 &m_variableBindingSet,
561 ) {
562 #[cfg(feature = "ignore_duplicates")]
563 {
564 __A::skip_value(&mut __map)?;
565 continue;
566 }
567 #[cfg(feature = "strict")]
568 return _serde::__private::Err(
569 <__A::Error as _serde::de::Error>::duplicate_field(
570 "variableBindingSet",
571 ),
572 );
573 }
574 m_variableBindingSet = _serde::__private::Some(
575 match __A::next_value::<Pointer>(&mut __map) {
576 _serde::__private::Ok(__val) => __val,
577 _serde::__private::Err(__err) => {
578 return _serde::__private::Err(__err);
579 }
580 },
581 );
582 }
583 __Field::m_listeners => {
584 #[cfg(
585 any(feature = "strict", feature = "ignore_duplicates")
586 )]
587 if _serde::__private::Option::is_some(&m_listeners) {
588 #[cfg(feature = "ignore_duplicates")]
589 {
590 __A::skip_value(&mut __map)?;
591 continue;
592 }
593 #[cfg(feature = "strict")]
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::duplicate_field(
596 "listeners",
597 ),
598 );
599 }
600 m_listeners = _serde::__private::Some(
601 match __A::next_value::<Vec<Pointer>>(&mut __map) {
602 _serde::__private::Ok(__val) => __val,
603 _serde::__private::Err(__err) => {
604 return _serde::__private::Err(__err);
605 }
606 },
607 );
608 }
609 __Field::m_enterNotifyEvents => {
610 #[cfg(
611 any(feature = "strict", feature = "ignore_duplicates")
612 )]
613 if _serde::__private::Option::is_some(
614 &m_enterNotifyEvents,
615 ) {
616 #[cfg(feature = "ignore_duplicates")]
617 {
618 __A::skip_value(&mut __map)?;
619 continue;
620 }
621 #[cfg(feature = "strict")]
622 return _serde::__private::Err(
623 <__A::Error as _serde::de::Error>::duplicate_field(
624 "enterNotifyEvents",
625 ),
626 );
627 }
628 m_enterNotifyEvents = _serde::__private::Some(
629 match __A::next_value::<Pointer>(&mut __map) {
630 _serde::__private::Ok(__val) => __val,
631 _serde::__private::Err(__err) => {
632 return _serde::__private::Err(__err);
633 }
634 },
635 );
636 }
637 __Field::m_exitNotifyEvents => {
638 #[cfg(
639 any(feature = "strict", feature = "ignore_duplicates")
640 )]
641 if _serde::__private::Option::is_some(&m_exitNotifyEvents) {
642 #[cfg(feature = "ignore_duplicates")]
643 {
644 __A::skip_value(&mut __map)?;
645 continue;
646 }
647 #[cfg(feature = "strict")]
648 return _serde::__private::Err(
649 <__A::Error as _serde::de::Error>::duplicate_field(
650 "exitNotifyEvents",
651 ),
652 );
653 }
654 m_exitNotifyEvents = _serde::__private::Some(
655 match __A::next_value::<Pointer>(&mut __map) {
656 _serde::__private::Ok(__val) => __val,
657 _serde::__private::Err(__err) => {
658 return _serde::__private::Err(__err);
659 }
660 },
661 );
662 }
663 __Field::m_transitions => {
664 #[cfg(
665 any(feature = "strict", feature = "ignore_duplicates")
666 )]
667 if _serde::__private::Option::is_some(&m_transitions) {
668 #[cfg(feature = "ignore_duplicates")]
669 {
670 __A::skip_value(&mut __map)?;
671 continue;
672 }
673 #[cfg(feature = "strict")]
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::duplicate_field(
676 "transitions",
677 ),
678 );
679 }
680 m_transitions = _serde::__private::Some(
681 match __A::next_value::<Pointer>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 __Field::m_generator => {
690 #[cfg(
691 any(feature = "strict", feature = "ignore_duplicates")
692 )]
693 if _serde::__private::Option::is_some(&m_generator) {
694 #[cfg(feature = "ignore_duplicates")]
695 {
696 __A::skip_value(&mut __map)?;
697 continue;
698 }
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::duplicate_field(
702 "generator",
703 ),
704 );
705 }
706 m_generator = _serde::__private::Some(
707 match __A::next_value::<Pointer>(&mut __map) {
708 _serde::__private::Ok(__val) => __val,
709 _serde::__private::Err(__err) => {
710 return _serde::__private::Err(__err);
711 }
712 },
713 );
714 }
715 __Field::m_name => {
716 #[cfg(
717 any(feature = "strict", feature = "ignore_duplicates")
718 )]
719 if _serde::__private::Option::is_some(&m_name) {
720 #[cfg(feature = "ignore_duplicates")]
721 {
722 __A::skip_value(&mut __map)?;
723 continue;
724 }
725 #[cfg(feature = "strict")]
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::duplicate_field("name"),
728 );
729 }
730 m_name = _serde::__private::Some(
731 match __A::next_value::<StringPtr<'de>>(&mut __map) {
732 _serde::__private::Ok(__val) => __val,
733 _serde::__private::Err(__err) => {
734 return _serde::__private::Err(__err);
735 }
736 },
737 );
738 }
739 __Field::m_stateId => {
740 #[cfg(
741 any(feature = "strict", feature = "ignore_duplicates")
742 )]
743 if _serde::__private::Option::is_some(&m_stateId) {
744 #[cfg(feature = "ignore_duplicates")]
745 {
746 __A::skip_value(&mut __map)?;
747 continue;
748 }
749 #[cfg(feature = "strict")]
750 return _serde::__private::Err(
751 <__A::Error as _serde::de::Error>::duplicate_field(
752 "stateId",
753 ),
754 );
755 }
756 m_stateId = _serde::__private::Some(
757 match __A::next_value::<i32>(&mut __map) {
758 _serde::__private::Ok(__val) => __val,
759 _serde::__private::Err(__err) => {
760 return _serde::__private::Err(__err);
761 }
762 },
763 );
764 }
765 __Field::m_probability => {
766 #[cfg(
767 any(feature = "strict", feature = "ignore_duplicates")
768 )]
769 if _serde::__private::Option::is_some(&m_probability) {
770 #[cfg(feature = "ignore_duplicates")]
771 {
772 __A::skip_value(&mut __map)?;
773 continue;
774 }
775 #[cfg(feature = "strict")]
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::duplicate_field(
778 "probability",
779 ),
780 );
781 }
782 m_probability = _serde::__private::Some(
783 match __A::next_value::<f32>(&mut __map) {
784 _serde::__private::Ok(__val) => __val,
785 _serde::__private::Err(__err) => {
786 return _serde::__private::Err(__err);
787 }
788 },
789 );
790 }
791 __Field::m_enable => {
792 #[cfg(
793 any(feature = "strict", feature = "ignore_duplicates")
794 )]
795 if _serde::__private::Option::is_some(&m_enable) {
796 #[cfg(feature = "ignore_duplicates")]
797 {
798 __A::skip_value(&mut __map)?;
799 continue;
800 }
801 #[cfg(feature = "strict")]
802 return _serde::__private::Err(
803 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
804 );
805 }
806 m_enable = _serde::__private::Some(
807 match __A::next_value::<bool>(&mut __map) {
808 _serde::__private::Ok(__val) => __val,
809 _serde::__private::Err(__err) => {
810 return _serde::__private::Err(__err);
811 }
812 },
813 );
814 }
815 _ => __A::skip_value(&mut __map)?,
816 }
817 }
818 let m_variableBindingSet = match m_variableBindingSet {
819 _serde::__private::Some(__field) => __field,
820 _serde::__private::None => {
821 #[cfg(feature = "strict")]
822 return _serde::__private::Err(
823 <__A::Error as _serde::de::Error>::missing_field(
824 "variableBindingSet",
825 ),
826 );
827 #[cfg(not(feature = "strict"))] Default::default()
828 }
829 };
830 let m_listeners = match m_listeners {
831 _serde::__private::Some(__field) => __field,
832 _serde::__private::None => {
833 #[cfg(feature = "strict")]
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::missing_field(
836 "listeners",
837 ),
838 );
839 #[cfg(not(feature = "strict"))] Default::default()
840 }
841 };
842 let m_enterNotifyEvents = match m_enterNotifyEvents {
843 _serde::__private::Some(__field) => __field,
844 _serde::__private::None => {
845 #[cfg(feature = "strict")]
846 return _serde::__private::Err(
847 <__A::Error as _serde::de::Error>::missing_field(
848 "enterNotifyEvents",
849 ),
850 );
851 #[cfg(not(feature = "strict"))] Default::default()
852 }
853 };
854 let m_exitNotifyEvents = match m_exitNotifyEvents {
855 _serde::__private::Some(__field) => __field,
856 _serde::__private::None => {
857 #[cfg(feature = "strict")]
858 return _serde::__private::Err(
859 <__A::Error as _serde::de::Error>::missing_field(
860 "exitNotifyEvents",
861 ),
862 );
863 #[cfg(not(feature = "strict"))] Default::default()
864 }
865 };
866 let m_transitions = match m_transitions {
867 _serde::__private::Some(__field) => __field,
868 _serde::__private::None => {
869 #[cfg(feature = "strict")]
870 return _serde::__private::Err(
871 <__A::Error as _serde::de::Error>::missing_field(
872 "transitions",
873 ),
874 );
875 #[cfg(not(feature = "strict"))] Default::default()
876 }
877 };
878 let m_generator = match m_generator {
879 _serde::__private::Some(__field) => __field,
880 _serde::__private::None => {
881 #[cfg(feature = "strict")]
882 return _serde::__private::Err(
883 <__A::Error as _serde::de::Error>::missing_field(
884 "generator",
885 ),
886 );
887 #[cfg(not(feature = "strict"))] Default::default()
888 }
889 };
890 let m_name = match m_name {
891 _serde::__private::Some(__field) => __field,
892 _serde::__private::None => {
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field("name"),
896 );
897 #[cfg(not(feature = "strict"))] Default::default()
898 }
899 };
900 let m_stateId = match m_stateId {
901 _serde::__private::Some(__field) => __field,
902 _serde::__private::None => {
903 #[cfg(feature = "strict")]
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field("stateId"),
906 );
907 #[cfg(not(feature = "strict"))] Default::default()
908 }
909 };
910 let m_probability = match m_probability {
911 _serde::__private::Some(__field) => __field,
912 _serde::__private::None => {
913 #[cfg(feature = "strict")]
914 return _serde::__private::Err(
915 <__A::Error as _serde::de::Error>::missing_field(
916 "probability",
917 ),
918 );
919 #[cfg(not(feature = "strict"))] Default::default()
920 }
921 };
922 let m_enable = match m_enable {
923 _serde::__private::Some(__field) => __field,
924 _serde::__private::None => {
925 #[cfg(feature = "strict")]
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::missing_field("enable"),
928 );
929 #[cfg(not(feature = "strict"))] Default::default()
930 }
931 };
932 let __ptr = None;
933 let parent = hkBaseObject { __ptr };
934 let parent = hkReferencedObject {
935 __ptr,
936 parent,
937 ..Default::default()
938 };
939 let parent = hkbBindable {
940 __ptr,
941 parent,
942 m_variableBindingSet,
943 ..Default::default()
944 };
945 let __ptr = __A::class_ptr(&mut __map);
946 _serde::__private::Ok(hkbStateMachineStateInfo {
947 __ptr,
948 parent,
949 m_listeners,
950 m_enterNotifyEvents,
951 m_exitNotifyEvents,
952 m_transitions,
953 m_generator,
954 m_name,
955 m_stateId,
956 m_probability,
957 m_enable,
958 })
959 }
960 }
961 const FIELDS: &[&str] = &[
962 "listeners",
963 "enterNotifyEvents",
964 "exitNotifyEvents",
965 "transitions",
966 "generator",
967 "name",
968 "stateId",
969 "probability",
970 "enable",
971 ];
972 _serde::Deserializer::deserialize_struct(
973 deserializer,
974 "hkbStateMachineStateInfo",
975 FIELDS,
976 __hkbStateMachineStateInfoVisitor {
977 marker: _serde::__private::PhantomData::<hkbStateMachineStateInfo>,
978 lifetime: _serde::__private::PhantomData,
979 },
980 )
981 }
982 }
983};