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 hkbSequence<'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 = "eventSequencedData"))]
36 #[cfg_attr(feature = "serde", serde(rename = "eventSequencedData"))]
37 pub m_eventSequencedData: Vec<Pointer>,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "realVariableSequencedData"))]
43 #[cfg_attr(feature = "serde", serde(rename = "realVariableSequencedData"))]
44 pub m_realVariableSequencedData: Vec<Pointer>,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "boolVariableSequencedData"))]
50 #[cfg_attr(feature = "serde", serde(rename = "boolVariableSequencedData"))]
51 pub m_boolVariableSequencedData: Vec<Pointer>,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "intVariableSequencedData"))]
57 #[cfg_attr(feature = "serde", serde(rename = "intVariableSequencedData"))]
58 pub m_intVariableSequencedData: Vec<Pointer>,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "enableEventId"))]
64 #[cfg_attr(feature = "serde", serde(rename = "enableEventId"))]
65 pub m_enableEventId: i32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "disableEventId"))]
71 #[cfg_attr(feature = "serde", serde(rename = "disableEventId"))]
72 pub m_disableEventId: i32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "stringData"))]
78 #[cfg_attr(feature = "serde", serde(rename = "stringData"))]
79 pub m_stringData: Pointer,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "variableIdMap"))]
86 #[cfg_attr(feature = "serde", serde(rename = "variableIdMap"))]
87 pub m_variableIdMap: Pointer,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "eventIdMap"))]
94 #[cfg_attr(feature = "serde", serde(rename = "eventIdMap"))]
95 pub m_eventIdMap: Pointer,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "nextSampleEvents"))]
102 #[cfg_attr(feature = "serde", serde(rename = "nextSampleEvents"))]
103 pub m_nextSampleEvents: Vec<()>,
104 #[cfg_attr(feature = "json_schema", schemars(rename = "nextSampleReals"))]
110 #[cfg_attr(feature = "serde", serde(rename = "nextSampleReals"))]
111 pub m_nextSampleReals: Vec<()>,
112 #[cfg_attr(feature = "json_schema", schemars(rename = "nextSampleBools"))]
118 #[cfg_attr(feature = "serde", serde(rename = "nextSampleBools"))]
119 pub m_nextSampleBools: Vec<()>,
120 #[cfg_attr(feature = "json_schema", schemars(rename = "nextSampleInts"))]
126 #[cfg_attr(feature = "serde", serde(rename = "nextSampleInts"))]
127 pub m_nextSampleInts: Vec<()>,
128 #[cfg_attr(feature = "json_schema", schemars(rename = "time"))]
134 #[cfg_attr(feature = "serde", serde(rename = "time"))]
135 pub m_time: f32,
136 #[cfg_attr(feature = "json_schema", schemars(rename = "isEnabled"))]
142 #[cfg_attr(feature = "serde", serde(rename = "isEnabled"))]
143 pub m_isEnabled: bool,
144}
145const _: () = {
146 use havok_serde as _serde;
147 impl<'a> _serde::HavokClass for hkbSequence<'a> {
148 #[inline]
149 fn name(&self) -> &'static str {
150 "hkbSequence"
151 }
152 #[inline]
153 fn signature(&self) -> _serde::__private::Signature {
154 _serde::__private::Signature::new(0x43182ca3)
155 }
156 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
157 fn deps_indexes(&self) -> Vec<usize> {
158 let mut v = Vec::new();
159 v.push(self.parent.parent.parent.m_variableBindingSet.get());
160 v.extend(self.m_eventSequencedData.iter().map(|ptr| ptr.get()));
161 v.extend(self.m_realVariableSequencedData.iter().map(|ptr| ptr.get()));
162 v.extend(self.m_boolVariableSequencedData.iter().map(|ptr| ptr.get()));
163 v.extend(self.m_intVariableSequencedData.iter().map(|ptr| ptr.get()));
164 v.push(self.m_stringData.get());
165 v.push(self.m_variableIdMap.get());
166 v.push(self.m_eventIdMap.get());
167 v
168 }
169 }
170 impl<'a> _serde::Serialize for hkbSequence<'a> {
171 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
172 where
173 S: _serde::ser::Serializer,
174 {
175 let class_meta = self
176 .__ptr
177 .map(|name| (name, _serde::__private::Signature::new(0x43182ca3)));
178 let mut serializer = __serializer
179 .serialize_struct("hkbSequence", class_meta, (168u64, 248u64))?;
180 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
181 serializer
182 .skip_field(
183 "memSizeAndFlags",
184 &self.parent.parent.parent.parent.m_memSizeAndFlags,
185 )?;
186 serializer
187 .skip_field(
188 "referenceCount",
189 &self.parent.parent.parent.parent.m_referenceCount,
190 )?;
191 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
192 serializer
193 .serialize_field(
194 "variableBindingSet",
195 &self.parent.parent.parent.m_variableBindingSet,
196 )?;
197 serializer
198 .skip_array_field(
199 "cachedBindables",
200 &self.parent.parent.parent.m_cachedBindables,
201 TypeSize::NonPtr,
202 )?;
203 serializer
204 .skip_field(
205 "areBindablesCached",
206 &self.parent.parent.parent.m_areBindablesCached,
207 )?;
208 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
209 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
210 serializer.serialize_field("name", &self.parent.parent.m_name)?;
211 serializer.skip_field("id", &self.parent.parent.m_id)?;
212 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
213 serializer
214 .skip_fixed_array_field(
215 "padNode",
216 self.parent.parent.m_padNode.as_slice(),
217 TypeSize::NonPtr,
218 )?;
219 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
220 serializer.serialize_field("enable", &self.parent.m_enable)?;
221 serializer
222 .skip_fixed_array_field(
223 "padModifier",
224 self.parent.m_padModifier.as_slice(),
225 TypeSize::NonPtr,
226 )?;
227 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
228 serializer
229 .serialize_array_field(
230 "eventSequencedData",
231 &self.m_eventSequencedData,
232 TypeSize::NonPtr,
233 )?;
234 serializer
235 .serialize_array_field(
236 "realVariableSequencedData",
237 &self.m_realVariableSequencedData,
238 TypeSize::NonPtr,
239 )?;
240 serializer
241 .serialize_array_field(
242 "boolVariableSequencedData",
243 &self.m_boolVariableSequencedData,
244 TypeSize::NonPtr,
245 )?;
246 serializer
247 .serialize_array_field(
248 "intVariableSequencedData",
249 &self.m_intVariableSequencedData,
250 TypeSize::NonPtr,
251 )?;
252 serializer.serialize_field("enableEventId", &self.m_enableEventId)?;
253 serializer.serialize_field("disableEventId", &self.m_disableEventId)?;
254 serializer.serialize_field("stringData", &self.m_stringData)?;
255 serializer.skip_field("variableIdMap", &self.m_variableIdMap)?;
256 serializer.skip_field("eventIdMap", &self.m_eventIdMap)?;
257 serializer
258 .skip_array_field(
259 "nextSampleEvents",
260 &self.m_nextSampleEvents,
261 TypeSize::NonPtr,
262 )?;
263 serializer
264 .skip_array_field(
265 "nextSampleReals",
266 &self.m_nextSampleReals,
267 TypeSize::NonPtr,
268 )?;
269 serializer
270 .skip_array_field(
271 "nextSampleBools",
272 &self.m_nextSampleBools,
273 TypeSize::NonPtr,
274 )?;
275 serializer
276 .skip_array_field(
277 "nextSampleInts",
278 &self.m_nextSampleInts,
279 TypeSize::NonPtr,
280 )?;
281 serializer.skip_field("time", &self.m_time)?;
282 serializer.skip_field("isEnabled", &self.m_isEnabled)?;
283 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
284 serializer.end()
285 }
286 }
287};
288#[doc(hidden)]
289#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
290const _: () = {
291 use havok_serde as _serde;
292 #[automatically_derived]
293 impl<'de> _serde::Deserialize<'de> for hkbSequence<'de> {
294 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
295 where
296 __D: _serde::Deserializer<'de>,
297 {
298 #[allow(non_camel_case_types)]
299 enum __Field {
300 m_variableBindingSet,
301 m_userData,
302 m_name,
303 m_enable,
304 m_eventSequencedData,
305 m_realVariableSequencedData,
306 m_boolVariableSequencedData,
307 m_intVariableSequencedData,
308 m_enableEventId,
309 m_disableEventId,
310 m_stringData,
311 __ignore,
312 }
313 struct __FieldVisitor;
314 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
315 type Value = __Field;
316 fn expecting(
317 &self,
318 __formatter: &mut core::fmt::Formatter,
319 ) -> core::fmt::Result {
320 core::fmt::Formatter::write_str(__formatter, "field identifier")
321 }
322 #[allow(clippy::match_single_binding)]
324 #[allow(clippy::reversed_empty_ranges)]
325 #[allow(clippy::single_match)]
326 fn visit_key<__E>(
327 self,
328 __value: &str,
329 ) -> core::result::Result<Self::Value, __E>
330 where
331 __E: _serde::de::Error,
332 {
333 match __value {
334 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
335 "userData" => Ok(__Field::m_userData),
336 "name" => Ok(__Field::m_name),
337 "enable" => Ok(__Field::m_enable),
338 "eventSequencedData" => Ok(__Field::m_eventSequencedData),
339 "realVariableSequencedData" => {
340 Ok(__Field::m_realVariableSequencedData)
341 }
342 "boolVariableSequencedData" => {
343 Ok(__Field::m_boolVariableSequencedData)
344 }
345 "intVariableSequencedData" => {
346 Ok(__Field::m_intVariableSequencedData)
347 }
348 "enableEventId" => Ok(__Field::m_enableEventId),
349 "disableEventId" => Ok(__Field::m_disableEventId),
350 "stringData" => Ok(__Field::m_stringData),
351 _ => Ok(__Field::__ignore),
352 }
353 }
354 }
355 impl<'de> _serde::Deserialize<'de> for __Field {
356 #[inline]
357 fn deserialize<__D>(
358 __deserializer: __D,
359 ) -> core::result::Result<Self, __D::Error>
360 where
361 __D: _serde::Deserializer<'de>,
362 {
363 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
364 }
365 }
366 struct __hkbSequenceVisitor<'de> {
367 marker: _serde::__private::PhantomData<hkbSequence<'de>>,
368 lifetime: _serde::__private::PhantomData<&'de ()>,
369 }
370 #[allow(clippy::match_single_binding)]
371 #[allow(clippy::reversed_empty_ranges)]
372 #[allow(clippy::single_match)]
373 impl<'de> _serde::de::Visitor<'de> for __hkbSequenceVisitor<'de> {
374 type Value = hkbSequence<'de>;
375 fn expecting(
376 &self,
377 __formatter: &mut core::fmt::Formatter,
378 ) -> core::fmt::Result {
379 core::fmt::Formatter::write_str(__formatter, "struct hkbSequence")
380 }
381 fn visit_struct_for_bytes<__A>(
382 self,
383 mut __map: __A,
384 ) -> _serde::__private::Result<Self::Value, __A::Error>
385 where
386 __A: _serde::de::MapAccess<'de>,
387 {
388 let __ptr = __A::class_ptr(&mut __map);
389 let parent = __A::parent_value(&mut __map)?;
390 let mut m_eventSequencedData: _serde::__private::Option<
391 Vec<Pointer>,
392 > = _serde::__private::None;
393 let mut m_realVariableSequencedData: _serde::__private::Option<
394 Vec<Pointer>,
395 > = _serde::__private::None;
396 let mut m_boolVariableSequencedData: _serde::__private::Option<
397 Vec<Pointer>,
398 > = _serde::__private::None;
399 let mut m_intVariableSequencedData: _serde::__private::Option<
400 Vec<Pointer>,
401 > = _serde::__private::None;
402 let mut m_enableEventId: _serde::__private::Option<i32> = _serde::__private::None;
403 let mut m_disableEventId: _serde::__private::Option<i32> = _serde::__private::None;
404 let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
405 let mut m_variableIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
406 let mut m_eventIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
407 let mut m_nextSampleEvents: _serde::__private::Option<Vec<()>> = _serde::__private::None;
408 let mut m_nextSampleReals: _serde::__private::Option<Vec<()>> = _serde::__private::None;
409 let mut m_nextSampleBools: _serde::__private::Option<Vec<()>> = _serde::__private::None;
410 let mut m_nextSampleInts: _serde::__private::Option<Vec<()>> = _serde::__private::None;
411 let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
412 let mut m_isEnabled: _serde::__private::Option<bool> = _serde::__private::None;
413 for i in 0..15usize {
414 match i {
415 0usize => {
416 if _serde::__private::Option::is_some(
417 &m_eventSequencedData,
418 ) {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::duplicate_field(
421 "eventSequencedData",
422 ),
423 );
424 }
425 m_eventSequencedData = _serde::__private::Some(
426 match __A::next_value::<Vec<Pointer>>(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 1usize => {
435 if _serde::__private::Option::is_some(
436 &m_realVariableSequencedData,
437 ) {
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::duplicate_field(
440 "realVariableSequencedData",
441 ),
442 );
443 }
444 m_realVariableSequencedData = _serde::__private::Some(
445 match __A::next_value::<Vec<Pointer>>(&mut __map) {
446 _serde::__private::Ok(__val) => __val,
447 _serde::__private::Err(__err) => {
448 return _serde::__private::Err(__err);
449 }
450 },
451 );
452 }
453 2usize => {
454 if _serde::__private::Option::is_some(
455 &m_boolVariableSequencedData,
456 ) {
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::duplicate_field(
459 "boolVariableSequencedData",
460 ),
461 );
462 }
463 m_boolVariableSequencedData = _serde::__private::Some(
464 match __A::next_value::<Vec<Pointer>>(&mut __map) {
465 _serde::__private::Ok(__val) => __val,
466 _serde::__private::Err(__err) => {
467 return _serde::__private::Err(__err);
468 }
469 },
470 );
471 }
472 3usize => {
473 if _serde::__private::Option::is_some(
474 &m_intVariableSequencedData,
475 ) {
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::duplicate_field(
478 "intVariableSequencedData",
479 ),
480 );
481 }
482 m_intVariableSequencedData = _serde::__private::Some(
483 match __A::next_value::<Vec<Pointer>>(&mut __map) {
484 _serde::__private::Ok(__val) => __val,
485 _serde::__private::Err(__err) => {
486 return _serde::__private::Err(__err);
487 }
488 },
489 );
490 }
491 4usize => {
492 if _serde::__private::Option::is_some(&m_enableEventId) {
493 return _serde::__private::Err(
494 <__A::Error as _serde::de::Error>::duplicate_field(
495 "enableEventId",
496 ),
497 );
498 }
499 m_enableEventId = _serde::__private::Some(
500 match __A::next_value::<i32>(&mut __map) {
501 _serde::__private::Ok(__val) => __val,
502 _serde::__private::Err(__err) => {
503 return _serde::__private::Err(__err);
504 }
505 },
506 );
507 }
508 5usize => {
509 if _serde::__private::Option::is_some(&m_disableEventId) {
510 return _serde::__private::Err(
511 <__A::Error as _serde::de::Error>::duplicate_field(
512 "disableEventId",
513 ),
514 );
515 }
516 m_disableEventId = _serde::__private::Some(
517 match __A::next_value::<i32>(&mut __map) {
518 _serde::__private::Ok(__val) => __val,
519 _serde::__private::Err(__err) => {
520 return _serde::__private::Err(__err);
521 }
522 },
523 );
524 }
525 6usize => {
526 if _serde::__private::Option::is_some(&m_stringData) {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::duplicate_field(
529 "stringData",
530 ),
531 );
532 }
533 m_stringData = _serde::__private::Some(
534 match __A::next_value::<Pointer>(&mut __map) {
535 _serde::__private::Ok(__val) => __val,
536 _serde::__private::Err(__err) => {
537 return _serde::__private::Err(__err);
538 }
539 },
540 );
541 }
542 7usize => {
543 if _serde::__private::Option::is_some(&m_variableIdMap) {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::duplicate_field(
546 "variableIdMap",
547 ),
548 );
549 }
550 m_variableIdMap = _serde::__private::Some(
551 match __A::next_value::<Pointer>(&mut __map) {
552 _serde::__private::Ok(__val) => __val,
553 _serde::__private::Err(__err) => {
554 return _serde::__private::Err(__err);
555 }
556 },
557 );
558 }
559 8usize => {
560 if _serde::__private::Option::is_some(&m_eventIdMap) {
561 return _serde::__private::Err(
562 <__A::Error as _serde::de::Error>::duplicate_field(
563 "eventIdMap",
564 ),
565 );
566 }
567 m_eventIdMap = _serde::__private::Some(
568 match __A::next_value::<Pointer>(&mut __map) {
569 _serde::__private::Ok(__val) => __val,
570 _serde::__private::Err(__err) => {
571 return _serde::__private::Err(__err);
572 }
573 },
574 );
575 }
576 9usize => {
577 if _serde::__private::Option::is_some(&m_nextSampleEvents) {
578 return _serde::__private::Err(
579 <__A::Error as _serde::de::Error>::duplicate_field(
580 "nextSampleEvents",
581 ),
582 );
583 }
584 m_nextSampleEvents = _serde::__private::Some(
585 match __A::next_value::<Vec<()>>(&mut __map) {
586 _serde::__private::Ok(__val) => __val,
587 _serde::__private::Err(__err) => {
588 return _serde::__private::Err(__err);
589 }
590 },
591 );
592 }
593 10usize => {
594 if _serde::__private::Option::is_some(&m_nextSampleReals) {
595 return _serde::__private::Err(
596 <__A::Error as _serde::de::Error>::duplicate_field(
597 "nextSampleReals",
598 ),
599 );
600 }
601 m_nextSampleReals = _serde::__private::Some(
602 match __A::next_value::<Vec<()>>(&mut __map) {
603 _serde::__private::Ok(__val) => __val,
604 _serde::__private::Err(__err) => {
605 return _serde::__private::Err(__err);
606 }
607 },
608 );
609 }
610 11usize => {
611 if _serde::__private::Option::is_some(&m_nextSampleBools) {
612 return _serde::__private::Err(
613 <__A::Error as _serde::de::Error>::duplicate_field(
614 "nextSampleBools",
615 ),
616 );
617 }
618 m_nextSampleBools = _serde::__private::Some(
619 match __A::next_value::<Vec<()>>(&mut __map) {
620 _serde::__private::Ok(__val) => __val,
621 _serde::__private::Err(__err) => {
622 return _serde::__private::Err(__err);
623 }
624 },
625 );
626 }
627 12usize => {
628 if _serde::__private::Option::is_some(&m_nextSampleInts) {
629 return _serde::__private::Err(
630 <__A::Error as _serde::de::Error>::duplicate_field(
631 "nextSampleInts",
632 ),
633 );
634 }
635 m_nextSampleInts = _serde::__private::Some(
636 match __A::next_value::<Vec<()>>(&mut __map) {
637 _serde::__private::Ok(__val) => __val,
638 _serde::__private::Err(__err) => {
639 return _serde::__private::Err(__err);
640 }
641 },
642 );
643 }
644 13usize => {
645 if _serde::__private::Option::is_some(&m_time) {
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::duplicate_field("time"),
648 );
649 }
650 m_time = _serde::__private::Some(
651 match __A::next_value::<f32>(&mut __map) {
652 _serde::__private::Ok(__val) => __val,
653 _serde::__private::Err(__err) => {
654 return _serde::__private::Err(__err);
655 }
656 },
657 );
658 }
659 14usize => {
660 if _serde::__private::Option::is_some(&m_isEnabled) {
661 return _serde::__private::Err(
662 <__A::Error as _serde::de::Error>::duplicate_field(
663 "isEnabled",
664 ),
665 );
666 }
667 m_isEnabled = _serde::__private::Some(
668 match __A::next_value::<bool>(&mut __map) {
669 _serde::__private::Ok(__val) => __val,
670 _serde::__private::Err(__err) => {
671 return _serde::__private::Err(__err);
672 }
673 },
674 );
675 }
676 _ => {}
677 }
678 }
679 __A::pad(&mut __map, 3usize, 3usize)?;
680 let m_eventSequencedData = match m_eventSequencedData {
681 _serde::__private::Some(__field) => __field,
682 _serde::__private::None => {
683 return _serde::__private::Err(
684 <__A::Error as _serde::de::Error>::missing_field(
685 "eventSequencedData",
686 ),
687 );
688 }
689 };
690 let m_realVariableSequencedData = match m_realVariableSequencedData {
691 _serde::__private::Some(__field) => __field,
692 _serde::__private::None => {
693 return _serde::__private::Err(
694 <__A::Error as _serde::de::Error>::missing_field(
695 "realVariableSequencedData",
696 ),
697 );
698 }
699 };
700 let m_boolVariableSequencedData = match m_boolVariableSequencedData {
701 _serde::__private::Some(__field) => __field,
702 _serde::__private::None => {
703 return _serde::__private::Err(
704 <__A::Error as _serde::de::Error>::missing_field(
705 "boolVariableSequencedData",
706 ),
707 );
708 }
709 };
710 let m_intVariableSequencedData = match m_intVariableSequencedData {
711 _serde::__private::Some(__field) => __field,
712 _serde::__private::None => {
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::missing_field(
715 "intVariableSequencedData",
716 ),
717 );
718 }
719 };
720 let m_enableEventId = match m_enableEventId {
721 _serde::__private::Some(__field) => __field,
722 _serde::__private::None => {
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::missing_field(
725 "enableEventId",
726 ),
727 );
728 }
729 };
730 let m_disableEventId = match m_disableEventId {
731 _serde::__private::Some(__field) => __field,
732 _serde::__private::None => {
733 return _serde::__private::Err(
734 <__A::Error as _serde::de::Error>::missing_field(
735 "disableEventId",
736 ),
737 );
738 }
739 };
740 let m_stringData = match m_stringData {
741 _serde::__private::Some(__field) => __field,
742 _serde::__private::None => {
743 return _serde::__private::Err(
744 <__A::Error as _serde::de::Error>::missing_field(
745 "stringData",
746 ),
747 );
748 }
749 };
750 let m_variableIdMap = match m_variableIdMap {
751 _serde::__private::Some(__field) => __field,
752 _serde::__private::None => {
753 return _serde::__private::Err(
754 <__A::Error as _serde::de::Error>::missing_field(
755 "variableIdMap",
756 ),
757 );
758 }
759 };
760 let m_eventIdMap = match m_eventIdMap {
761 _serde::__private::Some(__field) => __field,
762 _serde::__private::None => {
763 return _serde::__private::Err(
764 <__A::Error as _serde::de::Error>::missing_field(
765 "eventIdMap",
766 ),
767 );
768 }
769 };
770 let m_nextSampleEvents = match m_nextSampleEvents {
771 _serde::__private::Some(__field) => __field,
772 _serde::__private::None => {
773 return _serde::__private::Err(
774 <__A::Error as _serde::de::Error>::missing_field(
775 "nextSampleEvents",
776 ),
777 );
778 }
779 };
780 let m_nextSampleReals = match m_nextSampleReals {
781 _serde::__private::Some(__field) => __field,
782 _serde::__private::None => {
783 return _serde::__private::Err(
784 <__A::Error as _serde::de::Error>::missing_field(
785 "nextSampleReals",
786 ),
787 );
788 }
789 };
790 let m_nextSampleBools = match m_nextSampleBools {
791 _serde::__private::Some(__field) => __field,
792 _serde::__private::None => {
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::missing_field(
795 "nextSampleBools",
796 ),
797 );
798 }
799 };
800 let m_nextSampleInts = match m_nextSampleInts {
801 _serde::__private::Some(__field) => __field,
802 _serde::__private::None => {
803 return _serde::__private::Err(
804 <__A::Error as _serde::de::Error>::missing_field(
805 "nextSampleInts",
806 ),
807 );
808 }
809 };
810 let m_time = match m_time {
811 _serde::__private::Some(__field) => __field,
812 _serde::__private::None => {
813 return _serde::__private::Err(
814 <__A::Error as _serde::de::Error>::missing_field("time"),
815 );
816 }
817 };
818 let m_isEnabled = match m_isEnabled {
819 _serde::__private::Some(__field) => __field,
820 _serde::__private::None => {
821 return _serde::__private::Err(
822 <__A::Error as _serde::de::Error>::missing_field(
823 "isEnabled",
824 ),
825 );
826 }
827 };
828 _serde::__private::Ok(hkbSequence {
829 __ptr,
830 parent,
831 m_eventSequencedData,
832 m_realVariableSequencedData,
833 m_boolVariableSequencedData,
834 m_intVariableSequencedData,
835 m_enableEventId,
836 m_disableEventId,
837 m_stringData,
838 m_variableIdMap,
839 m_eventIdMap,
840 m_nextSampleEvents,
841 m_nextSampleReals,
842 m_nextSampleBools,
843 m_nextSampleInts,
844 m_time,
845 m_isEnabled,
846 })
847 }
848 #[allow(clippy::manual_unwrap_or_default)]
849 fn visit_struct<__A>(
850 self,
851 mut __map: __A,
852 ) -> _serde::__private::Result<Self::Value, __A::Error>
853 where
854 __A: _serde::de::MapAccess<'de>,
855 {
856 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
857 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
858 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
859 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
860 let mut m_eventSequencedData: _serde::__private::Option<
861 Vec<Pointer>,
862 > = _serde::__private::None;
863 let mut m_realVariableSequencedData: _serde::__private::Option<
864 Vec<Pointer>,
865 > = _serde::__private::None;
866 let mut m_boolVariableSequencedData: _serde::__private::Option<
867 Vec<Pointer>,
868 > = _serde::__private::None;
869 let mut m_intVariableSequencedData: _serde::__private::Option<
870 Vec<Pointer>,
871 > = _serde::__private::None;
872 let mut m_enableEventId: _serde::__private::Option<i32> = _serde::__private::None;
873 let mut m_disableEventId: _serde::__private::Option<i32> = _serde::__private::None;
874 let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
875 while let _serde::__private::Some(__key) = {
876 __A::next_key::<__Field>(&mut __map)?
877 } {
878 match __key {
879 __Field::m_variableBindingSet => {
880 #[cfg(
881 any(feature = "strict", feature = "ignore_duplicates")
882 )]
883 if _serde::__private::Option::is_some(
884 &m_variableBindingSet,
885 ) {
886 #[cfg(feature = "ignore_duplicates")]
887 {
888 __A::skip_value(&mut __map)?;
889 continue;
890 }
891 #[cfg(feature = "strict")]
892 return _serde::__private::Err(
893 <__A::Error as _serde::de::Error>::duplicate_field(
894 "variableBindingSet",
895 ),
896 );
897 }
898 m_variableBindingSet = _serde::__private::Some(
899 match __A::next_value::<Pointer>(&mut __map) {
900 _serde::__private::Ok(__val) => __val,
901 _serde::__private::Err(__err) => {
902 return _serde::__private::Err(__err);
903 }
904 },
905 );
906 }
907 __Field::m_userData => {
908 #[cfg(
909 any(feature = "strict", feature = "ignore_duplicates")
910 )]
911 if _serde::__private::Option::is_some(&m_userData) {
912 #[cfg(feature = "ignore_duplicates")]
913 {
914 __A::skip_value(&mut __map)?;
915 continue;
916 }
917 #[cfg(feature = "strict")]
918 return _serde::__private::Err(
919 <__A::Error as _serde::de::Error>::duplicate_field(
920 "userData",
921 ),
922 );
923 }
924 m_userData = _serde::__private::Some(
925 match __A::next_value::<Ulong>(&mut __map) {
926 _serde::__private::Ok(__val) => __val,
927 _serde::__private::Err(__err) => {
928 return _serde::__private::Err(__err);
929 }
930 },
931 );
932 }
933 __Field::m_name => {
934 #[cfg(
935 any(feature = "strict", feature = "ignore_duplicates")
936 )]
937 if _serde::__private::Option::is_some(&m_name) {
938 #[cfg(feature = "ignore_duplicates")]
939 {
940 __A::skip_value(&mut __map)?;
941 continue;
942 }
943 #[cfg(feature = "strict")]
944 return _serde::__private::Err(
945 <__A::Error as _serde::de::Error>::duplicate_field("name"),
946 );
947 }
948 m_name = _serde::__private::Some(
949 match __A::next_value::<StringPtr<'de>>(&mut __map) {
950 _serde::__private::Ok(__val) => __val,
951 _serde::__private::Err(__err) => {
952 return _serde::__private::Err(__err);
953 }
954 },
955 );
956 }
957 __Field::m_enable => {
958 #[cfg(
959 any(feature = "strict", feature = "ignore_duplicates")
960 )]
961 if _serde::__private::Option::is_some(&m_enable) {
962 #[cfg(feature = "ignore_duplicates")]
963 {
964 __A::skip_value(&mut __map)?;
965 continue;
966 }
967 #[cfg(feature = "strict")]
968 return _serde::__private::Err(
969 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
970 );
971 }
972 m_enable = _serde::__private::Some(
973 match __A::next_value::<bool>(&mut __map) {
974 _serde::__private::Ok(__val) => __val,
975 _serde::__private::Err(__err) => {
976 return _serde::__private::Err(__err);
977 }
978 },
979 );
980 }
981 __Field::m_eventSequencedData => {
982 #[cfg(
983 any(feature = "strict", feature = "ignore_duplicates")
984 )]
985 if _serde::__private::Option::is_some(
986 &m_eventSequencedData,
987 ) {
988 #[cfg(feature = "ignore_duplicates")]
989 {
990 __A::skip_value(&mut __map)?;
991 continue;
992 }
993 #[cfg(feature = "strict")]
994 return _serde::__private::Err(
995 <__A::Error as _serde::de::Error>::duplicate_field(
996 "eventSequencedData",
997 ),
998 );
999 }
1000 m_eventSequencedData = _serde::__private::Some(
1001 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1002 _serde::__private::Ok(__val) => __val,
1003 _serde::__private::Err(__err) => {
1004 return _serde::__private::Err(__err);
1005 }
1006 },
1007 );
1008 }
1009 __Field::m_realVariableSequencedData => {
1010 #[cfg(
1011 any(feature = "strict", feature = "ignore_duplicates")
1012 )]
1013 if _serde::__private::Option::is_some(
1014 &m_realVariableSequencedData,
1015 ) {
1016 #[cfg(feature = "ignore_duplicates")]
1017 {
1018 __A::skip_value(&mut __map)?;
1019 continue;
1020 }
1021 #[cfg(feature = "strict")]
1022 return _serde::__private::Err(
1023 <__A::Error as _serde::de::Error>::duplicate_field(
1024 "realVariableSequencedData",
1025 ),
1026 );
1027 }
1028 m_realVariableSequencedData = _serde::__private::Some(
1029 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1030 _serde::__private::Ok(__val) => __val,
1031 _serde::__private::Err(__err) => {
1032 return _serde::__private::Err(__err);
1033 }
1034 },
1035 );
1036 }
1037 __Field::m_boolVariableSequencedData => {
1038 #[cfg(
1039 any(feature = "strict", feature = "ignore_duplicates")
1040 )]
1041 if _serde::__private::Option::is_some(
1042 &m_boolVariableSequencedData,
1043 ) {
1044 #[cfg(feature = "ignore_duplicates")]
1045 {
1046 __A::skip_value(&mut __map)?;
1047 continue;
1048 }
1049 #[cfg(feature = "strict")]
1050 return _serde::__private::Err(
1051 <__A::Error as _serde::de::Error>::duplicate_field(
1052 "boolVariableSequencedData",
1053 ),
1054 );
1055 }
1056 m_boolVariableSequencedData = _serde::__private::Some(
1057 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1058 _serde::__private::Ok(__val) => __val,
1059 _serde::__private::Err(__err) => {
1060 return _serde::__private::Err(__err);
1061 }
1062 },
1063 );
1064 }
1065 __Field::m_intVariableSequencedData => {
1066 #[cfg(
1067 any(feature = "strict", feature = "ignore_duplicates")
1068 )]
1069 if _serde::__private::Option::is_some(
1070 &m_intVariableSequencedData,
1071 ) {
1072 #[cfg(feature = "ignore_duplicates")]
1073 {
1074 __A::skip_value(&mut __map)?;
1075 continue;
1076 }
1077 #[cfg(feature = "strict")]
1078 return _serde::__private::Err(
1079 <__A::Error as _serde::de::Error>::duplicate_field(
1080 "intVariableSequencedData",
1081 ),
1082 );
1083 }
1084 m_intVariableSequencedData = _serde::__private::Some(
1085 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1086 _serde::__private::Ok(__val) => __val,
1087 _serde::__private::Err(__err) => {
1088 return _serde::__private::Err(__err);
1089 }
1090 },
1091 );
1092 }
1093 __Field::m_enableEventId => {
1094 #[cfg(
1095 any(feature = "strict", feature = "ignore_duplicates")
1096 )]
1097 if _serde::__private::Option::is_some(&m_enableEventId) {
1098 #[cfg(feature = "ignore_duplicates")]
1099 {
1100 __A::skip_value(&mut __map)?;
1101 continue;
1102 }
1103 #[cfg(feature = "strict")]
1104 return _serde::__private::Err(
1105 <__A::Error as _serde::de::Error>::duplicate_field(
1106 "enableEventId",
1107 ),
1108 );
1109 }
1110 m_enableEventId = _serde::__private::Some(
1111 match __A::next_value::<i32>(&mut __map) {
1112 _serde::__private::Ok(__val) => __val,
1113 _serde::__private::Err(__err) => {
1114 return _serde::__private::Err(__err);
1115 }
1116 },
1117 );
1118 }
1119 __Field::m_disableEventId => {
1120 #[cfg(
1121 any(feature = "strict", feature = "ignore_duplicates")
1122 )]
1123 if _serde::__private::Option::is_some(&m_disableEventId) {
1124 #[cfg(feature = "ignore_duplicates")]
1125 {
1126 __A::skip_value(&mut __map)?;
1127 continue;
1128 }
1129 #[cfg(feature = "strict")]
1130 return _serde::__private::Err(
1131 <__A::Error as _serde::de::Error>::duplicate_field(
1132 "disableEventId",
1133 ),
1134 );
1135 }
1136 m_disableEventId = _serde::__private::Some(
1137 match __A::next_value::<i32>(&mut __map) {
1138 _serde::__private::Ok(__val) => __val,
1139 _serde::__private::Err(__err) => {
1140 return _serde::__private::Err(__err);
1141 }
1142 },
1143 );
1144 }
1145 __Field::m_stringData => {
1146 #[cfg(
1147 any(feature = "strict", feature = "ignore_duplicates")
1148 )]
1149 if _serde::__private::Option::is_some(&m_stringData) {
1150 #[cfg(feature = "ignore_duplicates")]
1151 {
1152 __A::skip_value(&mut __map)?;
1153 continue;
1154 }
1155 #[cfg(feature = "strict")]
1156 return _serde::__private::Err(
1157 <__A::Error as _serde::de::Error>::duplicate_field(
1158 "stringData",
1159 ),
1160 );
1161 }
1162 m_stringData = _serde::__private::Some(
1163 match __A::next_value::<Pointer>(&mut __map) {
1164 _serde::__private::Ok(__val) => __val,
1165 _serde::__private::Err(__err) => {
1166 return _serde::__private::Err(__err);
1167 }
1168 },
1169 );
1170 }
1171 _ => __A::skip_value(&mut __map)?,
1172 }
1173 }
1174 let m_variableBindingSet = match m_variableBindingSet {
1175 _serde::__private::Some(__field) => __field,
1176 _serde::__private::None => {
1177 #[cfg(feature = "strict")]
1178 return _serde::__private::Err(
1179 <__A::Error as _serde::de::Error>::missing_field(
1180 "variableBindingSet",
1181 ),
1182 );
1183 #[cfg(not(feature = "strict"))] Default::default()
1184 }
1185 };
1186 let m_userData = match m_userData {
1187 _serde::__private::Some(__field) => __field,
1188 _serde::__private::None => {
1189 #[cfg(feature = "strict")]
1190 return _serde::__private::Err(
1191 <__A::Error as _serde::de::Error>::missing_field("userData"),
1192 );
1193 #[cfg(not(feature = "strict"))] Default::default()
1194 }
1195 };
1196 let m_name = match m_name {
1197 _serde::__private::Some(__field) => __field,
1198 _serde::__private::None => {
1199 #[cfg(feature = "strict")]
1200 return _serde::__private::Err(
1201 <__A::Error as _serde::de::Error>::missing_field("name"),
1202 );
1203 #[cfg(not(feature = "strict"))] Default::default()
1204 }
1205 };
1206 let m_enable = match m_enable {
1207 _serde::__private::Some(__field) => __field,
1208 _serde::__private::None => {
1209 #[cfg(feature = "strict")]
1210 return _serde::__private::Err(
1211 <__A::Error as _serde::de::Error>::missing_field("enable"),
1212 );
1213 #[cfg(not(feature = "strict"))] Default::default()
1214 }
1215 };
1216 let m_eventSequencedData = match m_eventSequencedData {
1217 _serde::__private::Some(__field) => __field,
1218 _serde::__private::None => {
1219 #[cfg(feature = "strict")]
1220 return _serde::__private::Err(
1221 <__A::Error as _serde::de::Error>::missing_field(
1222 "eventSequencedData",
1223 ),
1224 );
1225 #[cfg(not(feature = "strict"))] Default::default()
1226 }
1227 };
1228 let m_realVariableSequencedData = match m_realVariableSequencedData {
1229 _serde::__private::Some(__field) => __field,
1230 _serde::__private::None => {
1231 #[cfg(feature = "strict")]
1232 return _serde::__private::Err(
1233 <__A::Error as _serde::de::Error>::missing_field(
1234 "realVariableSequencedData",
1235 ),
1236 );
1237 #[cfg(not(feature = "strict"))] Default::default()
1238 }
1239 };
1240 let m_boolVariableSequencedData = match m_boolVariableSequencedData {
1241 _serde::__private::Some(__field) => __field,
1242 _serde::__private::None => {
1243 #[cfg(feature = "strict")]
1244 return _serde::__private::Err(
1245 <__A::Error as _serde::de::Error>::missing_field(
1246 "boolVariableSequencedData",
1247 ),
1248 );
1249 #[cfg(not(feature = "strict"))] Default::default()
1250 }
1251 };
1252 let m_intVariableSequencedData = match m_intVariableSequencedData {
1253 _serde::__private::Some(__field) => __field,
1254 _serde::__private::None => {
1255 #[cfg(feature = "strict")]
1256 return _serde::__private::Err(
1257 <__A::Error as _serde::de::Error>::missing_field(
1258 "intVariableSequencedData",
1259 ),
1260 );
1261 #[cfg(not(feature = "strict"))] Default::default()
1262 }
1263 };
1264 let m_enableEventId = match m_enableEventId {
1265 _serde::__private::Some(__field) => __field,
1266 _serde::__private::None => {
1267 #[cfg(feature = "strict")]
1268 return _serde::__private::Err(
1269 <__A::Error as _serde::de::Error>::missing_field(
1270 "enableEventId",
1271 ),
1272 );
1273 #[cfg(not(feature = "strict"))] Default::default()
1274 }
1275 };
1276 let m_disableEventId = match m_disableEventId {
1277 _serde::__private::Some(__field) => __field,
1278 _serde::__private::None => {
1279 #[cfg(feature = "strict")]
1280 return _serde::__private::Err(
1281 <__A::Error as _serde::de::Error>::missing_field(
1282 "disableEventId",
1283 ),
1284 );
1285 #[cfg(not(feature = "strict"))] Default::default()
1286 }
1287 };
1288 let m_stringData = match m_stringData {
1289 _serde::__private::Some(__field) => __field,
1290 _serde::__private::None => {
1291 #[cfg(feature = "strict")]
1292 return _serde::__private::Err(
1293 <__A::Error as _serde::de::Error>::missing_field(
1294 "stringData",
1295 ),
1296 );
1297 #[cfg(not(feature = "strict"))] Default::default()
1298 }
1299 };
1300 let __ptr = None;
1301 let parent = hkBaseObject { __ptr };
1302 let parent = hkReferencedObject {
1303 __ptr,
1304 parent,
1305 ..Default::default()
1306 };
1307 let parent = hkbBindable {
1308 __ptr,
1309 parent,
1310 m_variableBindingSet,
1311 ..Default::default()
1312 };
1313 let parent = hkbNode {
1314 __ptr,
1315 parent,
1316 m_userData,
1317 m_name,
1318 ..Default::default()
1319 };
1320 let parent = hkbModifier {
1321 __ptr,
1322 parent,
1323 m_enable,
1324 ..Default::default()
1325 };
1326 let __ptr = __A::class_ptr(&mut __map);
1327 _serde::__private::Ok(hkbSequence {
1328 __ptr,
1329 parent,
1330 m_eventSequencedData,
1331 m_realVariableSequencedData,
1332 m_boolVariableSequencedData,
1333 m_intVariableSequencedData,
1334 m_enableEventId,
1335 m_disableEventId,
1336 m_stringData,
1337 ..Default::default()
1338 })
1339 }
1340 }
1341 const FIELDS: &[&str] = &[
1342 "eventSequencedData",
1343 "realVariableSequencedData",
1344 "boolVariableSequencedData",
1345 "intVariableSequencedData",
1346 "enableEventId",
1347 "disableEventId",
1348 "stringData",
1349 "variableIdMap",
1350 "eventIdMap",
1351 "nextSampleEvents",
1352 "nextSampleReals",
1353 "nextSampleBools",
1354 "nextSampleInts",
1355 "time",
1356 "isEnabled",
1357 ];
1358 _serde::Deserializer::deserialize_struct(
1359 deserializer,
1360 "hkbSequence",
1361 FIELDS,
1362 __hkbSequenceVisitor {
1363 marker: _serde::__private::PhantomData::<hkbSequence>,
1364 lifetime: _serde::__private::PhantomData,
1365 },
1366 )
1367 }
1368 }
1369};