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 hkbBehaviorGraph<'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: hkbGenerator<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "variableMode"))]
36 #[cfg_attr(feature = "serde", serde(rename = "variableMode"))]
37 pub m_variableMode: VariableMode,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "uniqueIdPool"))]
44 #[cfg_attr(feature = "serde", serde(rename = "uniqueIdPool"))]
45 pub m_uniqueIdPool: Vec<()>,
46 #[cfg_attr(
52 feature = "json_schema",
53 schemars(rename = "idToStateMachineTemplateMap")
54 )]
55 #[cfg_attr(feature = "serde", serde(rename = "idToStateMachineTemplateMap"))]
56 pub m_idToStateMachineTemplateMap: Pointer,
57 #[cfg_attr(feature = "json_schema", schemars(rename = "mirroredExternalIdMap"))]
63 #[cfg_attr(feature = "serde", serde(rename = "mirroredExternalIdMap"))]
64 pub m_mirroredExternalIdMap: Vec<()>,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "pseudoRandomGenerator"))]
71 #[cfg_attr(feature = "serde", serde(rename = "pseudoRandomGenerator"))]
72 pub m_pseudoRandomGenerator: Pointer,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "rootGenerator"))]
78 #[cfg_attr(feature = "serde", serde(rename = "rootGenerator"))]
79 pub m_rootGenerator: Pointer,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
85 #[cfg_attr(feature = "serde", serde(rename = "data"))]
86 pub m_data: Pointer,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "rootGeneratorClone"))]
93 #[cfg_attr(feature = "serde", serde(rename = "rootGeneratorClone"))]
94 pub m_rootGeneratorClone: Pointer,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "activeNodes"))]
101 #[cfg_attr(feature = "serde", serde(rename = "activeNodes"))]
102 pub m_activeNodes: Pointer,
103 #[cfg_attr(
109 feature = "json_schema",
110 schemars(rename = "activeNodeTemplateToIndexMap")
111 )]
112 #[cfg_attr(feature = "serde", serde(rename = "activeNodeTemplateToIndexMap"))]
113 pub m_activeNodeTemplateToIndexMap: Pointer,
114 #[cfg_attr(feature = "json_schema", schemars(rename = "activeNodesChildrenIndices"))]
120 #[cfg_attr(feature = "serde", serde(rename = "activeNodesChildrenIndices"))]
121 pub m_activeNodesChildrenIndices: Pointer,
122 #[cfg_attr(feature = "json_schema", schemars(rename = "globalTransitionData"))]
128 #[cfg_attr(feature = "serde", serde(rename = "globalTransitionData"))]
129 pub m_globalTransitionData: Pointer,
130 #[cfg_attr(feature = "json_schema", schemars(rename = "eventIdMap"))]
136 #[cfg_attr(feature = "serde", serde(rename = "eventIdMap"))]
137 pub m_eventIdMap: Pointer,
138 #[cfg_attr(feature = "json_schema", schemars(rename = "attributeIdMap"))]
144 #[cfg_attr(feature = "serde", serde(rename = "attributeIdMap"))]
145 pub m_attributeIdMap: Pointer,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "variableIdMap"))]
152 #[cfg_attr(feature = "serde", serde(rename = "variableIdMap"))]
153 pub m_variableIdMap: Pointer,
154 #[cfg_attr(feature = "json_schema", schemars(rename = "characterPropertyIdMap"))]
160 #[cfg_attr(feature = "serde", serde(rename = "characterPropertyIdMap"))]
161 pub m_characterPropertyIdMap: Pointer,
162 #[cfg_attr(feature = "json_schema", schemars(rename = "variableValueSet"))]
168 #[cfg_attr(feature = "serde", serde(rename = "variableValueSet"))]
169 pub m_variableValueSet: Pointer,
170 #[cfg_attr(feature = "json_schema", schemars(rename = "nodeTemplateToCloneMap"))]
176 #[cfg_attr(feature = "serde", serde(rename = "nodeTemplateToCloneMap"))]
177 pub m_nodeTemplateToCloneMap: Pointer,
178 #[cfg_attr(feature = "json_schema", schemars(rename = "nodeCloneToTemplateMap"))]
184 #[cfg_attr(feature = "serde", serde(rename = "nodeCloneToTemplateMap"))]
185 pub m_nodeCloneToTemplateMap: Pointer,
186 #[cfg_attr(
192 feature = "json_schema",
193 schemars(rename = "stateListenerTemplateToCloneMap")
194 )]
195 #[cfg_attr(feature = "serde", serde(rename = "stateListenerTemplateToCloneMap"))]
196 pub m_stateListenerTemplateToCloneMap: Pointer,
197 #[cfg_attr(feature = "json_schema", schemars(rename = "nodePartitionInfo"))]
203 #[cfg_attr(feature = "serde", serde(rename = "nodePartitionInfo"))]
204 pub m_nodePartitionInfo: Pointer,
205 #[cfg_attr(feature = "json_schema", schemars(rename = "numIntermediateOutputs"))]
211 #[cfg_attr(feature = "serde", serde(rename = "numIntermediateOutputs"))]
212 pub m_numIntermediateOutputs: i32,
213 #[cfg_attr(feature = "json_schema", schemars(rename = "jobs"))]
219 #[cfg_attr(feature = "serde", serde(rename = "jobs"))]
220 pub m_jobs: Vec<Pointer>,
221 #[cfg_attr(feature = "json_schema", schemars(rename = "allPartitionMemory"))]
227 #[cfg_attr(feature = "serde", serde(rename = "allPartitionMemory"))]
228 pub m_allPartitionMemory: Vec<Pointer>,
229 #[cfg_attr(feature = "json_schema", schemars(rename = "numStaticNodes"))]
235 #[cfg_attr(feature = "serde", serde(rename = "numStaticNodes"))]
236 pub m_numStaticNodes: i16,
237 #[cfg_attr(feature = "json_schema", schemars(rename = "nextUniqueId"))]
243 #[cfg_attr(feature = "serde", serde(rename = "nextUniqueId"))]
244 pub m_nextUniqueId: i16,
245 #[cfg_attr(feature = "json_schema", schemars(rename = "isActive"))]
251 #[cfg_attr(feature = "serde", serde(rename = "isActive"))]
252 pub m_isActive: bool,
253 #[cfg_attr(feature = "json_schema", schemars(rename = "isLinked"))]
259 #[cfg_attr(feature = "serde", serde(rename = "isLinked"))]
260 pub m_isLinked: bool,
261 #[cfg_attr(feature = "json_schema", schemars(rename = "updateActiveNodes"))]
267 #[cfg_attr(feature = "serde", serde(rename = "updateActiveNodes"))]
268 pub m_updateActiveNodes: bool,
269 #[cfg_attr(feature = "json_schema", schemars(rename = "stateOrTransitionChanged"))]
275 #[cfg_attr(feature = "serde", serde(rename = "stateOrTransitionChanged"))]
276 pub m_stateOrTransitionChanged: bool,
277}
278const _: () = {
279 use havok_serde as _serde;
280 impl<'a> _serde::HavokClass for hkbBehaviorGraph<'a> {
281 #[inline]
282 fn name(&self) -> &'static str {
283 "hkbBehaviorGraph"
284 }
285 #[inline]
286 fn signature(&self) -> _serde::__private::Signature {
287 _serde::__private::Signature::new(0xb1218f86)
288 }
289 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
290 fn deps_indexes(&self) -> Vec<usize> {
291 let mut v = Vec::new();
292 v.push(self.parent.parent.parent.m_variableBindingSet.get());
293 v.push(self.m_idToStateMachineTemplateMap.get());
294 v.push(self.m_pseudoRandomGenerator.get());
295 v.push(self.m_rootGenerator.get());
296 v.push(self.m_data.get());
297 v.push(self.m_rootGeneratorClone.get());
298 v.push(self.m_activeNodes.get());
299 v.push(self.m_activeNodeTemplateToIndexMap.get());
300 v.push(self.m_activeNodesChildrenIndices.get());
301 v.push(self.m_globalTransitionData.get());
302 v.push(self.m_eventIdMap.get());
303 v.push(self.m_attributeIdMap.get());
304 v.push(self.m_variableIdMap.get());
305 v.push(self.m_characterPropertyIdMap.get());
306 v.push(self.m_variableValueSet.get());
307 v.push(self.m_nodeTemplateToCloneMap.get());
308 v.push(self.m_nodeCloneToTemplateMap.get());
309 v.push(self.m_stateListenerTemplateToCloneMap.get());
310 v.push(self.m_nodePartitionInfo.get());
311 v.extend(self.m_jobs.iter().map(|ptr| ptr.get()));
312 v.extend(self.m_allPartitionMemory.iter().map(|ptr| ptr.get()));
313 v
314 }
315 }
316 impl<'a> _serde::Serialize for hkbBehaviorGraph<'a> {
317 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
318 where
319 S: _serde::ser::Serializer,
320 {
321 let class_meta = self
322 .__ptr
323 .map(|name| (name, _serde::__private::Signature::new(0xb1218f86)));
324 let mut serializer = __serializer
325 .serialize_struct("hkbBehaviorGraph", class_meta, (176u64, 304u64))?;
326 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
327 serializer
328 .skip_field(
329 "memSizeAndFlags",
330 &self.parent.parent.parent.parent.m_memSizeAndFlags,
331 )?;
332 serializer
333 .skip_field(
334 "referenceCount",
335 &self.parent.parent.parent.parent.m_referenceCount,
336 )?;
337 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
338 serializer
339 .serialize_field(
340 "variableBindingSet",
341 &self.parent.parent.parent.m_variableBindingSet,
342 )?;
343 serializer
344 .skip_array_field(
345 "cachedBindables",
346 &self.parent.parent.parent.m_cachedBindables,
347 TypeSize::NonPtr,
348 )?;
349 serializer
350 .skip_field(
351 "areBindablesCached",
352 &self.parent.parent.parent.m_areBindablesCached,
353 )?;
354 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
355 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
356 serializer.serialize_field("name", &self.parent.parent.m_name)?;
357 serializer.skip_field("id", &self.parent.parent.m_id)?;
358 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
359 serializer
360 .skip_fixed_array_field(
361 "padNode",
362 self.parent.parent.m_padNode.as_slice(),
363 TypeSize::NonPtr,
364 )?;
365 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
366 serializer.serialize_field("variableMode", &self.m_variableMode)?;
367 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
368 serializer
369 .skip_array_field(
370 "uniqueIdPool",
371 &self.m_uniqueIdPool,
372 TypeSize::NonPtr,
373 )?;
374 serializer
375 .skip_field(
376 "idToStateMachineTemplateMap",
377 &self.m_idToStateMachineTemplateMap,
378 )?;
379 serializer
380 .skip_array_field(
381 "mirroredExternalIdMap",
382 &self.m_mirroredExternalIdMap,
383 TypeSize::NonPtr,
384 )?;
385 serializer
386 .skip_field("pseudoRandomGenerator", &self.m_pseudoRandomGenerator)?;
387 serializer.serialize_field("rootGenerator", &self.m_rootGenerator)?;
388 serializer.serialize_field("data", &self.m_data)?;
389 serializer.skip_field("rootGeneratorClone", &self.m_rootGeneratorClone)?;
390 serializer.skip_field("activeNodes", &self.m_activeNodes)?;
391 serializer
392 .skip_field(
393 "activeNodeTemplateToIndexMap",
394 &self.m_activeNodeTemplateToIndexMap,
395 )?;
396 serializer
397 .skip_field(
398 "activeNodesChildrenIndices",
399 &self.m_activeNodesChildrenIndices,
400 )?;
401 serializer.skip_field("globalTransitionData", &self.m_globalTransitionData)?;
402 serializer.skip_field("eventIdMap", &self.m_eventIdMap)?;
403 serializer.skip_field("attributeIdMap", &self.m_attributeIdMap)?;
404 serializer.skip_field("variableIdMap", &self.m_variableIdMap)?;
405 serializer
406 .skip_field("characterPropertyIdMap", &self.m_characterPropertyIdMap)?;
407 serializer.skip_field("variableValueSet", &self.m_variableValueSet)?;
408 serializer
409 .skip_field("nodeTemplateToCloneMap", &self.m_nodeTemplateToCloneMap)?;
410 serializer
411 .skip_field("nodeCloneToTemplateMap", &self.m_nodeCloneToTemplateMap)?;
412 serializer
413 .skip_field(
414 "stateListenerTemplateToCloneMap",
415 &self.m_stateListenerTemplateToCloneMap,
416 )?;
417 serializer.skip_field("nodePartitionInfo", &self.m_nodePartitionInfo)?;
418 serializer
419 .skip_field("numIntermediateOutputs", &self.m_numIntermediateOutputs)?;
420 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
421 serializer.skip_array_field("jobs", &self.m_jobs, TypeSize::NonPtr)?;
422 serializer
423 .skip_array_field(
424 "allPartitionMemory",
425 &self.m_allPartitionMemory,
426 TypeSize::NonPtr,
427 )?;
428 serializer.skip_field("numStaticNodes", &self.m_numStaticNodes)?;
429 serializer.skip_field("nextUniqueId", &self.m_nextUniqueId)?;
430 serializer.skip_field("isActive", &self.m_isActive)?;
431 serializer.skip_field("isLinked", &self.m_isLinked)?;
432 serializer.skip_field("updateActiveNodes", &self.m_updateActiveNodes)?;
433 serializer
434 .skip_field(
435 "stateOrTransitionChanged",
436 &self.m_stateOrTransitionChanged,
437 )?;
438 serializer.end()
439 }
440 }
441};
442#[doc(hidden)]
443#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
444const _: () = {
445 use havok_serde as _serde;
446 #[automatically_derived]
447 impl<'de> _serde::Deserialize<'de> for hkbBehaviorGraph<'de> {
448 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
449 where
450 __D: _serde::Deserializer<'de>,
451 {
452 #[allow(non_camel_case_types)]
453 enum __Field {
454 m_variableBindingSet,
455 m_userData,
456 m_name,
457 m_variableMode,
458 m_rootGenerator,
459 m_data,
460 __ignore,
461 }
462 struct __FieldVisitor;
463 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
464 type Value = __Field;
465 fn expecting(
466 &self,
467 __formatter: &mut core::fmt::Formatter,
468 ) -> core::fmt::Result {
469 core::fmt::Formatter::write_str(__formatter, "field identifier")
470 }
471 #[allow(clippy::match_single_binding)]
473 #[allow(clippy::reversed_empty_ranges)]
474 #[allow(clippy::single_match)]
475 fn visit_key<__E>(
476 self,
477 __value: &str,
478 ) -> core::result::Result<Self::Value, __E>
479 where
480 __E: _serde::de::Error,
481 {
482 match __value {
483 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
484 "userData" => Ok(__Field::m_userData),
485 "name" => Ok(__Field::m_name),
486 "variableMode" => Ok(__Field::m_variableMode),
487 "rootGenerator" => Ok(__Field::m_rootGenerator),
488 "data" => Ok(__Field::m_data),
489 _ => Ok(__Field::__ignore),
490 }
491 }
492 }
493 impl<'de> _serde::Deserialize<'de> for __Field {
494 #[inline]
495 fn deserialize<__D>(
496 __deserializer: __D,
497 ) -> core::result::Result<Self, __D::Error>
498 where
499 __D: _serde::Deserializer<'de>,
500 {
501 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
502 }
503 }
504 struct __hkbBehaviorGraphVisitor<'de> {
505 marker: _serde::__private::PhantomData<hkbBehaviorGraph<'de>>,
506 lifetime: _serde::__private::PhantomData<&'de ()>,
507 }
508 #[allow(clippy::match_single_binding)]
509 #[allow(clippy::reversed_empty_ranges)]
510 #[allow(clippy::single_match)]
511 impl<'de> _serde::de::Visitor<'de> for __hkbBehaviorGraphVisitor<'de> {
512 type Value = hkbBehaviorGraph<'de>;
513 fn expecting(
514 &self,
515 __formatter: &mut core::fmt::Formatter,
516 ) -> core::fmt::Result {
517 core::fmt::Formatter::write_str(
518 __formatter,
519 "struct hkbBehaviorGraph",
520 )
521 }
522 fn visit_struct_for_bytes<__A>(
523 self,
524 mut __map: __A,
525 ) -> _serde::__private::Result<Self::Value, __A::Error>
526 where
527 __A: _serde::de::MapAccess<'de>,
528 {
529 let __ptr = __A::class_ptr(&mut __map);
530 let parent = __A::parent_value(&mut __map)?;
531 let mut m_variableMode: _serde::__private::Option<VariableMode> = _serde::__private::None;
532 let mut m_uniqueIdPool: _serde::__private::Option<Vec<()>> = _serde::__private::None;
533 let mut m_idToStateMachineTemplateMap: _serde::__private::Option<
534 Pointer,
535 > = _serde::__private::None;
536 let mut m_mirroredExternalIdMap: _serde::__private::Option<
537 Vec<()>,
538 > = _serde::__private::None;
539 let mut m_pseudoRandomGenerator: _serde::__private::Option<
540 Pointer,
541 > = _serde::__private::None;
542 let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
543 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
544 let mut m_rootGeneratorClone: _serde::__private::Option<Pointer> = _serde::__private::None;
545 let mut m_activeNodes: _serde::__private::Option<Pointer> = _serde::__private::None;
546 let mut m_activeNodeTemplateToIndexMap: _serde::__private::Option<
547 Pointer,
548 > = _serde::__private::None;
549 let mut m_activeNodesChildrenIndices: _serde::__private::Option<
550 Pointer,
551 > = _serde::__private::None;
552 let mut m_globalTransitionData: _serde::__private::Option<Pointer> = _serde::__private::None;
553 let mut m_eventIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
554 let mut m_attributeIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
555 let mut m_variableIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
556 let mut m_characterPropertyIdMap: _serde::__private::Option<
557 Pointer,
558 > = _serde::__private::None;
559 let mut m_variableValueSet: _serde::__private::Option<Pointer> = _serde::__private::None;
560 let mut m_nodeTemplateToCloneMap: _serde::__private::Option<
561 Pointer,
562 > = _serde::__private::None;
563 let mut m_nodeCloneToTemplateMap: _serde::__private::Option<
564 Pointer,
565 > = _serde::__private::None;
566 let mut m_stateListenerTemplateToCloneMap: _serde::__private::Option<
567 Pointer,
568 > = _serde::__private::None;
569 let mut m_nodePartitionInfo: _serde::__private::Option<Pointer> = _serde::__private::None;
570 let mut m_numIntermediateOutputs: _serde::__private::Option<i32> = _serde::__private::None;
571 let mut m_jobs: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
572 let mut m_allPartitionMemory: _serde::__private::Option<
573 Vec<Pointer>,
574 > = _serde::__private::None;
575 let mut m_numStaticNodes: _serde::__private::Option<i16> = _serde::__private::None;
576 let mut m_nextUniqueId: _serde::__private::Option<i16> = _serde::__private::None;
577 let mut m_isActive: _serde::__private::Option<bool> = _serde::__private::None;
578 let mut m_isLinked: _serde::__private::Option<bool> = _serde::__private::None;
579 let mut m_updateActiveNodes: _serde::__private::Option<bool> = _serde::__private::None;
580 let mut m_stateOrTransitionChanged: _serde::__private::Option<
581 bool,
582 > = _serde::__private::None;
583 for i in 0..30usize {
584 match i {
585 0usize => {
586 if _serde::__private::Option::is_some(&m_variableMode) {
587 return _serde::__private::Err(
588 <__A::Error as _serde::de::Error>::duplicate_field(
589 "variableMode",
590 ),
591 );
592 }
593 m_variableMode = _serde::__private::Some(
594 match __A::next_value::<VariableMode>(&mut __map) {
595 _serde::__private::Ok(__val) => __val,
596 _serde::__private::Err(__err) => {
597 return _serde::__private::Err(__err);
598 }
599 },
600 );
601 }
602 1usize => {
603 if _serde::__private::Option::is_some(&m_uniqueIdPool) {
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::duplicate_field(
606 "uniqueIdPool",
607 ),
608 );
609 }
610 __A::pad(&mut __map, 3usize, 7usize)?;
611 m_uniqueIdPool = _serde::__private::Some(
612 match __A::next_value::<Vec<()>>(&mut __map) {
613 _serde::__private::Ok(__val) => __val,
614 _serde::__private::Err(__err) => {
615 return _serde::__private::Err(__err);
616 }
617 },
618 );
619 }
620 2usize => {
621 if _serde::__private::Option::is_some(
622 &m_idToStateMachineTemplateMap,
623 ) {
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::duplicate_field(
626 "idToStateMachineTemplateMap",
627 ),
628 );
629 }
630 m_idToStateMachineTemplateMap = _serde::__private::Some(
631 match __A::next_value::<Pointer>(&mut __map) {
632 _serde::__private::Ok(__val) => __val,
633 _serde::__private::Err(__err) => {
634 return _serde::__private::Err(__err);
635 }
636 },
637 );
638 }
639 3usize => {
640 if _serde::__private::Option::is_some(
641 &m_mirroredExternalIdMap,
642 ) {
643 return _serde::__private::Err(
644 <__A::Error as _serde::de::Error>::duplicate_field(
645 "mirroredExternalIdMap",
646 ),
647 );
648 }
649 m_mirroredExternalIdMap = _serde::__private::Some(
650 match __A::next_value::<Vec<()>>(&mut __map) {
651 _serde::__private::Ok(__val) => __val,
652 _serde::__private::Err(__err) => {
653 return _serde::__private::Err(__err);
654 }
655 },
656 );
657 }
658 4usize => {
659 if _serde::__private::Option::is_some(
660 &m_pseudoRandomGenerator,
661 ) {
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::duplicate_field(
664 "pseudoRandomGenerator",
665 ),
666 );
667 }
668 m_pseudoRandomGenerator = _serde::__private::Some(
669 match __A::next_value::<Pointer>(&mut __map) {
670 _serde::__private::Ok(__val) => __val,
671 _serde::__private::Err(__err) => {
672 return _serde::__private::Err(__err);
673 }
674 },
675 );
676 }
677 5usize => {
678 if _serde::__private::Option::is_some(&m_rootGenerator) {
679 return _serde::__private::Err(
680 <__A::Error as _serde::de::Error>::duplicate_field(
681 "rootGenerator",
682 ),
683 );
684 }
685 m_rootGenerator = _serde::__private::Some(
686 match __A::next_value::<Pointer>(&mut __map) {
687 _serde::__private::Ok(__val) => __val,
688 _serde::__private::Err(__err) => {
689 return _serde::__private::Err(__err);
690 }
691 },
692 );
693 }
694 6usize => {
695 if _serde::__private::Option::is_some(&m_data) {
696 return _serde::__private::Err(
697 <__A::Error as _serde::de::Error>::duplicate_field("data"),
698 );
699 }
700 m_data = _serde::__private::Some(
701 match __A::next_value::<Pointer>(&mut __map) {
702 _serde::__private::Ok(__val) => __val,
703 _serde::__private::Err(__err) => {
704 return _serde::__private::Err(__err);
705 }
706 },
707 );
708 }
709 7usize => {
710 if _serde::__private::Option::is_some(
711 &m_rootGeneratorClone,
712 ) {
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::duplicate_field(
715 "rootGeneratorClone",
716 ),
717 );
718 }
719 m_rootGeneratorClone = _serde::__private::Some(
720 match __A::next_value::<Pointer>(&mut __map) {
721 _serde::__private::Ok(__val) => __val,
722 _serde::__private::Err(__err) => {
723 return _serde::__private::Err(__err);
724 }
725 },
726 );
727 }
728 8usize => {
729 if _serde::__private::Option::is_some(&m_activeNodes) {
730 return _serde::__private::Err(
731 <__A::Error as _serde::de::Error>::duplicate_field(
732 "activeNodes",
733 ),
734 );
735 }
736 m_activeNodes = _serde::__private::Some(
737 match __A::next_value::<Pointer>(&mut __map) {
738 _serde::__private::Ok(__val) => __val,
739 _serde::__private::Err(__err) => {
740 return _serde::__private::Err(__err);
741 }
742 },
743 );
744 }
745 9usize => {
746 if _serde::__private::Option::is_some(
747 &m_activeNodeTemplateToIndexMap,
748 ) {
749 return _serde::__private::Err(
750 <__A::Error as _serde::de::Error>::duplicate_field(
751 "activeNodeTemplateToIndexMap",
752 ),
753 );
754 }
755 m_activeNodeTemplateToIndexMap = _serde::__private::Some(
756 match __A::next_value::<Pointer>(&mut __map) {
757 _serde::__private::Ok(__val) => __val,
758 _serde::__private::Err(__err) => {
759 return _serde::__private::Err(__err);
760 }
761 },
762 );
763 }
764 10usize => {
765 if _serde::__private::Option::is_some(
766 &m_activeNodesChildrenIndices,
767 ) {
768 return _serde::__private::Err(
769 <__A::Error as _serde::de::Error>::duplicate_field(
770 "activeNodesChildrenIndices",
771 ),
772 );
773 }
774 m_activeNodesChildrenIndices = _serde::__private::Some(
775 match __A::next_value::<Pointer>(&mut __map) {
776 _serde::__private::Ok(__val) => __val,
777 _serde::__private::Err(__err) => {
778 return _serde::__private::Err(__err);
779 }
780 },
781 );
782 }
783 11usize => {
784 if _serde::__private::Option::is_some(
785 &m_globalTransitionData,
786 ) {
787 return _serde::__private::Err(
788 <__A::Error as _serde::de::Error>::duplicate_field(
789 "globalTransitionData",
790 ),
791 );
792 }
793 m_globalTransitionData = _serde::__private::Some(
794 match __A::next_value::<Pointer>(&mut __map) {
795 _serde::__private::Ok(__val) => __val,
796 _serde::__private::Err(__err) => {
797 return _serde::__private::Err(__err);
798 }
799 },
800 );
801 }
802 12usize => {
803 if _serde::__private::Option::is_some(&m_eventIdMap) {
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::duplicate_field(
806 "eventIdMap",
807 ),
808 );
809 }
810 m_eventIdMap = _serde::__private::Some(
811 match __A::next_value::<Pointer>(&mut __map) {
812 _serde::__private::Ok(__val) => __val,
813 _serde::__private::Err(__err) => {
814 return _serde::__private::Err(__err);
815 }
816 },
817 );
818 }
819 13usize => {
820 if _serde::__private::Option::is_some(&m_attributeIdMap) {
821 return _serde::__private::Err(
822 <__A::Error as _serde::de::Error>::duplicate_field(
823 "attributeIdMap",
824 ),
825 );
826 }
827 m_attributeIdMap = _serde::__private::Some(
828 match __A::next_value::<Pointer>(&mut __map) {
829 _serde::__private::Ok(__val) => __val,
830 _serde::__private::Err(__err) => {
831 return _serde::__private::Err(__err);
832 }
833 },
834 );
835 }
836 14usize => {
837 if _serde::__private::Option::is_some(&m_variableIdMap) {
838 return _serde::__private::Err(
839 <__A::Error as _serde::de::Error>::duplicate_field(
840 "variableIdMap",
841 ),
842 );
843 }
844 m_variableIdMap = _serde::__private::Some(
845 match __A::next_value::<Pointer>(&mut __map) {
846 _serde::__private::Ok(__val) => __val,
847 _serde::__private::Err(__err) => {
848 return _serde::__private::Err(__err);
849 }
850 },
851 );
852 }
853 15usize => {
854 if _serde::__private::Option::is_some(
855 &m_characterPropertyIdMap,
856 ) {
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::duplicate_field(
859 "characterPropertyIdMap",
860 ),
861 );
862 }
863 m_characterPropertyIdMap = _serde::__private::Some(
864 match __A::next_value::<Pointer>(&mut __map) {
865 _serde::__private::Ok(__val) => __val,
866 _serde::__private::Err(__err) => {
867 return _serde::__private::Err(__err);
868 }
869 },
870 );
871 }
872 16usize => {
873 if _serde::__private::Option::is_some(&m_variableValueSet) {
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::duplicate_field(
876 "variableValueSet",
877 ),
878 );
879 }
880 m_variableValueSet = _serde::__private::Some(
881 match __A::next_value::<Pointer>(&mut __map) {
882 _serde::__private::Ok(__val) => __val,
883 _serde::__private::Err(__err) => {
884 return _serde::__private::Err(__err);
885 }
886 },
887 );
888 }
889 17usize => {
890 if _serde::__private::Option::is_some(
891 &m_nodeTemplateToCloneMap,
892 ) {
893 return _serde::__private::Err(
894 <__A::Error as _serde::de::Error>::duplicate_field(
895 "nodeTemplateToCloneMap",
896 ),
897 );
898 }
899 m_nodeTemplateToCloneMap = _serde::__private::Some(
900 match __A::next_value::<Pointer>(&mut __map) {
901 _serde::__private::Ok(__val) => __val,
902 _serde::__private::Err(__err) => {
903 return _serde::__private::Err(__err);
904 }
905 },
906 );
907 }
908 18usize => {
909 if _serde::__private::Option::is_some(
910 &m_nodeCloneToTemplateMap,
911 ) {
912 return _serde::__private::Err(
913 <__A::Error as _serde::de::Error>::duplicate_field(
914 "nodeCloneToTemplateMap",
915 ),
916 );
917 }
918 m_nodeCloneToTemplateMap = _serde::__private::Some(
919 match __A::next_value::<Pointer>(&mut __map) {
920 _serde::__private::Ok(__val) => __val,
921 _serde::__private::Err(__err) => {
922 return _serde::__private::Err(__err);
923 }
924 },
925 );
926 }
927 19usize => {
928 if _serde::__private::Option::is_some(
929 &m_stateListenerTemplateToCloneMap,
930 ) {
931 return _serde::__private::Err(
932 <__A::Error as _serde::de::Error>::duplicate_field(
933 "stateListenerTemplateToCloneMap",
934 ),
935 );
936 }
937 m_stateListenerTemplateToCloneMap = _serde::__private::Some(
938 match __A::next_value::<Pointer>(&mut __map) {
939 _serde::__private::Ok(__val) => __val,
940 _serde::__private::Err(__err) => {
941 return _serde::__private::Err(__err);
942 }
943 },
944 );
945 }
946 20usize => {
947 if _serde::__private::Option::is_some(
948 &m_nodePartitionInfo,
949 ) {
950 return _serde::__private::Err(
951 <__A::Error as _serde::de::Error>::duplicate_field(
952 "nodePartitionInfo",
953 ),
954 );
955 }
956 m_nodePartitionInfo = _serde::__private::Some(
957 match __A::next_value::<Pointer>(&mut __map) {
958 _serde::__private::Ok(__val) => __val,
959 _serde::__private::Err(__err) => {
960 return _serde::__private::Err(__err);
961 }
962 },
963 );
964 }
965 21usize => {
966 if _serde::__private::Option::is_some(
967 &m_numIntermediateOutputs,
968 ) {
969 return _serde::__private::Err(
970 <__A::Error as _serde::de::Error>::duplicate_field(
971 "numIntermediateOutputs",
972 ),
973 );
974 }
975 m_numIntermediateOutputs = _serde::__private::Some(
976 match __A::next_value::<i32>(&mut __map) {
977 _serde::__private::Ok(__val) => __val,
978 _serde::__private::Err(__err) => {
979 return _serde::__private::Err(__err);
980 }
981 },
982 );
983 }
984 22usize => {
985 if _serde::__private::Option::is_some(&m_jobs) {
986 return _serde::__private::Err(
987 <__A::Error as _serde::de::Error>::duplicate_field("jobs"),
988 );
989 }
990 __A::pad(&mut __map, 0usize, 4usize)?;
991 m_jobs = _serde::__private::Some(
992 match __A::next_value::<Vec<Pointer>>(&mut __map) {
993 _serde::__private::Ok(__val) => __val,
994 _serde::__private::Err(__err) => {
995 return _serde::__private::Err(__err);
996 }
997 },
998 );
999 }
1000 23usize => {
1001 if _serde::__private::Option::is_some(
1002 &m_allPartitionMemory,
1003 ) {
1004 return _serde::__private::Err(
1005 <__A::Error as _serde::de::Error>::duplicate_field(
1006 "allPartitionMemory",
1007 ),
1008 );
1009 }
1010 m_allPartitionMemory = _serde::__private::Some(
1011 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1012 _serde::__private::Ok(__val) => __val,
1013 _serde::__private::Err(__err) => {
1014 return _serde::__private::Err(__err);
1015 }
1016 },
1017 );
1018 }
1019 24usize => {
1020 if _serde::__private::Option::is_some(&m_numStaticNodes) {
1021 return _serde::__private::Err(
1022 <__A::Error as _serde::de::Error>::duplicate_field(
1023 "numStaticNodes",
1024 ),
1025 );
1026 }
1027 m_numStaticNodes = _serde::__private::Some(
1028 match __A::next_value::<i16>(&mut __map) {
1029 _serde::__private::Ok(__val) => __val,
1030 _serde::__private::Err(__err) => {
1031 return _serde::__private::Err(__err);
1032 }
1033 },
1034 );
1035 }
1036 25usize => {
1037 if _serde::__private::Option::is_some(&m_nextUniqueId) {
1038 return _serde::__private::Err(
1039 <__A::Error as _serde::de::Error>::duplicate_field(
1040 "nextUniqueId",
1041 ),
1042 );
1043 }
1044 m_nextUniqueId = _serde::__private::Some(
1045 match __A::next_value::<i16>(&mut __map) {
1046 _serde::__private::Ok(__val) => __val,
1047 _serde::__private::Err(__err) => {
1048 return _serde::__private::Err(__err);
1049 }
1050 },
1051 );
1052 }
1053 26usize => {
1054 if _serde::__private::Option::is_some(&m_isActive) {
1055 return _serde::__private::Err(
1056 <__A::Error as _serde::de::Error>::duplicate_field(
1057 "isActive",
1058 ),
1059 );
1060 }
1061 m_isActive = _serde::__private::Some(
1062 match __A::next_value::<bool>(&mut __map) {
1063 _serde::__private::Ok(__val) => __val,
1064 _serde::__private::Err(__err) => {
1065 return _serde::__private::Err(__err);
1066 }
1067 },
1068 );
1069 }
1070 27usize => {
1071 if _serde::__private::Option::is_some(&m_isLinked) {
1072 return _serde::__private::Err(
1073 <__A::Error as _serde::de::Error>::duplicate_field(
1074 "isLinked",
1075 ),
1076 );
1077 }
1078 m_isLinked = _serde::__private::Some(
1079 match __A::next_value::<bool>(&mut __map) {
1080 _serde::__private::Ok(__val) => __val,
1081 _serde::__private::Err(__err) => {
1082 return _serde::__private::Err(__err);
1083 }
1084 },
1085 );
1086 }
1087 28usize => {
1088 if _serde::__private::Option::is_some(
1089 &m_updateActiveNodes,
1090 ) {
1091 return _serde::__private::Err(
1092 <__A::Error as _serde::de::Error>::duplicate_field(
1093 "updateActiveNodes",
1094 ),
1095 );
1096 }
1097 m_updateActiveNodes = _serde::__private::Some(
1098 match __A::next_value::<bool>(&mut __map) {
1099 _serde::__private::Ok(__val) => __val,
1100 _serde::__private::Err(__err) => {
1101 return _serde::__private::Err(__err);
1102 }
1103 },
1104 );
1105 }
1106 29usize => {
1107 if _serde::__private::Option::is_some(
1108 &m_stateOrTransitionChanged,
1109 ) {
1110 return _serde::__private::Err(
1111 <__A::Error as _serde::de::Error>::duplicate_field(
1112 "stateOrTransitionChanged",
1113 ),
1114 );
1115 }
1116 m_stateOrTransitionChanged = _serde::__private::Some(
1117 match __A::next_value::<bool>(&mut __map) {
1118 _serde::__private::Ok(__val) => __val,
1119 _serde::__private::Err(__err) => {
1120 return _serde::__private::Err(__err);
1121 }
1122 },
1123 );
1124 }
1125 _ => {}
1126 }
1127 }
1128 let m_variableMode = match m_variableMode {
1129 _serde::__private::Some(__field) => __field,
1130 _serde::__private::None => {
1131 return _serde::__private::Err(
1132 <__A::Error as _serde::de::Error>::missing_field(
1133 "variableMode",
1134 ),
1135 );
1136 }
1137 };
1138 let m_uniqueIdPool = match m_uniqueIdPool {
1139 _serde::__private::Some(__field) => __field,
1140 _serde::__private::None => {
1141 return _serde::__private::Err(
1142 <__A::Error as _serde::de::Error>::missing_field(
1143 "uniqueIdPool",
1144 ),
1145 );
1146 }
1147 };
1148 let m_idToStateMachineTemplateMap = match m_idToStateMachineTemplateMap {
1149 _serde::__private::Some(__field) => __field,
1150 _serde::__private::None => {
1151 return _serde::__private::Err(
1152 <__A::Error as _serde::de::Error>::missing_field(
1153 "idToStateMachineTemplateMap",
1154 ),
1155 );
1156 }
1157 };
1158 let m_mirroredExternalIdMap = match m_mirroredExternalIdMap {
1159 _serde::__private::Some(__field) => __field,
1160 _serde::__private::None => {
1161 return _serde::__private::Err(
1162 <__A::Error as _serde::de::Error>::missing_field(
1163 "mirroredExternalIdMap",
1164 ),
1165 );
1166 }
1167 };
1168 let m_pseudoRandomGenerator = match m_pseudoRandomGenerator {
1169 _serde::__private::Some(__field) => __field,
1170 _serde::__private::None => {
1171 return _serde::__private::Err(
1172 <__A::Error as _serde::de::Error>::missing_field(
1173 "pseudoRandomGenerator",
1174 ),
1175 );
1176 }
1177 };
1178 let m_rootGenerator = match m_rootGenerator {
1179 _serde::__private::Some(__field) => __field,
1180 _serde::__private::None => {
1181 return _serde::__private::Err(
1182 <__A::Error as _serde::de::Error>::missing_field(
1183 "rootGenerator",
1184 ),
1185 );
1186 }
1187 };
1188 let m_data = match m_data {
1189 _serde::__private::Some(__field) => __field,
1190 _serde::__private::None => {
1191 return _serde::__private::Err(
1192 <__A::Error as _serde::de::Error>::missing_field("data"),
1193 );
1194 }
1195 };
1196 let m_rootGeneratorClone = match m_rootGeneratorClone {
1197 _serde::__private::Some(__field) => __field,
1198 _serde::__private::None => {
1199 return _serde::__private::Err(
1200 <__A::Error as _serde::de::Error>::missing_field(
1201 "rootGeneratorClone",
1202 ),
1203 );
1204 }
1205 };
1206 let m_activeNodes = match m_activeNodes {
1207 _serde::__private::Some(__field) => __field,
1208 _serde::__private::None => {
1209 return _serde::__private::Err(
1210 <__A::Error as _serde::de::Error>::missing_field(
1211 "activeNodes",
1212 ),
1213 );
1214 }
1215 };
1216 let m_activeNodeTemplateToIndexMap = match m_activeNodeTemplateToIndexMap {
1217 _serde::__private::Some(__field) => __field,
1218 _serde::__private::None => {
1219 return _serde::__private::Err(
1220 <__A::Error as _serde::de::Error>::missing_field(
1221 "activeNodeTemplateToIndexMap",
1222 ),
1223 );
1224 }
1225 };
1226 let m_activeNodesChildrenIndices = match m_activeNodesChildrenIndices {
1227 _serde::__private::Some(__field) => __field,
1228 _serde::__private::None => {
1229 return _serde::__private::Err(
1230 <__A::Error as _serde::de::Error>::missing_field(
1231 "activeNodesChildrenIndices",
1232 ),
1233 );
1234 }
1235 };
1236 let m_globalTransitionData = match m_globalTransitionData {
1237 _serde::__private::Some(__field) => __field,
1238 _serde::__private::None => {
1239 return _serde::__private::Err(
1240 <__A::Error as _serde::de::Error>::missing_field(
1241 "globalTransitionData",
1242 ),
1243 );
1244 }
1245 };
1246 let m_eventIdMap = match m_eventIdMap {
1247 _serde::__private::Some(__field) => __field,
1248 _serde::__private::None => {
1249 return _serde::__private::Err(
1250 <__A::Error as _serde::de::Error>::missing_field(
1251 "eventIdMap",
1252 ),
1253 );
1254 }
1255 };
1256 let m_attributeIdMap = match m_attributeIdMap {
1257 _serde::__private::Some(__field) => __field,
1258 _serde::__private::None => {
1259 return _serde::__private::Err(
1260 <__A::Error as _serde::de::Error>::missing_field(
1261 "attributeIdMap",
1262 ),
1263 );
1264 }
1265 };
1266 let m_variableIdMap = match m_variableIdMap {
1267 _serde::__private::Some(__field) => __field,
1268 _serde::__private::None => {
1269 return _serde::__private::Err(
1270 <__A::Error as _serde::de::Error>::missing_field(
1271 "variableIdMap",
1272 ),
1273 );
1274 }
1275 };
1276 let m_characterPropertyIdMap = match m_characterPropertyIdMap {
1277 _serde::__private::Some(__field) => __field,
1278 _serde::__private::None => {
1279 return _serde::__private::Err(
1280 <__A::Error as _serde::de::Error>::missing_field(
1281 "characterPropertyIdMap",
1282 ),
1283 );
1284 }
1285 };
1286 let m_variableValueSet = match m_variableValueSet {
1287 _serde::__private::Some(__field) => __field,
1288 _serde::__private::None => {
1289 return _serde::__private::Err(
1290 <__A::Error as _serde::de::Error>::missing_field(
1291 "variableValueSet",
1292 ),
1293 );
1294 }
1295 };
1296 let m_nodeTemplateToCloneMap = match m_nodeTemplateToCloneMap {
1297 _serde::__private::Some(__field) => __field,
1298 _serde::__private::None => {
1299 return _serde::__private::Err(
1300 <__A::Error as _serde::de::Error>::missing_field(
1301 "nodeTemplateToCloneMap",
1302 ),
1303 );
1304 }
1305 };
1306 let m_nodeCloneToTemplateMap = match m_nodeCloneToTemplateMap {
1307 _serde::__private::Some(__field) => __field,
1308 _serde::__private::None => {
1309 return _serde::__private::Err(
1310 <__A::Error as _serde::de::Error>::missing_field(
1311 "nodeCloneToTemplateMap",
1312 ),
1313 );
1314 }
1315 };
1316 let m_stateListenerTemplateToCloneMap = match m_stateListenerTemplateToCloneMap {
1317 _serde::__private::Some(__field) => __field,
1318 _serde::__private::None => {
1319 return _serde::__private::Err(
1320 <__A::Error as _serde::de::Error>::missing_field(
1321 "stateListenerTemplateToCloneMap",
1322 ),
1323 );
1324 }
1325 };
1326 let m_nodePartitionInfo = match m_nodePartitionInfo {
1327 _serde::__private::Some(__field) => __field,
1328 _serde::__private::None => {
1329 return _serde::__private::Err(
1330 <__A::Error as _serde::de::Error>::missing_field(
1331 "nodePartitionInfo",
1332 ),
1333 );
1334 }
1335 };
1336 let m_numIntermediateOutputs = match m_numIntermediateOutputs {
1337 _serde::__private::Some(__field) => __field,
1338 _serde::__private::None => {
1339 return _serde::__private::Err(
1340 <__A::Error as _serde::de::Error>::missing_field(
1341 "numIntermediateOutputs",
1342 ),
1343 );
1344 }
1345 };
1346 let m_jobs = match m_jobs {
1347 _serde::__private::Some(__field) => __field,
1348 _serde::__private::None => {
1349 return _serde::__private::Err(
1350 <__A::Error as _serde::de::Error>::missing_field("jobs"),
1351 );
1352 }
1353 };
1354 let m_allPartitionMemory = match m_allPartitionMemory {
1355 _serde::__private::Some(__field) => __field,
1356 _serde::__private::None => {
1357 return _serde::__private::Err(
1358 <__A::Error as _serde::de::Error>::missing_field(
1359 "allPartitionMemory",
1360 ),
1361 );
1362 }
1363 };
1364 let m_numStaticNodes = match m_numStaticNodes {
1365 _serde::__private::Some(__field) => __field,
1366 _serde::__private::None => {
1367 return _serde::__private::Err(
1368 <__A::Error as _serde::de::Error>::missing_field(
1369 "numStaticNodes",
1370 ),
1371 );
1372 }
1373 };
1374 let m_nextUniqueId = match m_nextUniqueId {
1375 _serde::__private::Some(__field) => __field,
1376 _serde::__private::None => {
1377 return _serde::__private::Err(
1378 <__A::Error as _serde::de::Error>::missing_field(
1379 "nextUniqueId",
1380 ),
1381 );
1382 }
1383 };
1384 let m_isActive = match m_isActive {
1385 _serde::__private::Some(__field) => __field,
1386 _serde::__private::None => {
1387 return _serde::__private::Err(
1388 <__A::Error as _serde::de::Error>::missing_field("isActive"),
1389 );
1390 }
1391 };
1392 let m_isLinked = match m_isLinked {
1393 _serde::__private::Some(__field) => __field,
1394 _serde::__private::None => {
1395 return _serde::__private::Err(
1396 <__A::Error as _serde::de::Error>::missing_field("isLinked"),
1397 );
1398 }
1399 };
1400 let m_updateActiveNodes = match m_updateActiveNodes {
1401 _serde::__private::Some(__field) => __field,
1402 _serde::__private::None => {
1403 return _serde::__private::Err(
1404 <__A::Error as _serde::de::Error>::missing_field(
1405 "updateActiveNodes",
1406 ),
1407 );
1408 }
1409 };
1410 let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
1411 _serde::__private::Some(__field) => __field,
1412 _serde::__private::None => {
1413 return _serde::__private::Err(
1414 <__A::Error as _serde::de::Error>::missing_field(
1415 "stateOrTransitionChanged",
1416 ),
1417 );
1418 }
1419 };
1420 _serde::__private::Ok(hkbBehaviorGraph {
1421 __ptr,
1422 parent,
1423 m_variableMode,
1424 m_uniqueIdPool,
1425 m_idToStateMachineTemplateMap,
1426 m_mirroredExternalIdMap,
1427 m_pseudoRandomGenerator,
1428 m_rootGenerator,
1429 m_data,
1430 m_rootGeneratorClone,
1431 m_activeNodes,
1432 m_activeNodeTemplateToIndexMap,
1433 m_activeNodesChildrenIndices,
1434 m_globalTransitionData,
1435 m_eventIdMap,
1436 m_attributeIdMap,
1437 m_variableIdMap,
1438 m_characterPropertyIdMap,
1439 m_variableValueSet,
1440 m_nodeTemplateToCloneMap,
1441 m_nodeCloneToTemplateMap,
1442 m_stateListenerTemplateToCloneMap,
1443 m_nodePartitionInfo,
1444 m_numIntermediateOutputs,
1445 m_jobs,
1446 m_allPartitionMemory,
1447 m_numStaticNodes,
1448 m_nextUniqueId,
1449 m_isActive,
1450 m_isLinked,
1451 m_updateActiveNodes,
1452 m_stateOrTransitionChanged,
1453 })
1454 }
1455 #[allow(clippy::manual_unwrap_or_default)]
1456 fn visit_struct<__A>(
1457 self,
1458 mut __map: __A,
1459 ) -> _serde::__private::Result<Self::Value, __A::Error>
1460 where
1461 __A: _serde::de::MapAccess<'de>,
1462 {
1463 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1464 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1465 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1466 let mut m_variableMode: _serde::__private::Option<VariableMode> = _serde::__private::None;
1467 let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
1468 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
1469 while let _serde::__private::Some(__key) = {
1470 __A::next_key::<__Field>(&mut __map)?
1471 } {
1472 match __key {
1473 __Field::m_variableBindingSet => {
1474 #[cfg(
1475 any(feature = "strict", feature = "ignore_duplicates")
1476 )]
1477 if _serde::__private::Option::is_some(
1478 &m_variableBindingSet,
1479 ) {
1480 #[cfg(feature = "ignore_duplicates")]
1481 {
1482 __A::skip_value(&mut __map)?;
1483 continue;
1484 }
1485 #[cfg(feature = "strict")]
1486 return _serde::__private::Err(
1487 <__A::Error as _serde::de::Error>::duplicate_field(
1488 "variableBindingSet",
1489 ),
1490 );
1491 }
1492 m_variableBindingSet = _serde::__private::Some(
1493 match __A::next_value::<Pointer>(&mut __map) {
1494 _serde::__private::Ok(__val) => __val,
1495 _serde::__private::Err(__err) => {
1496 return _serde::__private::Err(__err);
1497 }
1498 },
1499 );
1500 }
1501 __Field::m_userData => {
1502 #[cfg(
1503 any(feature = "strict", feature = "ignore_duplicates")
1504 )]
1505 if _serde::__private::Option::is_some(&m_userData) {
1506 #[cfg(feature = "ignore_duplicates")]
1507 {
1508 __A::skip_value(&mut __map)?;
1509 continue;
1510 }
1511 #[cfg(feature = "strict")]
1512 return _serde::__private::Err(
1513 <__A::Error as _serde::de::Error>::duplicate_field(
1514 "userData",
1515 ),
1516 );
1517 }
1518 m_userData = _serde::__private::Some(
1519 match __A::next_value::<Ulong>(&mut __map) {
1520 _serde::__private::Ok(__val) => __val,
1521 _serde::__private::Err(__err) => {
1522 return _serde::__private::Err(__err);
1523 }
1524 },
1525 );
1526 }
1527 __Field::m_name => {
1528 #[cfg(
1529 any(feature = "strict", feature = "ignore_duplicates")
1530 )]
1531 if _serde::__private::Option::is_some(&m_name) {
1532 #[cfg(feature = "ignore_duplicates")]
1533 {
1534 __A::skip_value(&mut __map)?;
1535 continue;
1536 }
1537 #[cfg(feature = "strict")]
1538 return _serde::__private::Err(
1539 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1540 );
1541 }
1542 m_name = _serde::__private::Some(
1543 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1544 _serde::__private::Ok(__val) => __val,
1545 _serde::__private::Err(__err) => {
1546 return _serde::__private::Err(__err);
1547 }
1548 },
1549 );
1550 }
1551 __Field::m_variableMode => {
1552 #[cfg(
1553 any(feature = "strict", feature = "ignore_duplicates")
1554 )]
1555 if _serde::__private::Option::is_some(&m_variableMode) {
1556 #[cfg(feature = "ignore_duplicates")]
1557 {
1558 __A::skip_value(&mut __map)?;
1559 continue;
1560 }
1561 #[cfg(feature = "strict")]
1562 return _serde::__private::Err(
1563 <__A::Error as _serde::de::Error>::duplicate_field(
1564 "variableMode",
1565 ),
1566 );
1567 }
1568 m_variableMode = _serde::__private::Some(
1569 match __A::next_value::<VariableMode>(&mut __map) {
1570 _serde::__private::Ok(__val) => __val,
1571 _serde::__private::Err(__err) => {
1572 return _serde::__private::Err(__err);
1573 }
1574 },
1575 );
1576 }
1577 __Field::m_rootGenerator => {
1578 #[cfg(
1579 any(feature = "strict", feature = "ignore_duplicates")
1580 )]
1581 if _serde::__private::Option::is_some(&m_rootGenerator) {
1582 #[cfg(feature = "ignore_duplicates")]
1583 {
1584 __A::skip_value(&mut __map)?;
1585 continue;
1586 }
1587 #[cfg(feature = "strict")]
1588 return _serde::__private::Err(
1589 <__A::Error as _serde::de::Error>::duplicate_field(
1590 "rootGenerator",
1591 ),
1592 );
1593 }
1594 m_rootGenerator = _serde::__private::Some(
1595 match __A::next_value::<Pointer>(&mut __map) {
1596 _serde::__private::Ok(__val) => __val,
1597 _serde::__private::Err(__err) => {
1598 return _serde::__private::Err(__err);
1599 }
1600 },
1601 );
1602 }
1603 __Field::m_data => {
1604 #[cfg(
1605 any(feature = "strict", feature = "ignore_duplicates")
1606 )]
1607 if _serde::__private::Option::is_some(&m_data) {
1608 #[cfg(feature = "ignore_duplicates")]
1609 {
1610 __A::skip_value(&mut __map)?;
1611 continue;
1612 }
1613 #[cfg(feature = "strict")]
1614 return _serde::__private::Err(
1615 <__A::Error as _serde::de::Error>::duplicate_field("data"),
1616 );
1617 }
1618 m_data = _serde::__private::Some(
1619 match __A::next_value::<Pointer>(&mut __map) {
1620 _serde::__private::Ok(__val) => __val,
1621 _serde::__private::Err(__err) => {
1622 return _serde::__private::Err(__err);
1623 }
1624 },
1625 );
1626 }
1627 _ => __A::skip_value(&mut __map)?,
1628 }
1629 }
1630 let m_variableBindingSet = match m_variableBindingSet {
1631 _serde::__private::Some(__field) => __field,
1632 _serde::__private::None => {
1633 #[cfg(feature = "strict")]
1634 return _serde::__private::Err(
1635 <__A::Error as _serde::de::Error>::missing_field(
1636 "variableBindingSet",
1637 ),
1638 );
1639 #[cfg(not(feature = "strict"))] Default::default()
1640 }
1641 };
1642 let m_userData = match m_userData {
1643 _serde::__private::Some(__field) => __field,
1644 _serde::__private::None => {
1645 #[cfg(feature = "strict")]
1646 return _serde::__private::Err(
1647 <__A::Error as _serde::de::Error>::missing_field("userData"),
1648 );
1649 #[cfg(not(feature = "strict"))] Default::default()
1650 }
1651 };
1652 let m_name = match m_name {
1653 _serde::__private::Some(__field) => __field,
1654 _serde::__private::None => {
1655 #[cfg(feature = "strict")]
1656 return _serde::__private::Err(
1657 <__A::Error as _serde::de::Error>::missing_field("name"),
1658 );
1659 #[cfg(not(feature = "strict"))] Default::default()
1660 }
1661 };
1662 let m_variableMode = match m_variableMode {
1663 _serde::__private::Some(__field) => __field,
1664 _serde::__private::None => {
1665 #[cfg(feature = "strict")]
1666 return _serde::__private::Err(
1667 <__A::Error as _serde::de::Error>::missing_field(
1668 "variableMode",
1669 ),
1670 );
1671 #[cfg(not(feature = "strict"))] Default::default()
1672 }
1673 };
1674 let m_rootGenerator = match m_rootGenerator {
1675 _serde::__private::Some(__field) => __field,
1676 _serde::__private::None => {
1677 #[cfg(feature = "strict")]
1678 return _serde::__private::Err(
1679 <__A::Error as _serde::de::Error>::missing_field(
1680 "rootGenerator",
1681 ),
1682 );
1683 #[cfg(not(feature = "strict"))] Default::default()
1684 }
1685 };
1686 let m_data = match m_data {
1687 _serde::__private::Some(__field) => __field,
1688 _serde::__private::None => {
1689 #[cfg(feature = "strict")]
1690 return _serde::__private::Err(
1691 <__A::Error as _serde::de::Error>::missing_field("data"),
1692 );
1693 #[cfg(not(feature = "strict"))] Default::default()
1694 }
1695 };
1696 let __ptr = None;
1697 let parent = hkBaseObject { __ptr };
1698 let parent = hkReferencedObject {
1699 __ptr,
1700 parent,
1701 ..Default::default()
1702 };
1703 let parent = hkbBindable {
1704 __ptr,
1705 parent,
1706 m_variableBindingSet,
1707 ..Default::default()
1708 };
1709 let parent = hkbNode {
1710 __ptr,
1711 parent,
1712 m_userData,
1713 m_name,
1714 ..Default::default()
1715 };
1716 let parent = hkbGenerator { __ptr, parent };
1717 let __ptr = __A::class_ptr(&mut __map);
1718 _serde::__private::Ok(hkbBehaviorGraph {
1719 __ptr,
1720 parent,
1721 m_variableMode,
1722 m_rootGenerator,
1723 m_data,
1724 ..Default::default()
1725 })
1726 }
1727 }
1728 const FIELDS: &[&str] = &[
1729 "variableMode",
1730 "uniqueIdPool",
1731 "idToStateMachineTemplateMap",
1732 "mirroredExternalIdMap",
1733 "pseudoRandomGenerator",
1734 "rootGenerator",
1735 "data",
1736 "rootGeneratorClone",
1737 "activeNodes",
1738 "activeNodeTemplateToIndexMap",
1739 "activeNodesChildrenIndices",
1740 "globalTransitionData",
1741 "eventIdMap",
1742 "attributeIdMap",
1743 "variableIdMap",
1744 "characterPropertyIdMap",
1745 "variableValueSet",
1746 "nodeTemplateToCloneMap",
1747 "nodeCloneToTemplateMap",
1748 "stateListenerTemplateToCloneMap",
1749 "nodePartitionInfo",
1750 "numIntermediateOutputs",
1751 "jobs",
1752 "allPartitionMemory",
1753 "numStaticNodes",
1754 "nextUniqueId",
1755 "isActive",
1756 "isLinked",
1757 "updateActiveNodes",
1758 "stateOrTransitionChanged",
1759 ];
1760 _serde::Deserializer::deserialize_struct(
1761 deserializer,
1762 "hkbBehaviorGraph",
1763 FIELDS,
1764 __hkbBehaviorGraphVisitor {
1765 marker: _serde::__private::PhantomData::<hkbBehaviorGraph>,
1766 lifetime: _serde::__private::PhantomData,
1767 },
1768 )
1769 }
1770 }
1771};
1772#[allow(non_upper_case_globals, non_snake_case)]
1775#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1776#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1777#[derive(
1778 Debug,
1779 Clone,
1780 Default,
1781 PartialEq,
1782 Eq,
1783 PartialOrd,
1784 Ord,
1785 num_derive::ToPrimitive,
1786 num_derive::FromPrimitive,
1787)]
1788pub enum VariableMode {
1789 #[default]
1790 VARIABLE_MODE_DISCARD_WHEN_INACTIVE = 0isize,
1791 VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE = 1isize,
1792}
1793const _: () = {
1794 use havok_serde as __serde;
1795 impl __serde::Serialize for VariableMode {
1796 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1797 where
1798 S: __serde::ser::Serializer,
1799 {
1800 let mut __serializer = __serializer.serialize_enum_flags()?;
1801 match self {
1802 Self::VARIABLE_MODE_DISCARD_WHEN_INACTIVE => {
1803 __serializer
1804 .serialize_field("VARIABLE_MODE_DISCARD_WHEN_INACTIVE", &0u64)
1805 }
1806 Self::VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE => {
1807 __serializer
1808 .serialize_field(
1809 "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1810 &1u64,
1811 )
1812 }
1813 }?;
1814 use num_traits::ToPrimitive as _;
1815 let num = self
1816 .to_i8()
1817 .ok_or(S::Error::custom("Failed enum VariableMode to_i8"))?;
1818 __serializer.serialize_bits(&num)?;
1819 __serializer.end()
1820 }
1821 }
1822};
1823#[doc(hidden)]
1824#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1825const _: () = {
1826 #[allow(unused_extern_crates, clippy::useless_attribute)]
1827 extern crate havok_serde as _serde;
1828 #[automatically_derived]
1829 impl<'de> _serde::Deserialize<'de> for VariableMode {
1830 fn deserialize<__D>(
1831 __deserializer: __D,
1832 ) -> _serde::__private::Result<Self, __D::Error>
1833 where
1834 __D: _serde::Deserializer<'de>,
1835 {
1836 #[allow(non_camel_case_types)]
1837 #[doc(hidden)]
1838 enum __Field {
1839 __field0,
1840 __field1,
1841 }
1842 #[doc(hidden)]
1843 struct __FieldVisitor;
1844 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1845 type Value = __Field;
1846 fn expecting(
1847 &self,
1848 __formatter: &mut _serde::__private::Formatter,
1849 ) -> _serde::__private::fmt::Result {
1850 _serde::__private::Formatter::write_str(
1851 __formatter,
1852 "variant identifier",
1853 )
1854 }
1855 fn visit_int8<__E>(
1856 self,
1857 __value: i8,
1858 ) -> _serde::__private::Result<Self::Value, __E>
1859 where
1860 __E: _serde::de::Error,
1861 {
1862 match __value {
1863 0i8 => _serde::__private::Ok(__Field::__field0),
1864 1i8 => _serde::__private::Ok(__Field::__field1),
1865 _ => {
1866 _serde::__private::Err(
1867 _serde::de::Error::invalid_value(
1868 _serde::de::Unexpected::Int8(__value),
1869 &"value(i8) of variant is one of 0, 1",
1870 ),
1871 )
1872 }
1873 }
1874 }
1875 fn visit_stringptr<__E>(
1876 self,
1877 __value: StringPtr<'de>,
1878 ) -> _serde::__private::Result<Self::Value, __E>
1879 where
1880 __E: _serde::de::Error,
1881 {
1882 if let Some(__value) = __value.into_inner() {
1883 match __value.as_ref() {
1884 v if v == "0"
1885 || v
1886 .eq_ignore_ascii_case(
1887 "VARIABLE_MODE_DISCARD_WHEN_INACTIVE",
1888 ) => _serde::__private::Ok(__Field::__field0),
1889 v if v == "1"
1890 || v
1891 .eq_ignore_ascii_case(
1892 "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1893 ) => _serde::__private::Ok(__Field::__field1),
1894 _ => {
1895 _serde::__private::Err(
1896 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1897 )
1898 }
1899 }
1900 } else {
1901 _serde::__private::Err(
1902 _serde::de::Error::unknown_variant("None", VARIANTS),
1903 )
1904 }
1905 }
1906 }
1907 impl<'de> _serde::Deserialize<'de> for __Field {
1908 #[inline]
1909 fn deserialize<__D>(
1910 __deserializer: __D,
1911 ) -> _serde::__private::Result<Self, __D::Error>
1912 where
1913 __D: _serde::Deserializer<'de>,
1914 {
1915 _serde::Deserializer::deserialize_identifier(
1916 __deserializer,
1917 _serde::de::ReadEnumSize::Int8,
1918 __FieldVisitor,
1919 )
1920 }
1921 }
1922 #[doc(hidden)]
1923 struct __Visitor<'de> {
1924 marker: _serde::__private::PhantomData<VariableMode>,
1925 lifetime: _serde::__private::PhantomData<&'de ()>,
1926 }
1927 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1928 type Value = VariableMode;
1929 fn expecting(
1930 &self,
1931 __formatter: &mut _serde::__private::Formatter,
1932 ) -> _serde::__private::fmt::Result {
1933 _serde::__private::Formatter::write_str(
1934 __formatter,
1935 "enum VariableMode",
1936 )
1937 }
1938 fn visit_enum<__A>(
1939 self,
1940 __data: __A,
1941 ) -> _serde::__private::Result<Self::Value, __A::Error>
1942 where
1943 __A: _serde::de::EnumAccess<'de>,
1944 {
1945 match _serde::de::EnumAccess::variant(__data)? {
1946 (__Field::__field0, __variant) => {
1947 _serde::de::VariantAccess::unit_variant(__variant)?;
1948 _serde::__private::Ok(
1949 VariableMode::VARIABLE_MODE_DISCARD_WHEN_INACTIVE,
1950 )
1951 }
1952 (__Field::__field1, __variant) => {
1953 _serde::de::VariantAccess::unit_variant(__variant)?;
1954 _serde::__private::Ok(
1955 VariableMode::VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE,
1956 )
1957 }
1958 }
1959 }
1960 }
1961 #[doc(hidden)]
1962 const VARIANTS: &'static [&'static str] = &[
1963 "VARIABLE_MODE_DISCARD_WHEN_INACTIVE",
1964 "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1965 ];
1966 _serde::Deserializer::deserialize_enum(
1967 __deserializer,
1968 "VariableMode",
1969 VARIANTS,
1970 __Visitor {
1971 marker: _serde::__private::PhantomData::<VariableMode>,
1972 lifetime: _serde::__private::PhantomData,
1973 },
1974 )
1975 }
1976 }
1977};