havok_classes/generated/
hkbAuxiliaryNodeInfo_.rs

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