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 hkModelerNodeTypeAttribute {
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 = "type"))]
31 #[cfg_attr(feature = "serde", serde(rename = "type"))]
32 pub m_type: ModelerType,
33}
34const _: () = {
35 use havok_serde as _serde;
36 impl _serde::HavokClass for hkModelerNodeTypeAttribute {
37 #[inline]
38 fn name(&self) -> &'static str {
39 "hkModelerNodeTypeAttribute"
40 }
41 #[inline]
42 fn signature(&self) -> _serde::__private::Signature {
43 _serde::__private::Signature::new(0x338c092f)
44 }
45 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
46 fn deps_indexes(&self) -> Vec<usize> {
47 let mut v = Vec::new();
48 v
49 }
50 }
51 impl _serde::Serialize for hkModelerNodeTypeAttribute {
52 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
53 where
54 S: _serde::ser::Serializer,
55 {
56 let class_meta = self
57 .__ptr
58 .map(|name| (name, _serde::__private::Signature::new(0x338c092f)));
59 let mut serializer = __serializer
60 .serialize_struct(
61 "hkModelerNodeTypeAttribute",
62 class_meta,
63 (1u64, 1u64),
64 )?;
65 serializer.serialize_field("type", &self.m_type)?;
66 serializer.end()
67 }
68 }
69};
70#[doc(hidden)]
71#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
72const _: () = {
73 use havok_serde as _serde;
74 #[automatically_derived]
75 impl<'de> _serde::Deserialize<'de> for hkModelerNodeTypeAttribute {
76 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
77 where
78 __D: _serde::Deserializer<'de>,
79 {
80 #[allow(non_camel_case_types)]
81 enum __Field {
82 m_type,
83 __ignore,
84 }
85 struct __FieldVisitor;
86 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
87 type Value = __Field;
88 fn expecting(
89 &self,
90 __formatter: &mut core::fmt::Formatter,
91 ) -> core::fmt::Result {
92 core::fmt::Formatter::write_str(__formatter, "field identifier")
93 }
94 #[allow(clippy::match_single_binding)]
96 #[allow(clippy::reversed_empty_ranges)]
97 #[allow(clippy::single_match)]
98 fn visit_key<__E>(
99 self,
100 __value: &str,
101 ) -> core::result::Result<Self::Value, __E>
102 where
103 __E: _serde::de::Error,
104 {
105 match __value {
106 "type" => Ok(__Field::m_type),
107 _ => Ok(__Field::__ignore),
108 }
109 }
110 }
111 impl<'de> _serde::Deserialize<'de> for __Field {
112 #[inline]
113 fn deserialize<__D>(
114 __deserializer: __D,
115 ) -> core::result::Result<Self, __D::Error>
116 where
117 __D: _serde::Deserializer<'de>,
118 {
119 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
120 }
121 }
122 struct __hkModelerNodeTypeAttributeVisitor<'de> {
123 marker: _serde::__private::PhantomData<hkModelerNodeTypeAttribute>,
124 lifetime: _serde::__private::PhantomData<&'de ()>,
125 }
126 #[allow(clippy::match_single_binding)]
127 #[allow(clippy::reversed_empty_ranges)]
128 #[allow(clippy::single_match)]
129 impl<'de> _serde::de::Visitor<'de>
130 for __hkModelerNodeTypeAttributeVisitor<'de> {
131 type Value = hkModelerNodeTypeAttribute;
132 fn expecting(
133 &self,
134 __formatter: &mut core::fmt::Formatter,
135 ) -> core::fmt::Result {
136 core::fmt::Formatter::write_str(
137 __formatter,
138 "struct hkModelerNodeTypeAttribute",
139 )
140 }
141 fn visit_struct_for_bytes<__A>(
142 self,
143 mut __map: __A,
144 ) -> _serde::__private::Result<Self::Value, __A::Error>
145 where
146 __A: _serde::de::MapAccess<'de>,
147 {
148 let __ptr = __A::class_ptr(&mut __map);
149 let mut m_type: _serde::__private::Option<ModelerType> = _serde::__private::None;
150 for i in 0..1usize {
151 match i {
152 0usize => {
153 if _serde::__private::Option::is_some(&m_type) {
154 return _serde::__private::Err(
155 <__A::Error as _serde::de::Error>::duplicate_field("type"),
156 );
157 }
158 m_type = _serde::__private::Some(
159 match __A::next_value::<ModelerType>(&mut __map) {
160 _serde::__private::Ok(__val) => __val,
161 _serde::__private::Err(__err) => {
162 return _serde::__private::Err(__err);
163 }
164 },
165 );
166 }
167 _ => {}
168 }
169 }
170 let m_type = match m_type {
171 _serde::__private::Some(__field) => __field,
172 _serde::__private::None => {
173 return _serde::__private::Err(
174 <__A::Error as _serde::de::Error>::missing_field("type"),
175 );
176 }
177 };
178 _serde::__private::Ok(hkModelerNodeTypeAttribute {
179 __ptr,
180 m_type,
181 })
182 }
183 #[allow(clippy::manual_unwrap_or_default)]
184 fn visit_struct<__A>(
185 self,
186 mut __map: __A,
187 ) -> _serde::__private::Result<Self::Value, __A::Error>
188 where
189 __A: _serde::de::MapAccess<'de>,
190 {
191 let mut m_type: _serde::__private::Option<ModelerType> = _serde::__private::None;
192 while let _serde::__private::Some(__key) = {
193 __A::next_key::<__Field>(&mut __map)?
194 } {
195 match __key {
196 __Field::m_type => {
197 #[cfg(
198 any(feature = "strict", feature = "ignore_duplicates")
199 )]
200 if _serde::__private::Option::is_some(&m_type) {
201 #[cfg(feature = "ignore_duplicates")]
202 {
203 __A::skip_value(&mut __map)?;
204 continue;
205 }
206 #[cfg(feature = "strict")]
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::<ModelerType>(&mut __map) {
213 _serde::__private::Ok(__val) => __val,
214 _serde::__private::Err(__err) => {
215 return _serde::__private::Err(__err);
216 }
217 },
218 );
219 }
220 _ => __A::skip_value(&mut __map)?,
221 }
222 }
223 let m_type = match m_type {
224 _serde::__private::Some(__field) => __field,
225 _serde::__private::None => {
226 #[cfg(feature = "strict")]
227 return _serde::__private::Err(
228 <__A::Error as _serde::de::Error>::missing_field("type"),
229 );
230 #[cfg(not(feature = "strict"))] Default::default()
231 }
232 };
233 let __ptr = __A::class_ptr(&mut __map);
234 _serde::__private::Ok(hkModelerNodeTypeAttribute {
235 __ptr,
236 m_type,
237 })
238 }
239 }
240 const FIELDS: &[&str] = &["type"];
241 _serde::Deserializer::deserialize_struct(
242 deserializer,
243 "hkModelerNodeTypeAttribute",
244 FIELDS,
245 __hkModelerNodeTypeAttributeVisitor {
246 marker: _serde::__private::PhantomData::<hkModelerNodeTypeAttribute>,
247 lifetime: _serde::__private::PhantomData,
248 },
249 )
250 }
251 }
252};
253#[allow(non_upper_case_globals, non_snake_case)]
256#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
257#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
258#[derive(
259 Debug,
260 Clone,
261 Default,
262 PartialEq,
263 Eq,
264 PartialOrd,
265 Ord,
266 num_derive::ToPrimitive,
267 num_derive::FromPrimitive,
268)]
269pub enum ModelerType {
270 #[default]
271 DEFAULT = 0isize,
272 LOCATOR = 1isize,
273}
274const _: () = {
275 use havok_serde as __serde;
276 impl __serde::Serialize for ModelerType {
277 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
278 where
279 S: __serde::ser::Serializer,
280 {
281 let mut __serializer = __serializer.serialize_enum_flags()?;
282 match self {
283 Self::DEFAULT => __serializer.serialize_field("DEFAULT", &0u64),
284 Self::LOCATOR => __serializer.serialize_field("LOCATOR", &1u64),
285 }?;
286 use num_traits::ToPrimitive as _;
287 let num = self
288 .to_i8()
289 .ok_or(S::Error::custom("Failed enum ModelerType to_i8"))?;
290 __serializer.serialize_bits(&num)?;
291 __serializer.end()
292 }
293 }
294};
295#[doc(hidden)]
296#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
297const _: () = {
298 #[allow(unused_extern_crates, clippy::useless_attribute)]
299 extern crate havok_serde as _serde;
300 #[automatically_derived]
301 impl<'de> _serde::Deserialize<'de> for ModelerType {
302 fn deserialize<__D>(
303 __deserializer: __D,
304 ) -> _serde::__private::Result<Self, __D::Error>
305 where
306 __D: _serde::Deserializer<'de>,
307 {
308 #[allow(non_camel_case_types)]
309 #[doc(hidden)]
310 enum __Field {
311 __field0,
312 __field1,
313 }
314 #[doc(hidden)]
315 struct __FieldVisitor;
316 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
317 type Value = __Field;
318 fn expecting(
319 &self,
320 __formatter: &mut _serde::__private::Formatter,
321 ) -> _serde::__private::fmt::Result {
322 _serde::__private::Formatter::write_str(
323 __formatter,
324 "variant identifier",
325 )
326 }
327 fn visit_int8<__E>(
328 self,
329 __value: i8,
330 ) -> _serde::__private::Result<Self::Value, __E>
331 where
332 __E: _serde::de::Error,
333 {
334 match __value {
335 0i8 => _serde::__private::Ok(__Field::__field0),
336 1i8 => _serde::__private::Ok(__Field::__field1),
337 _ => {
338 _serde::__private::Err(
339 _serde::de::Error::invalid_value(
340 _serde::de::Unexpected::Int8(__value),
341 &"value(i8) of variant is one of 0, 1",
342 ),
343 )
344 }
345 }
346 }
347 fn visit_stringptr<__E>(
348 self,
349 __value: StringPtr<'de>,
350 ) -> _serde::__private::Result<Self::Value, __E>
351 where
352 __E: _serde::de::Error,
353 {
354 if let Some(__value) = __value.into_inner() {
355 match __value.as_ref() {
356 v if v == "0" || v.eq_ignore_ascii_case("DEFAULT") => {
357 _serde::__private::Ok(__Field::__field0)
358 }
359 v if v == "1" || v.eq_ignore_ascii_case("LOCATOR") => {
360 _serde::__private::Ok(__Field::__field1)
361 }
362 _ => {
363 _serde::__private::Err(
364 _serde::de::Error::unknown_variant(&__value, VARIANTS),
365 )
366 }
367 }
368 } else {
369 _serde::__private::Err(
370 _serde::de::Error::unknown_variant("None", VARIANTS),
371 )
372 }
373 }
374 }
375 impl<'de> _serde::Deserialize<'de> for __Field {
376 #[inline]
377 fn deserialize<__D>(
378 __deserializer: __D,
379 ) -> _serde::__private::Result<Self, __D::Error>
380 where
381 __D: _serde::Deserializer<'de>,
382 {
383 _serde::Deserializer::deserialize_identifier(
384 __deserializer,
385 _serde::de::ReadEnumSize::Int8,
386 __FieldVisitor,
387 )
388 }
389 }
390 #[doc(hidden)]
391 struct __Visitor<'de> {
392 marker: _serde::__private::PhantomData<ModelerType>,
393 lifetime: _serde::__private::PhantomData<&'de ()>,
394 }
395 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
396 type Value = ModelerType;
397 fn expecting(
398 &self,
399 __formatter: &mut _serde::__private::Formatter,
400 ) -> _serde::__private::fmt::Result {
401 _serde::__private::Formatter::write_str(
402 __formatter,
403 "enum ModelerType",
404 )
405 }
406 fn visit_enum<__A>(
407 self,
408 __data: __A,
409 ) -> _serde::__private::Result<Self::Value, __A::Error>
410 where
411 __A: _serde::de::EnumAccess<'de>,
412 {
413 match _serde::de::EnumAccess::variant(__data)? {
414 (__Field::__field0, __variant) => {
415 _serde::de::VariantAccess::unit_variant(__variant)?;
416 _serde::__private::Ok(ModelerType::DEFAULT)
417 }
418 (__Field::__field1, __variant) => {
419 _serde::de::VariantAccess::unit_variant(__variant)?;
420 _serde::__private::Ok(ModelerType::LOCATOR)
421 }
422 }
423 }
424 }
425 #[doc(hidden)]
426 const VARIANTS: &'static [&'static str] = &["DEFAULT", "LOCATOR"];
427 _serde::Deserializer::deserialize_enum(
428 __deserializer,
429 "ModelerType",
430 VARIANTS,
431 __Visitor {
432 marker: _serde::__private::PhantomData::<ModelerType>,
433 lifetime: _serde::__private::PhantomData,
434 },
435 )
436 }
437 }
438};