havok_classes/generated/
BSEventEveryNEventsModifier_.rs

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