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