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