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