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 hkpAgent1nSector {
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 = "bytesAllocated"))]
31 #[cfg_attr(feature = "serde", serde(rename = "bytesAllocated"))]
32 pub m_bytesAllocated: u32,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "pad0"))]
38 #[cfg_attr(feature = "serde", serde(rename = "pad0"))]
39 pub m_pad0: u32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "pad1"))]
45 #[cfg_attr(feature = "serde", serde(rename = "pad1"))]
46 pub m_pad1: u32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "pad2"))]
52 #[cfg_attr(feature = "serde", serde(rename = "pad2"))]
53 pub m_pad2: u32,
54 #[cfg_attr(
59 feature = "json_schema",
60 schemars(schema_with = "make_large_int_array_schema")
61 )]
62 #[cfg_attr(
63 feature = "serde",
64 serde(with = "::serde_with::As::<[::serde_with::Same; 496]>")
65 )]
66 #[educe(Default = [0;496usize])]
67 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
68 #[cfg_attr(feature = "serde", serde(rename = "data"))]
69 pub m_data: [u8; 496usize],
70}
71const _: () = {
72 use havok_serde as _serde;
73 impl _serde::HavokClass for hkpAgent1nSector {
74 #[inline]
75 fn name(&self) -> &'static str {
76 "hkpAgent1nSector"
77 }
78 #[inline]
79 fn signature(&self) -> _serde::__private::Signature {
80 _serde::__private::Signature::new(0x626e55a)
81 }
82 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
83 fn deps_indexes(&self) -> Vec<usize> {
84 let mut v = Vec::new();
85 v
86 }
87 }
88 impl _serde::Serialize for hkpAgent1nSector {
89 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
90 where
91 S: _serde::ser::Serializer,
92 {
93 let class_meta = self
94 .__ptr
95 .map(|name| (name, _serde::__private::Signature::new(0x626e55a)));
96 let mut serializer = __serializer
97 .serialize_struct("hkpAgent1nSector", class_meta, (512u64, 512u64))?;
98 serializer.serialize_field("bytesAllocated", &self.m_bytesAllocated)?;
99 serializer.serialize_field("pad0", &self.m_pad0)?;
100 serializer.serialize_field("pad1", &self.m_pad1)?;
101 serializer.serialize_field("pad2", &self.m_pad2)?;
102 serializer
103 .serialize_fixed_array_field(
104 "data",
105 self.m_data.as_slice(),
106 TypeSize::NonPtr,
107 )?;
108 serializer.end()
109 }
110 }
111};
112#[doc(hidden)]
113#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
114const _: () = {
115 use havok_serde as _serde;
116 #[automatically_derived]
117 impl<'de> _serde::Deserialize<'de> for hkpAgent1nSector {
118 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
119 where
120 __D: _serde::Deserializer<'de>,
121 {
122 #[allow(non_camel_case_types)]
123 enum __Field {
124 m_bytesAllocated,
125 m_pad0,
126 m_pad1,
127 m_pad2,
128 m_data,
129 __ignore,
130 }
131 struct __FieldVisitor;
132 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
133 type Value = __Field;
134 fn expecting(
135 &self,
136 __formatter: &mut core::fmt::Formatter,
137 ) -> core::fmt::Result {
138 core::fmt::Formatter::write_str(__formatter, "field identifier")
139 }
140 #[allow(clippy::match_single_binding)]
142 #[allow(clippy::reversed_empty_ranges)]
143 #[allow(clippy::single_match)]
144 fn visit_key<__E>(
145 self,
146 __value: &str,
147 ) -> core::result::Result<Self::Value, __E>
148 where
149 __E: _serde::de::Error,
150 {
151 match __value {
152 "bytesAllocated" => Ok(__Field::m_bytesAllocated),
153 "pad0" => Ok(__Field::m_pad0),
154 "pad1" => Ok(__Field::m_pad1),
155 "pad2" => Ok(__Field::m_pad2),
156 "data" => Ok(__Field::m_data),
157 _ => Ok(__Field::__ignore),
158 }
159 }
160 }
161 impl<'de> _serde::Deserialize<'de> for __Field {
162 #[inline]
163 fn deserialize<__D>(
164 __deserializer: __D,
165 ) -> core::result::Result<Self, __D::Error>
166 where
167 __D: _serde::Deserializer<'de>,
168 {
169 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
170 }
171 }
172 struct __hkpAgent1nSectorVisitor<'de> {
173 marker: _serde::__private::PhantomData<hkpAgent1nSector>,
174 lifetime: _serde::__private::PhantomData<&'de ()>,
175 }
176 #[allow(clippy::match_single_binding)]
177 #[allow(clippy::reversed_empty_ranges)]
178 #[allow(clippy::single_match)]
179 impl<'de> _serde::de::Visitor<'de> for __hkpAgent1nSectorVisitor<'de> {
180 type Value = hkpAgent1nSector;
181 fn expecting(
182 &self,
183 __formatter: &mut core::fmt::Formatter,
184 ) -> core::fmt::Result {
185 core::fmt::Formatter::write_str(
186 __formatter,
187 "struct hkpAgent1nSector",
188 )
189 }
190 fn visit_struct_for_bytes<__A>(
191 self,
192 mut __map: __A,
193 ) -> _serde::__private::Result<Self::Value, __A::Error>
194 where
195 __A: _serde::de::MapAccess<'de>,
196 {
197 let __ptr = __A::class_ptr(&mut __map);
198 let mut m_bytesAllocated: _serde::__private::Option<u32> = _serde::__private::None;
199 let mut m_pad0: _serde::__private::Option<u32> = _serde::__private::None;
200 let mut m_pad1: _serde::__private::Option<u32> = _serde::__private::None;
201 let mut m_pad2: _serde::__private::Option<u32> = _serde::__private::None;
202 let mut m_data: _serde::__private::Option<[u8; 496usize]> = _serde::__private::None;
203 for i in 0..5usize {
204 match i {
205 0usize => {
206 if _serde::__private::Option::is_some(&m_bytesAllocated) {
207 return _serde::__private::Err(
208 <__A::Error as _serde::de::Error>::duplicate_field(
209 "bytesAllocated",
210 ),
211 );
212 }
213 m_bytesAllocated = _serde::__private::Some(
214 match __A::next_value::<u32>(&mut __map) {
215 _serde::__private::Ok(__val) => __val,
216 _serde::__private::Err(__err) => {
217 return _serde::__private::Err(__err);
218 }
219 },
220 );
221 }
222 1usize => {
223 if _serde::__private::Option::is_some(&m_pad0) {
224 return _serde::__private::Err(
225 <__A::Error as _serde::de::Error>::duplicate_field("pad0"),
226 );
227 }
228 m_pad0 = _serde::__private::Some(
229 match __A::next_value::<u32>(&mut __map) {
230 _serde::__private::Ok(__val) => __val,
231 _serde::__private::Err(__err) => {
232 return _serde::__private::Err(__err);
233 }
234 },
235 );
236 }
237 2usize => {
238 if _serde::__private::Option::is_some(&m_pad1) {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::duplicate_field("pad1"),
241 );
242 }
243 m_pad1 = _serde::__private::Some(
244 match __A::next_value::<u32>(&mut __map) {
245 _serde::__private::Ok(__val) => __val,
246 _serde::__private::Err(__err) => {
247 return _serde::__private::Err(__err);
248 }
249 },
250 );
251 }
252 3usize => {
253 if _serde::__private::Option::is_some(&m_pad2) {
254 return _serde::__private::Err(
255 <__A::Error as _serde::de::Error>::duplicate_field("pad2"),
256 );
257 }
258 m_pad2 = _serde::__private::Some(
259 match __A::next_value::<u32>(&mut __map) {
260 _serde::__private::Ok(__val) => __val,
261 _serde::__private::Err(__err) => {
262 return _serde::__private::Err(__err);
263 }
264 },
265 );
266 }
267 4usize => {
268 if _serde::__private::Option::is_some(&m_data) {
269 return _serde::__private::Err(
270 <__A::Error as _serde::de::Error>::duplicate_field("data"),
271 );
272 }
273 m_data = _serde::__private::Some(
274 match __A::next_value::<[u8; 496usize]>(&mut __map) {
275 _serde::__private::Ok(__val) => __val,
276 _serde::__private::Err(__err) => {
277 return _serde::__private::Err(__err);
278 }
279 },
280 );
281 }
282 _ => {}
283 }
284 }
285 let m_bytesAllocated = match m_bytesAllocated {
286 _serde::__private::Some(__field) => __field,
287 _serde::__private::None => {
288 return _serde::__private::Err(
289 <__A::Error as _serde::de::Error>::missing_field(
290 "bytesAllocated",
291 ),
292 );
293 }
294 };
295 let m_pad0 = match m_pad0 {
296 _serde::__private::Some(__field) => __field,
297 _serde::__private::None => {
298 return _serde::__private::Err(
299 <__A::Error as _serde::de::Error>::missing_field("pad0"),
300 );
301 }
302 };
303 let m_pad1 = match m_pad1 {
304 _serde::__private::Some(__field) => __field,
305 _serde::__private::None => {
306 return _serde::__private::Err(
307 <__A::Error as _serde::de::Error>::missing_field("pad1"),
308 );
309 }
310 };
311 let m_pad2 = match m_pad2 {
312 _serde::__private::Some(__field) => __field,
313 _serde::__private::None => {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::missing_field("pad2"),
316 );
317 }
318 };
319 let m_data = match m_data {
320 _serde::__private::Some(__field) => __field,
321 _serde::__private::None => {
322 return _serde::__private::Err(
323 <__A::Error as _serde::de::Error>::missing_field("data"),
324 );
325 }
326 };
327 _serde::__private::Ok(hkpAgent1nSector {
328 __ptr,
329 m_bytesAllocated,
330 m_pad0,
331 m_pad1,
332 m_pad2,
333 m_data,
334 })
335 }
336 #[allow(clippy::manual_unwrap_or_default)]
337 fn visit_struct<__A>(
338 self,
339 mut __map: __A,
340 ) -> _serde::__private::Result<Self::Value, __A::Error>
341 where
342 __A: _serde::de::MapAccess<'de>,
343 {
344 let mut m_bytesAllocated: _serde::__private::Option<u32> = _serde::__private::None;
345 let mut m_pad0: _serde::__private::Option<u32> = _serde::__private::None;
346 let mut m_pad1: _serde::__private::Option<u32> = _serde::__private::None;
347 let mut m_pad2: _serde::__private::Option<u32> = _serde::__private::None;
348 let mut m_data: _serde::__private::Option<[u8; 496usize]> = _serde::__private::None;
349 while let _serde::__private::Some(__key) = {
350 __A::next_key::<__Field>(&mut __map)?
351 } {
352 match __key {
353 __Field::m_bytesAllocated => {
354 #[cfg(
355 any(feature = "strict", feature = "ignore_duplicates")
356 )]
357 if _serde::__private::Option::is_some(&m_bytesAllocated) {
358 #[cfg(feature = "ignore_duplicates")]
359 {
360 __A::skip_value(&mut __map)?;
361 continue;
362 }
363 #[cfg(feature = "strict")]
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::duplicate_field(
366 "bytesAllocated",
367 ),
368 );
369 }
370 m_bytesAllocated = _serde::__private::Some(
371 match __A::next_value::<u32>(&mut __map) {
372 _serde::__private::Ok(__val) => __val,
373 _serde::__private::Err(__err) => {
374 return _serde::__private::Err(__err);
375 }
376 },
377 );
378 }
379 __Field::m_pad0 => {
380 #[cfg(
381 any(feature = "strict", feature = "ignore_duplicates")
382 )]
383 if _serde::__private::Option::is_some(&m_pad0) {
384 #[cfg(feature = "ignore_duplicates")]
385 {
386 __A::skip_value(&mut __map)?;
387 continue;
388 }
389 #[cfg(feature = "strict")]
390 return _serde::__private::Err(
391 <__A::Error as _serde::de::Error>::duplicate_field("pad0"),
392 );
393 }
394 m_pad0 = _serde::__private::Some(
395 match __A::next_value::<u32>(&mut __map) {
396 _serde::__private::Ok(__val) => __val,
397 _serde::__private::Err(__err) => {
398 return _serde::__private::Err(__err);
399 }
400 },
401 );
402 }
403 __Field::m_pad1 => {
404 #[cfg(
405 any(feature = "strict", feature = "ignore_duplicates")
406 )]
407 if _serde::__private::Option::is_some(&m_pad1) {
408 #[cfg(feature = "ignore_duplicates")]
409 {
410 __A::skip_value(&mut __map)?;
411 continue;
412 }
413 #[cfg(feature = "strict")]
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::duplicate_field("pad1"),
416 );
417 }
418 m_pad1 = _serde::__private::Some(
419 match __A::next_value::<u32>(&mut __map) {
420 _serde::__private::Ok(__val) => __val,
421 _serde::__private::Err(__err) => {
422 return _serde::__private::Err(__err);
423 }
424 },
425 );
426 }
427 __Field::m_pad2 => {
428 #[cfg(
429 any(feature = "strict", feature = "ignore_duplicates")
430 )]
431 if _serde::__private::Option::is_some(&m_pad2) {
432 #[cfg(feature = "ignore_duplicates")]
433 {
434 __A::skip_value(&mut __map)?;
435 continue;
436 }
437 #[cfg(feature = "strict")]
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::duplicate_field("pad2"),
440 );
441 }
442 m_pad2 = _serde::__private::Some(
443 match __A::next_value::<u32>(&mut __map) {
444 _serde::__private::Ok(__val) => __val,
445 _serde::__private::Err(__err) => {
446 return _serde::__private::Err(__err);
447 }
448 },
449 );
450 }
451 __Field::m_data => {
452 #[cfg(
453 any(feature = "strict", feature = "ignore_duplicates")
454 )]
455 if _serde::__private::Option::is_some(&m_data) {
456 #[cfg(feature = "ignore_duplicates")]
457 {
458 __A::skip_value(&mut __map)?;
459 continue;
460 }
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::duplicate_field("data"),
464 );
465 }
466 m_data = _serde::__private::Some(
467 match __A::next_value::<[u8; 496usize]>(&mut __map) {
468 _serde::__private::Ok(__val) => __val,
469 _serde::__private::Err(__err) => {
470 return _serde::__private::Err(__err);
471 }
472 },
473 );
474 }
475 _ => __A::skip_value(&mut __map)?,
476 }
477 }
478 let m_bytesAllocated = match m_bytesAllocated {
479 _serde::__private::Some(__field) => __field,
480 _serde::__private::None => {
481 #[cfg(feature = "strict")]
482 return _serde::__private::Err(
483 <__A::Error as _serde::de::Error>::missing_field(
484 "bytesAllocated",
485 ),
486 );
487 #[cfg(not(feature = "strict"))] Default::default()
488 }
489 };
490 let m_pad0 = match m_pad0 {
491 _serde::__private::Some(__field) => __field,
492 _serde::__private::None => {
493 #[cfg(feature = "strict")]
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::missing_field("pad0"),
496 );
497 #[cfg(not(feature = "strict"))] Default::default()
498 }
499 };
500 let m_pad1 = match m_pad1 {
501 _serde::__private::Some(__field) => __field,
502 _serde::__private::None => {
503 #[cfg(feature = "strict")]
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::missing_field("pad1"),
506 );
507 #[cfg(not(feature = "strict"))] Default::default()
508 }
509 };
510 let m_pad2 = match m_pad2 {
511 _serde::__private::Some(__field) => __field,
512 _serde::__private::None => {
513 #[cfg(feature = "strict")]
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::missing_field("pad2"),
516 );
517 #[cfg(not(feature = "strict"))] Default::default()
518 }
519 };
520 let m_data = match m_data {
521 _serde::__private::Some(__field) => __field,
522 _serde::__private::None => {
523 #[cfg(feature = "strict")]
524 return _serde::__private::Err(
525 <__A::Error as _serde::de::Error>::missing_field("data"),
526 );
527 #[cfg(not(feature = "strict"))]
528 [Default::default(); 496usize]
529 }
530 };
531 let __ptr = __A::class_ptr(&mut __map);
532 _serde::__private::Ok(hkpAgent1nSector {
533 __ptr,
534 m_bytesAllocated,
535 m_pad0,
536 m_pad1,
537 m_pad2,
538 m_data,
539 })
540 }
541 }
542 const FIELDS: &[&str] = &["bytesAllocated", "pad0", "pad1", "pad2", "data"];
543 _serde::Deserializer::deserialize_struct(
544 deserializer,
545 "hkpAgent1nSector",
546 FIELDS,
547 __hkpAgent1nSectorVisitor {
548 marker: _serde::__private::PhantomData::<hkpAgent1nSector>,
549 lifetime: _serde::__private::PhantomData,
550 },
551 )
552 }
553 }
554};