havok_classes/generated/
hkpCollisionFilter_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpCollisionFilter`
5/// - version: `0`
6/// - signature: `0x60960336`
7/// - size: ` 48`(x86)/` 72`(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 hkpCollisionFilter {
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: `prepad`(ctype: `hkUint32[2]`)
32    /// - offset: ` 24`(x86)/` 48`(x86_64)
33    /// - type_size: `  8`(x86)/`  8`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "prepad"))]
35    #[cfg_attr(feature = "serde", serde(rename = "prepad"))]
36    pub m_prepad: [u32; 2usize],
37    /// # C++ Info
38    /// - name: `type`(ctype: `enum hkpFilterType`)
39    /// - offset: ` 32`(x86)/` 56`(x86_64)
40    /// - type_size: `  4`(x86)/`  4`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
42    #[cfg_attr(feature = "serde", serde(rename = "type"))]
43    pub m_type: hkpFilterType,
44    /// # C++ Info
45    /// - name: `postpad`(ctype: `hkUint32[3]`)
46    /// - offset: ` 36`(x86)/` 60`(x86_64)
47    /// - type_size: ` 12`(x86)/` 12`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "postpad"))]
49    #[cfg_attr(feature = "serde", serde(rename = "postpad"))]
50    pub m_postpad: [u32; 3usize],
51}
52const _: () = {
53    use havok_serde as _serde;
54    impl _serde::HavokClass for hkpCollisionFilter {
55        #[inline]
56        fn name(&self) -> &'static str {
57            "hkpCollisionFilter"
58        }
59        #[inline]
60        fn signature(&self) -> _serde::__private::Signature {
61            _serde::__private::Signature::new(0x60960336)
62        }
63        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
64        fn deps_indexes(&self) -> Vec<usize> {
65            let mut v = Vec::new();
66            v
67        }
68    }
69    impl _serde::Serialize for hkpCollisionFilter {
70        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
71        where
72            S: _serde::ser::Serializer,
73        {
74            let class_meta = self
75                .__ptr
76                .map(|name| (name, _serde::__private::Signature::new(0x60960336)));
77            let mut serializer = __serializer
78                .serialize_struct("hkpCollisionFilter", class_meta, (48u64, 72u64))?;
79            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
80            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
81            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
82            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
83            serializer.pad_field([0u8; 16usize].as_slice(), [0u8; 32usize].as_slice())?;
84            serializer
85                .serialize_fixed_array_field(
86                    "prepad",
87                    self.m_prepad.as_slice(),
88                    TypeSize::NonPtr,
89                )?;
90            serializer.serialize_field("type", &self.m_type)?;
91            serializer
92                .serialize_fixed_array_field(
93                    "postpad",
94                    self.m_postpad.as_slice(),
95                    TypeSize::NonPtr,
96                )?;
97            serializer.end()
98        }
99    }
100};
101#[doc(hidden)]
102#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
103const _: () = {
104    use havok_serde as _serde;
105    #[automatically_derived]
106    impl<'de> _serde::Deserialize<'de> for hkpCollisionFilter {
107        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
108        where
109            __D: _serde::Deserializer<'de>,
110        {
111            #[allow(non_camel_case_types)]
112            enum __Field {
113                m_prepad,
114                m_type,
115                m_postpad,
116                __ignore,
117            }
118            struct __FieldVisitor;
119            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
120                type Value = __Field;
121                fn expecting(
122                    &self,
123                    __formatter: &mut core::fmt::Formatter,
124                ) -> core::fmt::Result {
125                    core::fmt::Formatter::write_str(__formatter, "field identifier")
126                }
127                /// Intended for use in XML.
128                #[allow(clippy::match_single_binding)]
129                #[allow(clippy::reversed_empty_ranges)]
130                #[allow(clippy::single_match)]
131                fn visit_key<__E>(
132                    self,
133                    __value: &str,
134                ) -> core::result::Result<Self::Value, __E>
135                where
136                    __E: _serde::de::Error,
137                {
138                    match __value {
139                        "prepad" => Ok(__Field::m_prepad),
140                        "type" => Ok(__Field::m_type),
141                        "postpad" => Ok(__Field::m_postpad),
142                        _ => Ok(__Field::__ignore),
143                    }
144                }
145            }
146            impl<'de> _serde::Deserialize<'de> for __Field {
147                #[inline]
148                fn deserialize<__D>(
149                    __deserializer: __D,
150                ) -> core::result::Result<Self, __D::Error>
151                where
152                    __D: _serde::Deserializer<'de>,
153                {
154                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
155                }
156            }
157            struct __hkpCollisionFilterVisitor<'de> {
158                marker: _serde::__private::PhantomData<hkpCollisionFilter>,
159                lifetime: _serde::__private::PhantomData<&'de ()>,
160            }
161            #[allow(clippy::match_single_binding)]
162            #[allow(clippy::reversed_empty_ranges)]
163            #[allow(clippy::single_match)]
164            impl<'de> _serde::de::Visitor<'de> for __hkpCollisionFilterVisitor<'de> {
165                type Value = hkpCollisionFilter;
166                fn expecting(
167                    &self,
168                    __formatter: &mut core::fmt::Formatter,
169                ) -> core::fmt::Result {
170                    core::fmt::Formatter::write_str(
171                        __formatter,
172                        "struct hkpCollisionFilter",
173                    )
174                }
175                fn visit_struct_for_bytes<__A>(
176                    self,
177                    mut __map: __A,
178                ) -> _serde::__private::Result<Self::Value, __A::Error>
179                where
180                    __A: _serde::de::MapAccess<'de>,
181                {
182                    let __ptr = __A::class_ptr(&mut __map);
183                    let parent = __A::parent_value(&mut __map)?;
184                    let mut m_prepad: _serde::__private::Option<[u32; 2usize]> = _serde::__private::None;
185                    let mut m_type: _serde::__private::Option<hkpFilterType> = _serde::__private::None;
186                    let mut m_postpad: _serde::__private::Option<[u32; 3usize]> = _serde::__private::None;
187                    for i in 0..3usize {
188                        match i {
189                            0usize => {
190                                if _serde::__private::Option::is_some(&m_prepad) {
191                                    return _serde::__private::Err(
192                                        <__A::Error as _serde::de::Error>::duplicate_field("prepad"),
193                                    );
194                                }
195                                __A::pad(&mut __map, 16usize, 32usize)?;
196                                m_prepad = _serde::__private::Some(
197                                    match __A::next_value::<[u32; 2usize]>(&mut __map) {
198                                        _serde::__private::Ok(__val) => __val,
199                                        _serde::__private::Err(__err) => {
200                                            return _serde::__private::Err(__err);
201                                        }
202                                    },
203                                );
204                            }
205                            1usize => {
206                                if _serde::__private::Option::is_some(&m_type) {
207                                    return _serde::__private::Err(
208                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
209                                    );
210                                }
211                                m_type = _serde::__private::Some(
212                                    match __A::next_value::<hkpFilterType>(&mut __map) {
213                                        _serde::__private::Ok(__val) => __val,
214                                        _serde::__private::Err(__err) => {
215                                            return _serde::__private::Err(__err);
216                                        }
217                                    },
218                                );
219                            }
220                            2usize => {
221                                if _serde::__private::Option::is_some(&m_postpad) {
222                                    return _serde::__private::Err(
223                                        <__A::Error as _serde::de::Error>::duplicate_field(
224                                            "postpad",
225                                        ),
226                                    );
227                                }
228                                m_postpad = _serde::__private::Some(
229                                    match __A::next_value::<[u32; 3usize]>(&mut __map) {
230                                        _serde::__private::Ok(__val) => __val,
231                                        _serde::__private::Err(__err) => {
232                                            return _serde::__private::Err(__err);
233                                        }
234                                    },
235                                );
236                            }
237                            _ => {}
238                        }
239                    }
240                    let m_prepad = match m_prepad {
241                        _serde::__private::Some(__field) => __field,
242                        _serde::__private::None => {
243                            return _serde::__private::Err(
244                                <__A::Error as _serde::de::Error>::missing_field("prepad"),
245                            );
246                        }
247                    };
248                    let m_type = match m_type {
249                        _serde::__private::Some(__field) => __field,
250                        _serde::__private::None => {
251                            return _serde::__private::Err(
252                                <__A::Error as _serde::de::Error>::missing_field("type"),
253                            );
254                        }
255                    };
256                    let m_postpad = match m_postpad {
257                        _serde::__private::Some(__field) => __field,
258                        _serde::__private::None => {
259                            return _serde::__private::Err(
260                                <__A::Error as _serde::de::Error>::missing_field("postpad"),
261                            );
262                        }
263                    };
264                    _serde::__private::Ok(hkpCollisionFilter {
265                        __ptr,
266                        parent,
267                        m_prepad,
268                        m_type,
269                        m_postpad,
270                    })
271                }
272                #[allow(clippy::manual_unwrap_or_default)]
273                fn visit_struct<__A>(
274                    self,
275                    mut __map: __A,
276                ) -> _serde::__private::Result<Self::Value, __A::Error>
277                where
278                    __A: _serde::de::MapAccess<'de>,
279                {
280                    let mut m_prepad: _serde::__private::Option<[u32; 2usize]> = _serde::__private::None;
281                    let mut m_type: _serde::__private::Option<hkpFilterType> = _serde::__private::None;
282                    let mut m_postpad: _serde::__private::Option<[u32; 3usize]> = _serde::__private::None;
283                    while let _serde::__private::Some(__key) = {
284                        __A::next_key::<__Field>(&mut __map)?
285                    } {
286                        match __key {
287                            __Field::m_prepad => {
288                                #[cfg(
289                                    any(feature = "strict", feature = "ignore_duplicates")
290                                )]
291                                if _serde::__private::Option::is_some(&m_prepad) {
292                                    #[cfg(feature = "ignore_duplicates")]
293                                    {
294                                        __A::skip_value(&mut __map)?;
295                                        continue;
296                                    }
297                                    #[cfg(feature = "strict")]
298                                    return _serde::__private::Err(
299                                        <__A::Error as _serde::de::Error>::duplicate_field("prepad"),
300                                    );
301                                }
302                                m_prepad = _serde::__private::Some(
303                                    match __A::next_value::<[u32; 2usize]>(&mut __map) {
304                                        _serde::__private::Ok(__val) => __val,
305                                        _serde::__private::Err(__err) => {
306                                            return _serde::__private::Err(__err);
307                                        }
308                                    },
309                                );
310                            }
311                            __Field::m_type => {
312                                #[cfg(
313                                    any(feature = "strict", feature = "ignore_duplicates")
314                                )]
315                                if _serde::__private::Option::is_some(&m_type) {
316                                    #[cfg(feature = "ignore_duplicates")]
317                                    {
318                                        __A::skip_value(&mut __map)?;
319                                        continue;
320                                    }
321                                    #[cfg(feature = "strict")]
322                                    return _serde::__private::Err(
323                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
324                                    );
325                                }
326                                m_type = _serde::__private::Some(
327                                    match __A::next_value::<hkpFilterType>(&mut __map) {
328                                        _serde::__private::Ok(__val) => __val,
329                                        _serde::__private::Err(__err) => {
330                                            return _serde::__private::Err(__err);
331                                        }
332                                    },
333                                );
334                            }
335                            __Field::m_postpad => {
336                                #[cfg(
337                                    any(feature = "strict", feature = "ignore_duplicates")
338                                )]
339                                if _serde::__private::Option::is_some(&m_postpad) {
340                                    #[cfg(feature = "ignore_duplicates")]
341                                    {
342                                        __A::skip_value(&mut __map)?;
343                                        continue;
344                                    }
345                                    #[cfg(feature = "strict")]
346                                    return _serde::__private::Err(
347                                        <__A::Error as _serde::de::Error>::duplicate_field(
348                                            "postpad",
349                                        ),
350                                    );
351                                }
352                                m_postpad = _serde::__private::Some(
353                                    match __A::next_value::<[u32; 3usize]>(&mut __map) {
354                                        _serde::__private::Ok(__val) => __val,
355                                        _serde::__private::Err(__err) => {
356                                            return _serde::__private::Err(__err);
357                                        }
358                                    },
359                                );
360                            }
361                            _ => __A::skip_value(&mut __map)?,
362                        }
363                    }
364                    let m_prepad = match m_prepad {
365                        _serde::__private::Some(__field) => __field,
366                        _serde::__private::None => {
367                            #[cfg(feature = "strict")]
368                            return _serde::__private::Err(
369                                <__A::Error as _serde::de::Error>::missing_field("prepad"),
370                            );
371                            #[cfg(not(feature = "strict"))] Default::default()
372                        }
373                    };
374                    let m_type = match m_type {
375                        _serde::__private::Some(__field) => __field,
376                        _serde::__private::None => {
377                            #[cfg(feature = "strict")]
378                            return _serde::__private::Err(
379                                <__A::Error as _serde::de::Error>::missing_field("type"),
380                            );
381                            #[cfg(not(feature = "strict"))] Default::default()
382                        }
383                    };
384                    let m_postpad = match m_postpad {
385                        _serde::__private::Some(__field) => __field,
386                        _serde::__private::None => {
387                            #[cfg(feature = "strict")]
388                            return _serde::__private::Err(
389                                <__A::Error as _serde::de::Error>::missing_field("postpad"),
390                            );
391                            #[cfg(not(feature = "strict"))] Default::default()
392                        }
393                    };
394                    let __ptr = None;
395                    let parent = hkBaseObject { __ptr };
396                    let parent = hkReferencedObject {
397                        __ptr,
398                        parent,
399                        ..Default::default()
400                    };
401                    let __ptr = __A::class_ptr(&mut __map);
402                    _serde::__private::Ok(hkpCollisionFilter {
403                        __ptr,
404                        parent,
405                        m_prepad,
406                        m_type,
407                        m_postpad,
408                    })
409                }
410            }
411            const FIELDS: &[&str] = &["prepad", "type", "postpad"];
412            _serde::Deserializer::deserialize_struct(
413                deserializer,
414                "hkpCollisionFilter",
415                FIELDS,
416                __hkpCollisionFilterVisitor {
417                    marker: _serde::__private::PhantomData::<hkpCollisionFilter>,
418                    lifetime: _serde::__private::PhantomData,
419                },
420            )
421        }
422    }
423};
424/// # C++ Info
425/// - name: `hkpFilterType`(ctype: `hkEnum<hkpFilterType, hkUint32>`)
426#[allow(non_upper_case_globals, non_snake_case)]
427#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
428#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
429#[derive(
430    Debug,
431    Clone,
432    Default,
433    PartialEq,
434    Eq,
435    PartialOrd,
436    Ord,
437    num_derive::ToPrimitive,
438    num_derive::FromPrimitive,
439)]
440pub enum hkpFilterType {
441    #[default]
442    HK_FILTER_UNKNOWN = 0isize,
443    HK_FILTER_NULL = 1isize,
444    HK_FILTER_GROUP = 2isize,
445    HK_FILTER_LIST = 3isize,
446    HK_FILTER_CUSTOM = 4isize,
447    HK_FILTER_PAIR = 5isize,
448    HK_FILTER_CONSTRAINT = 6isize,
449}
450const _: () = {
451    use havok_serde as __serde;
452    impl __serde::Serialize for hkpFilterType {
453        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
454        where
455            S: __serde::ser::Serializer,
456        {
457            let mut __serializer = __serializer.serialize_enum_flags()?;
458            match self {
459                Self::HK_FILTER_UNKNOWN => {
460                    __serializer.serialize_field("HK_FILTER_UNKNOWN", &0u64)
461                }
462                Self::HK_FILTER_NULL => {
463                    __serializer.serialize_field("HK_FILTER_NULL", &1u64)
464                }
465                Self::HK_FILTER_GROUP => {
466                    __serializer.serialize_field("HK_FILTER_GROUP", &2u64)
467                }
468                Self::HK_FILTER_LIST => {
469                    __serializer.serialize_field("HK_FILTER_LIST", &3u64)
470                }
471                Self::HK_FILTER_CUSTOM => {
472                    __serializer.serialize_field("HK_FILTER_CUSTOM", &4u64)
473                }
474                Self::HK_FILTER_PAIR => {
475                    __serializer.serialize_field("HK_FILTER_PAIR", &5u64)
476                }
477                Self::HK_FILTER_CONSTRAINT => {
478                    __serializer.serialize_field("HK_FILTER_CONSTRAINT", &6u64)
479                }
480            }?;
481            use num_traits::ToPrimitive as _;
482            let num = self
483                .to_u32()
484                .ok_or(S::Error::custom("Failed enum hkpFilterType to_u32"))?;
485            __serializer.serialize_bits(&num)?;
486            __serializer.end()
487        }
488    }
489};
490#[doc(hidden)]
491#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
492const _: () = {
493    #[allow(unused_extern_crates, clippy::useless_attribute)]
494    extern crate havok_serde as _serde;
495    #[automatically_derived]
496    impl<'de> _serde::Deserialize<'de> for hkpFilterType {
497        fn deserialize<__D>(
498            __deserializer: __D,
499        ) -> _serde::__private::Result<Self, __D::Error>
500        where
501            __D: _serde::Deserializer<'de>,
502        {
503            #[allow(non_camel_case_types)]
504            #[doc(hidden)]
505            enum __Field {
506                __field0,
507                __field1,
508                __field2,
509                __field3,
510                __field4,
511                __field5,
512                __field6,
513            }
514            #[doc(hidden)]
515            struct __FieldVisitor;
516            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
517                type Value = __Field;
518                fn expecting(
519                    &self,
520                    __formatter: &mut _serde::__private::Formatter,
521                ) -> _serde::__private::fmt::Result {
522                    _serde::__private::Formatter::write_str(
523                        __formatter,
524                        "variant identifier",
525                    )
526                }
527                fn visit_uint32<__E>(
528                    self,
529                    __value: u32,
530                ) -> _serde::__private::Result<Self::Value, __E>
531                where
532                    __E: _serde::de::Error,
533                {
534                    match __value {
535                        0u32 => _serde::__private::Ok(__Field::__field0),
536                        1u32 => _serde::__private::Ok(__Field::__field1),
537                        2u32 => _serde::__private::Ok(__Field::__field2),
538                        3u32 => _serde::__private::Ok(__Field::__field3),
539                        4u32 => _serde::__private::Ok(__Field::__field4),
540                        5u32 => _serde::__private::Ok(__Field::__field5),
541                        6u32 => _serde::__private::Ok(__Field::__field6),
542                        _ => {
543                            _serde::__private::Err(
544                                _serde::de::Error::invalid_value(
545                                    _serde::de::Unexpected::Uint32(__value),
546                                    &"value(u32) of variant is one of 0, 1, 2, 3, 4, 5, 6",
547                                ),
548                            )
549                        }
550                    }
551                }
552                fn visit_stringptr<__E>(
553                    self,
554                    __value: StringPtr<'de>,
555                ) -> _serde::__private::Result<Self::Value, __E>
556                where
557                    __E: _serde::de::Error,
558                {
559                    if let Some(__value) = __value.into_inner() {
560                        match __value.as_ref() {
561                            v if v == "0"
562                                || v.eq_ignore_ascii_case("HK_FILTER_UNKNOWN") => {
563                                _serde::__private::Ok(__Field::__field0)
564                            }
565                            v if v == "1" || v.eq_ignore_ascii_case("HK_FILTER_NULL") => {
566                                _serde::__private::Ok(__Field::__field1)
567                            }
568                            v if v == "2"
569                                || v.eq_ignore_ascii_case("HK_FILTER_GROUP") => {
570                                _serde::__private::Ok(__Field::__field2)
571                            }
572                            v if v == "3" || v.eq_ignore_ascii_case("HK_FILTER_LIST") => {
573                                _serde::__private::Ok(__Field::__field3)
574                            }
575                            v if v == "4"
576                                || v.eq_ignore_ascii_case("HK_FILTER_CUSTOM") => {
577                                _serde::__private::Ok(__Field::__field4)
578                            }
579                            v if v == "5" || v.eq_ignore_ascii_case("HK_FILTER_PAIR") => {
580                                _serde::__private::Ok(__Field::__field5)
581                            }
582                            v if v == "6"
583                                || v.eq_ignore_ascii_case("HK_FILTER_CONSTRAINT") => {
584                                _serde::__private::Ok(__Field::__field6)
585                            }
586                            _ => {
587                                _serde::__private::Err(
588                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
589                                )
590                            }
591                        }
592                    } else {
593                        _serde::__private::Err(
594                            _serde::de::Error::unknown_variant("None", VARIANTS),
595                        )
596                    }
597                }
598            }
599            impl<'de> _serde::Deserialize<'de> for __Field {
600                #[inline]
601                fn deserialize<__D>(
602                    __deserializer: __D,
603                ) -> _serde::__private::Result<Self, __D::Error>
604                where
605                    __D: _serde::Deserializer<'de>,
606                {
607                    _serde::Deserializer::deserialize_identifier(
608                        __deserializer,
609                        _serde::de::ReadEnumSize::Uint32,
610                        __FieldVisitor,
611                    )
612                }
613            }
614            #[doc(hidden)]
615            struct __Visitor<'de> {
616                marker: _serde::__private::PhantomData<hkpFilterType>,
617                lifetime: _serde::__private::PhantomData<&'de ()>,
618            }
619            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
620                type Value = hkpFilterType;
621                fn expecting(
622                    &self,
623                    __formatter: &mut _serde::__private::Formatter,
624                ) -> _serde::__private::fmt::Result {
625                    _serde::__private::Formatter::write_str(
626                        __formatter,
627                        "enum hkpFilterType",
628                    )
629                }
630                fn visit_enum<__A>(
631                    self,
632                    __data: __A,
633                ) -> _serde::__private::Result<Self::Value, __A::Error>
634                where
635                    __A: _serde::de::EnumAccess<'de>,
636                {
637                    match _serde::de::EnumAccess::variant(__data)? {
638                        (__Field::__field0, __variant) => {
639                            _serde::de::VariantAccess::unit_variant(__variant)?;
640                            _serde::__private::Ok(hkpFilterType::HK_FILTER_UNKNOWN)
641                        }
642                        (__Field::__field1, __variant) => {
643                            _serde::de::VariantAccess::unit_variant(__variant)?;
644                            _serde::__private::Ok(hkpFilterType::HK_FILTER_NULL)
645                        }
646                        (__Field::__field2, __variant) => {
647                            _serde::de::VariantAccess::unit_variant(__variant)?;
648                            _serde::__private::Ok(hkpFilterType::HK_FILTER_GROUP)
649                        }
650                        (__Field::__field3, __variant) => {
651                            _serde::de::VariantAccess::unit_variant(__variant)?;
652                            _serde::__private::Ok(hkpFilterType::HK_FILTER_LIST)
653                        }
654                        (__Field::__field4, __variant) => {
655                            _serde::de::VariantAccess::unit_variant(__variant)?;
656                            _serde::__private::Ok(hkpFilterType::HK_FILTER_CUSTOM)
657                        }
658                        (__Field::__field5, __variant) => {
659                            _serde::de::VariantAccess::unit_variant(__variant)?;
660                            _serde::__private::Ok(hkpFilterType::HK_FILTER_PAIR)
661                        }
662                        (__Field::__field6, __variant) => {
663                            _serde::de::VariantAccess::unit_variant(__variant)?;
664                            _serde::__private::Ok(hkpFilterType::HK_FILTER_CONSTRAINT)
665                        }
666                    }
667                }
668            }
669            #[doc(hidden)]
670            const VARIANTS: &'static [&'static str] = &[
671                "HK_FILTER_UNKNOWN",
672                "HK_FILTER_NULL",
673                "HK_FILTER_GROUP",
674                "HK_FILTER_LIST",
675                "HK_FILTER_CUSTOM",
676                "HK_FILTER_PAIR",
677                "HK_FILTER_CONSTRAINT",
678            ];
679            _serde::Deserializer::deserialize_enum(
680                __deserializer,
681                "hkpFilterType",
682                VARIANTS,
683                __Visitor {
684                    marker: _serde::__private::PhantomData::<hkpFilterType>,
685                    lifetime: _serde::__private::PhantomData,
686                },
687            )
688        }
689    }
690};