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