havok_classes/generated/
hkbStateMachineStateInfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbStateMachineStateInfo`
5/// - version: `4`
6/// - signature: `0xed7f9d0`
7/// - size: ` 72`(x86)/`120`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkbBindable,
30    /// # C++ Info
31    /// - name: `listeners`(ctype: `hkArray<hkbStateListener*>`)
32    /// - offset: ` 28`(x86)/` 48`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "listeners"))]
35    #[cfg_attr(feature = "serde", serde(rename = "listeners"))]
36    pub m_listeners: Vec<Pointer>,
37    /// # C++ Info
38    /// - name: `enterNotifyEvents`(ctype: `struct hkbStateMachineEventPropertyArray*`)
39    /// - offset: ` 40`(x86)/` 64`(x86_64)
40    /// - type_size: `  4`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "enterNotifyEvents"))]
42    #[cfg_attr(feature = "serde", serde(rename = "enterNotifyEvents"))]
43    pub m_enterNotifyEvents: Pointer,
44    /// # C++ Info
45    /// - name: `exitNotifyEvents`(ctype: `struct hkbStateMachineEventPropertyArray*`)
46    /// - offset: ` 44`(x86)/` 72`(x86_64)
47    /// - type_size: `  4`(x86)/`  8`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "exitNotifyEvents"))]
49    #[cfg_attr(feature = "serde", serde(rename = "exitNotifyEvents"))]
50    pub m_exitNotifyEvents: Pointer,
51    /// # C++ Info
52    /// - name: `transitions`(ctype: `struct hkbStateMachineTransitionInfoArray*`)
53    /// - offset: ` 48`(x86)/` 80`(x86_64)
54    /// - type_size: `  4`(x86)/`  8`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "transitions"))]
56    #[cfg_attr(feature = "serde", serde(rename = "transitions"))]
57    pub m_transitions: Pointer,
58    /// # C++ Info
59    /// - name: `generator`(ctype: `struct hkbGenerator*`)
60    /// - offset: ` 52`(x86)/` 88`(x86_64)
61    /// - type_size: `  4`(x86)/`  8`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "generator"))]
63    #[cfg_attr(feature = "serde", serde(rename = "generator"))]
64    pub m_generator: Pointer,
65    /// # C++ Info
66    /// - name: `name`(ctype: `hkStringPtr`)
67    /// - offset: ` 56`(x86)/` 96`(x86_64)
68    /// - type_size: `  4`(x86)/`  8`(x86_64)
69    #[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    /// # C++ Info
74    /// - name: `stateId`(ctype: `hkInt32`)
75    /// - offset: ` 60`(x86)/`104`(x86_64)
76    /// - type_size: `  4`(x86)/`  4`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "stateId"))]
78    #[cfg_attr(feature = "serde", serde(rename = "stateId"))]
79    pub m_stateId: i32,
80    /// # C++ Info
81    /// - name: `probability`(ctype: `hkReal`)
82    /// - offset: ` 64`(x86)/`108`(x86_64)
83    /// - type_size: `  4`(x86)/`  4`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "probability"))]
85    #[cfg_attr(feature = "serde", serde(rename = "probability"))]
86    pub m_probability: f32,
87    /// # C++ Info
88    /// - name: `enable`(ctype: `hkBool`)
89    /// - offset: ` 68`(x86)/`112`(x86_64)
90    /// - type_size: `  1`(x86)/`  1`(x86_64)
91    #[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                /// Intended for use in XML.
205                #[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};