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