havok_classes/generated/
hkbProjectStringData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbProjectStringData`
5/// - version: `1`
6/// - signature: `0x76ad60a`
7/// - size: ` 76`(x86)/`120`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `animationFilenames`(ctype: `hkArray<hkStringPtr>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[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    /// # C++ Info
39    /// - name: `behaviorFilenames`(ctype: `hkArray<hkStringPtr>`)
40    /// - offset: ` 20`(x86)/` 32`(x86_64)
41    /// - type_size: ` 12`(x86)/` 16`(x86_64)
42    #[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    /// # C++ Info
47    /// - name: `characterFilenames`(ctype: `hkArray<hkStringPtr>`)
48    /// - offset: ` 32`(x86)/` 48`(x86_64)
49    /// - type_size: ` 12`(x86)/` 16`(x86_64)
50    #[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    /// # C++ Info
55    /// - name: `eventNames`(ctype: `hkArray<hkStringPtr>`)
56    /// - offset: ` 44`(x86)/` 64`(x86_64)
57    /// - type_size: ` 12`(x86)/` 16`(x86_64)
58    #[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    /// # C++ Info
63    /// - name: `animationPath`(ctype: `hkStringPtr`)
64    /// - offset: ` 56`(x86)/` 80`(x86_64)
65    /// - type_size: `  4`(x86)/`  8`(x86_64)
66    #[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    /// # C++ Info
71    /// - name: `behaviorPath`(ctype: `hkStringPtr`)
72    /// - offset: ` 60`(x86)/` 88`(x86_64)
73    /// - type_size: `  4`(x86)/`  8`(x86_64)
74    #[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    /// # C++ Info
79    /// - name: `characterPath`(ctype: `hkStringPtr`)
80    /// - offset: ` 64`(x86)/` 96`(x86_64)
81    /// - type_size: `  4`(x86)/`  8`(x86_64)
82    #[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    /// # C++ Info
87    /// - name: `fullPathToSource`(ctype: `hkStringPtr`)
88    /// - offset: ` 68`(x86)/`104`(x86_64)
89    /// - type_size: `  4`(x86)/`  8`(x86_64)
90    #[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    /// # C++ Info
95    /// - name: `rootPath`(ctype: `hkStringPtr`)
96    /// - offset: ` 72`(x86)/`112`(x86_64)
97    /// - type_size: `  4`(x86)/`  8`(x86_64)
98    /// - flags: `SERIALIZE_IGNORED`
99    #[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                /// Intended for use in XML.
200                #[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};