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 hkpPoweredChainMapper {
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(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "links"))]
35 #[cfg_attr(feature = "serde", serde(rename = "links"))]
36 pub m_links: Vec<hkpPoweredChainMapperLinkInfo>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "targets"))]
42 #[cfg_attr(feature = "serde", serde(rename = "targets"))]
43 pub m_targets: Vec<hkpPoweredChainMapperTarget>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "chains"))]
49 #[cfg_attr(feature = "serde", serde(rename = "chains"))]
50 pub m_chains: Vec<Pointer>,
51}
52const _: () = {
53 use havok_serde as _serde;
54 impl _serde::HavokClass for hkpPoweredChainMapper {
55 #[inline]
56 fn name(&self) -> &'static str {
57 "hkpPoweredChainMapper"
58 }
59 #[inline]
60 fn signature(&self) -> _serde::__private::Signature {
61 _serde::__private::Signature::new(0x7a77ef5)
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.extend(
67 self
68 .m_links
69 .iter()
70 .flat_map(|class| class.deps_indexes())
71 .collect::<Vec<usize>>(),
72 );
73 v.extend(
74 self
75 .m_targets
76 .iter()
77 .flat_map(|class| class.deps_indexes())
78 .collect::<Vec<usize>>(),
79 );
80 v.extend(self.m_chains.iter().map(|ptr| ptr.get()));
81 v
82 }
83 }
84 impl _serde::Serialize for hkpPoweredChainMapper {
85 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
86 where
87 S: _serde::ser::Serializer,
88 {
89 let class_meta = self
90 .__ptr
91 .map(|name| (name, _serde::__private::Signature::new(0x7a77ef5)));
92 let mut serializer = __serializer
93 .serialize_struct("hkpPoweredChainMapper", class_meta, (44u64, 64u64))?;
94 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
95 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
96 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
97 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
98 serializer
99 .serialize_array_field(
100 "links",
101 &self.m_links,
102 TypeSize::Struct {
103 size_x86: 12u64,
104 size_x86_64: 16u64,
105 },
106 )?;
107 serializer
108 .serialize_array_field(
109 "targets",
110 &self.m_targets,
111 TypeSize::Struct {
112 size_x86: 8u64,
113 size_x86_64: 16u64,
114 },
115 )?;
116 serializer
117 .serialize_array_field("chains", &self.m_chains, TypeSize::NonPtr)?;
118 serializer.end()
119 }
120 }
121};
122#[doc(hidden)]
123#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
124const _: () = {
125 use havok_serde as _serde;
126 #[automatically_derived]
127 impl<'de> _serde::Deserialize<'de> for hkpPoweredChainMapper {
128 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
129 where
130 __D: _serde::Deserializer<'de>,
131 {
132 #[allow(non_camel_case_types)]
133 enum __Field {
134 m_links,
135 m_targets,
136 m_chains,
137 __ignore,
138 }
139 struct __FieldVisitor;
140 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
141 type Value = __Field;
142 fn expecting(
143 &self,
144 __formatter: &mut core::fmt::Formatter,
145 ) -> core::fmt::Result {
146 core::fmt::Formatter::write_str(__formatter, "field identifier")
147 }
148 #[allow(clippy::match_single_binding)]
150 #[allow(clippy::reversed_empty_ranges)]
151 #[allow(clippy::single_match)]
152 fn visit_key<__E>(
153 self,
154 __value: &str,
155 ) -> core::result::Result<Self::Value, __E>
156 where
157 __E: _serde::de::Error,
158 {
159 match __value {
160 "links" => Ok(__Field::m_links),
161 "targets" => Ok(__Field::m_targets),
162 "chains" => Ok(__Field::m_chains),
163 _ => Ok(__Field::__ignore),
164 }
165 }
166 }
167 impl<'de> _serde::Deserialize<'de> for __Field {
168 #[inline]
169 fn deserialize<__D>(
170 __deserializer: __D,
171 ) -> core::result::Result<Self, __D::Error>
172 where
173 __D: _serde::Deserializer<'de>,
174 {
175 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
176 }
177 }
178 struct __hkpPoweredChainMapperVisitor<'de> {
179 marker: _serde::__private::PhantomData<hkpPoweredChainMapper>,
180 lifetime: _serde::__private::PhantomData<&'de ()>,
181 }
182 #[allow(clippy::match_single_binding)]
183 #[allow(clippy::reversed_empty_ranges)]
184 #[allow(clippy::single_match)]
185 impl<'de> _serde::de::Visitor<'de> for __hkpPoweredChainMapperVisitor<'de> {
186 type Value = hkpPoweredChainMapper;
187 fn expecting(
188 &self,
189 __formatter: &mut core::fmt::Formatter,
190 ) -> core::fmt::Result {
191 core::fmt::Formatter::write_str(
192 __formatter,
193 "struct hkpPoweredChainMapper",
194 )
195 }
196 fn visit_struct_for_bytes<__A>(
197 self,
198 mut __map: __A,
199 ) -> _serde::__private::Result<Self::Value, __A::Error>
200 where
201 __A: _serde::de::MapAccess<'de>,
202 {
203 let __ptr = __A::class_ptr(&mut __map);
204 let parent = __A::parent_value(&mut __map)?;
205 let mut m_links: _serde::__private::Option<
206 Vec<hkpPoweredChainMapperLinkInfo>,
207 > = _serde::__private::None;
208 let mut m_targets: _serde::__private::Option<
209 Vec<hkpPoweredChainMapperTarget>,
210 > = _serde::__private::None;
211 let mut m_chains: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
212 for i in 0..3usize {
213 match i {
214 0usize => {
215 if _serde::__private::Option::is_some(&m_links) {
216 return _serde::__private::Err(
217 <__A::Error as _serde::de::Error>::duplicate_field("links"),
218 );
219 }
220 m_links = _serde::__private::Some(
221 match __A::next_value::<
222 Vec<hkpPoweredChainMapperLinkInfo>,
223 >(&mut __map) {
224 _serde::__private::Ok(__val) => __val,
225 _serde::__private::Err(__err) => {
226 return _serde::__private::Err(__err);
227 }
228 },
229 );
230 }
231 1usize => {
232 if _serde::__private::Option::is_some(&m_targets) {
233 return _serde::__private::Err(
234 <__A::Error as _serde::de::Error>::duplicate_field(
235 "targets",
236 ),
237 );
238 }
239 m_targets = _serde::__private::Some(
240 match __A::next_value::<
241 Vec<hkpPoweredChainMapperTarget>,
242 >(&mut __map) {
243 _serde::__private::Ok(__val) => __val,
244 _serde::__private::Err(__err) => {
245 return _serde::__private::Err(__err);
246 }
247 },
248 );
249 }
250 2usize => {
251 if _serde::__private::Option::is_some(&m_chains) {
252 return _serde::__private::Err(
253 <__A::Error as _serde::de::Error>::duplicate_field("chains"),
254 );
255 }
256 m_chains = _serde::__private::Some(
257 match __A::next_value::<Vec<Pointer>>(&mut __map) {
258 _serde::__private::Ok(__val) => __val,
259 _serde::__private::Err(__err) => {
260 return _serde::__private::Err(__err);
261 }
262 },
263 );
264 }
265 _ => {}
266 }
267 }
268 let m_links = match m_links {
269 _serde::__private::Some(__field) => __field,
270 _serde::__private::None => {
271 return _serde::__private::Err(
272 <__A::Error as _serde::de::Error>::missing_field("links"),
273 );
274 }
275 };
276 let m_targets = match m_targets {
277 _serde::__private::Some(__field) => __field,
278 _serde::__private::None => {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::missing_field("targets"),
281 );
282 }
283 };
284 let m_chains = match m_chains {
285 _serde::__private::Some(__field) => __field,
286 _serde::__private::None => {
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::missing_field("chains"),
289 );
290 }
291 };
292 _serde::__private::Ok(hkpPoweredChainMapper {
293 __ptr,
294 parent,
295 m_links,
296 m_targets,
297 m_chains,
298 })
299 }
300 #[allow(clippy::manual_unwrap_or_default)]
301 fn visit_struct<__A>(
302 self,
303 mut __map: __A,
304 ) -> _serde::__private::Result<Self::Value, __A::Error>
305 where
306 __A: _serde::de::MapAccess<'de>,
307 {
308 let mut m_links: _serde::__private::Option<
309 Vec<hkpPoweredChainMapperLinkInfo>,
310 > = _serde::__private::None;
311 let mut m_targets: _serde::__private::Option<
312 Vec<hkpPoweredChainMapperTarget>,
313 > = _serde::__private::None;
314 let mut m_chains: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
315 while let _serde::__private::Some(__key) = {
316 __A::next_key::<__Field>(&mut __map)?
317 } {
318 match __key {
319 __Field::m_links => {
320 #[cfg(
321 any(feature = "strict", feature = "ignore_duplicates")
322 )]
323 if _serde::__private::Option::is_some(&m_links) {
324 #[cfg(feature = "ignore_duplicates")]
325 {
326 __A::skip_value(&mut __map)?;
327 continue;
328 }
329 #[cfg(feature = "strict")]
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::duplicate_field("links"),
332 );
333 }
334 m_links = _serde::__private::Some(
335 match __A::next_value::<
336 Vec<hkpPoweredChainMapperLinkInfo>,
337 >(&mut __map) {
338 _serde::__private::Ok(__val) => __val,
339 _serde::__private::Err(__err) => {
340 return _serde::__private::Err(__err);
341 }
342 },
343 );
344 }
345 __Field::m_targets => {
346 #[cfg(
347 any(feature = "strict", feature = "ignore_duplicates")
348 )]
349 if _serde::__private::Option::is_some(&m_targets) {
350 #[cfg(feature = "ignore_duplicates")]
351 {
352 __A::skip_value(&mut __map)?;
353 continue;
354 }
355 #[cfg(feature = "strict")]
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::duplicate_field(
358 "targets",
359 ),
360 );
361 }
362 m_targets = _serde::__private::Some(
363 match __A::next_value::<
364 Vec<hkpPoweredChainMapperTarget>,
365 >(&mut __map) {
366 _serde::__private::Ok(__val) => __val,
367 _serde::__private::Err(__err) => {
368 return _serde::__private::Err(__err);
369 }
370 },
371 );
372 }
373 __Field::m_chains => {
374 #[cfg(
375 any(feature = "strict", feature = "ignore_duplicates")
376 )]
377 if _serde::__private::Option::is_some(&m_chains) {
378 #[cfg(feature = "ignore_duplicates")]
379 {
380 __A::skip_value(&mut __map)?;
381 continue;
382 }
383 #[cfg(feature = "strict")]
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field("chains"),
386 );
387 }
388 m_chains = _serde::__private::Some(
389 match __A::next_value::<Vec<Pointer>>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 _ => __A::skip_value(&mut __map)?,
398 }
399 }
400 let m_links = match m_links {
401 _serde::__private::Some(__field) => __field,
402 _serde::__private::None => {
403 #[cfg(feature = "strict")]
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field("links"),
406 );
407 #[cfg(not(feature = "strict"))] Default::default()
408 }
409 };
410 let m_targets = match m_targets {
411 _serde::__private::Some(__field) => __field,
412 _serde::__private::None => {
413 #[cfg(feature = "strict")]
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field("targets"),
416 );
417 #[cfg(not(feature = "strict"))] Default::default()
418 }
419 };
420 let m_chains = match m_chains {
421 _serde::__private::Some(__field) => __field,
422 _serde::__private::None => {
423 #[cfg(feature = "strict")]
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::missing_field("chains"),
426 );
427 #[cfg(not(feature = "strict"))] Default::default()
428 }
429 };
430 let __ptr = None;
431 let parent = hkBaseObject { __ptr };
432 let parent = hkReferencedObject {
433 __ptr,
434 parent,
435 ..Default::default()
436 };
437 let __ptr = __A::class_ptr(&mut __map);
438 _serde::__private::Ok(hkpPoweredChainMapper {
439 __ptr,
440 parent,
441 m_links,
442 m_targets,
443 m_chains,
444 })
445 }
446 }
447 const FIELDS: &[&str] = &["links", "targets", "chains"];
448 _serde::Deserializer::deserialize_struct(
449 deserializer,
450 "hkpPoweredChainMapper",
451 FIELDS,
452 __hkpPoweredChainMapperVisitor {
453 marker: _serde::__private::PhantomData::<hkpPoweredChainMapper>,
454 lifetime: _serde::__private::PhantomData,
455 },
456 )
457 }
458 }
459};