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