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