havok_classes/generated/
hkbGeneratorSyncInfo_.rs

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