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