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