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