1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct BSEventEveryNEventsModifier<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "eventToCheckFor"))]
36 #[cfg_attr(feature = "serde", serde(rename = "eventToCheckFor"))]
37 pub m_eventToCheckFor: hkbEventProperty,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "eventToSend"))]
43 #[cfg_attr(feature = "serde", serde(rename = "eventToSend"))]
44 pub m_eventToSend: hkbEventProperty,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "numberOfEventsBeforeSend"))]
50 #[cfg_attr(feature = "serde", serde(rename = "numberOfEventsBeforeSend"))]
51 pub m_numberOfEventsBeforeSend: i8,
52 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "randomizeNumberOfEvents"))]
67 #[cfg_attr(feature = "serde", serde(rename = "randomizeNumberOfEvents"))]
68 pub m_randomizeNumberOfEvents: bool,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "numberOfEventsSeen"))]
75 #[cfg_attr(feature = "serde", serde(rename = "numberOfEventsSeen"))]
76 pub m_numberOfEventsSeen: i32,
77 #[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 #[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};