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 hkpConstraintInstanceSmallArraySerializeOverrideType {
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 = "data"))]
32 #[cfg_attr(feature = "serde", serde(rename = "data"))]
33 pub m_data: Pointer,
34 #[cfg_attr(feature = "json_schema", schemars(rename = "size"))]
39 #[cfg_attr(feature = "serde", serde(rename = "size"))]
40 pub m_size: u16,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "capacityAndFlags"))]
46 #[cfg_attr(feature = "serde", serde(rename = "capacityAndFlags"))]
47 pub m_capacityAndFlags: u16,
48}
49const _: () = {
50 use havok_serde as _serde;
51 impl _serde::HavokClass for hkpConstraintInstanceSmallArraySerializeOverrideType {
52 #[inline]
53 fn name(&self) -> &'static str {
54 "hkpConstraintInstanceSmallArraySerializeOverrideType"
55 }
56 #[inline]
57 fn signature(&self) -> _serde::__private::Signature {
58 _serde::__private::Signature::new(0xee3c2aec)
59 }
60 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
61 fn deps_indexes(&self) -> Vec<usize> {
62 let mut v = Vec::new();
63 v.push(self.m_data.get());
64 v
65 }
66 }
67 impl _serde::Serialize for hkpConstraintInstanceSmallArraySerializeOverrideType {
68 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
69 where
70 S: _serde::ser::Serializer,
71 {
72 let class_meta = self
73 .__ptr
74 .map(|name| (name, _serde::__private::Signature::new(0xee3c2aec)));
75 let mut serializer = __serializer
76 .serialize_struct(
77 "hkpConstraintInstanceSmallArraySerializeOverrideType",
78 class_meta,
79 (8u64, 16u64),
80 )?;
81 serializer.skip_field("data", &self.m_data)?;
82 serializer.serialize_field("size", &self.m_size)?;
83 serializer.serialize_field("capacityAndFlags", &self.m_capacityAndFlags)?;
84 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
85 serializer.end()
86 }
87 }
88};
89#[doc(hidden)]
90#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
91const _: () = {
92 use havok_serde as _serde;
93 #[automatically_derived]
94 impl<'de> _serde::Deserialize<'de>
95 for hkpConstraintInstanceSmallArraySerializeOverrideType {
96 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
97 where
98 __D: _serde::Deserializer<'de>,
99 {
100 #[allow(non_camel_case_types)]
101 enum __Field {
102 m_size,
103 m_capacityAndFlags,
104 __ignore,
105 }
106 struct __FieldVisitor;
107 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
108 type Value = __Field;
109 fn expecting(
110 &self,
111 __formatter: &mut core::fmt::Formatter,
112 ) -> core::fmt::Result {
113 core::fmt::Formatter::write_str(__formatter, "field identifier")
114 }
115 #[allow(clippy::match_single_binding)]
117 #[allow(clippy::reversed_empty_ranges)]
118 #[allow(clippy::single_match)]
119 fn visit_key<__E>(
120 self,
121 __value: &str,
122 ) -> core::result::Result<Self::Value, __E>
123 where
124 __E: _serde::de::Error,
125 {
126 match __value {
127 "size" => Ok(__Field::m_size),
128 "capacityAndFlags" => Ok(__Field::m_capacityAndFlags),
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 __hkpConstraintInstanceSmallArraySerializeOverrideTypeVisitor<'de> {
145 marker: _serde::__private::PhantomData<
146 hkpConstraintInstanceSmallArraySerializeOverrideType,
147 >,
148 lifetime: _serde::__private::PhantomData<&'de ()>,
149 }
150 #[allow(clippy::match_single_binding)]
151 #[allow(clippy::reversed_empty_ranges)]
152 #[allow(clippy::single_match)]
153 impl<'de> _serde::de::Visitor<'de>
154 for __hkpConstraintInstanceSmallArraySerializeOverrideTypeVisitor<'de> {
155 type Value = hkpConstraintInstanceSmallArraySerializeOverrideType;
156 fn expecting(
157 &self,
158 __formatter: &mut core::fmt::Formatter,
159 ) -> core::fmt::Result {
160 core::fmt::Formatter::write_str(
161 __formatter,
162 "struct hkpConstraintInstanceSmallArraySerializeOverrideType",
163 )
164 }
165 fn visit_struct_for_bytes<__A>(
166 self,
167 mut __map: __A,
168 ) -> _serde::__private::Result<Self::Value, __A::Error>
169 where
170 __A: _serde::de::MapAccess<'de>,
171 {
172 let __ptr = __A::class_ptr(&mut __map);
173 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
174 let mut m_size: _serde::__private::Option<u16> = _serde::__private::None;
175 let mut m_capacityAndFlags: _serde::__private::Option<u16> = _serde::__private::None;
176 for i in 0..3usize {
177 match i {
178 0usize => {
179 if _serde::__private::Option::is_some(&m_data) {
180 return _serde::__private::Err(
181 <__A::Error as _serde::de::Error>::duplicate_field("data"),
182 );
183 }
184 m_data = _serde::__private::Some(
185 match __A::next_value::<Pointer>(&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_size) {
195 return _serde::__private::Err(
196 <__A::Error as _serde::de::Error>::duplicate_field("size"),
197 );
198 }
199 m_size = _serde::__private::Some(
200 match __A::next_value::<u16>(&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_capacityAndFlags) {
210 return _serde::__private::Err(
211 <__A::Error as _serde::de::Error>::duplicate_field(
212 "capacityAndFlags",
213 ),
214 );
215 }
216 m_capacityAndFlags = _serde::__private::Some(
217 match __A::next_value::<u16>(&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_data = match m_data {
230 _serde::__private::Some(__field) => __field,
231 _serde::__private::None => {
232 return _serde::__private::Err(
233 <__A::Error as _serde::de::Error>::missing_field("data"),
234 );
235 }
236 };
237 let m_size = match m_size {
238 _serde::__private::Some(__field) => __field,
239 _serde::__private::None => {
240 return _serde::__private::Err(
241 <__A::Error as _serde::de::Error>::missing_field("size"),
242 );
243 }
244 };
245 let m_capacityAndFlags = match m_capacityAndFlags {
246 _serde::__private::Some(__field) => __field,
247 _serde::__private::None => {
248 return _serde::__private::Err(
249 <__A::Error as _serde::de::Error>::missing_field(
250 "capacityAndFlags",
251 ),
252 );
253 }
254 };
255 _serde::__private::Ok(hkpConstraintInstanceSmallArraySerializeOverrideType {
256 __ptr,
257 m_data,
258 m_size,
259 m_capacityAndFlags,
260 })
261 }
262 #[allow(clippy::manual_unwrap_or_default)]
263 fn visit_struct<__A>(
264 self,
265 mut __map: __A,
266 ) -> _serde::__private::Result<Self::Value, __A::Error>
267 where
268 __A: _serde::de::MapAccess<'de>,
269 {
270 let mut m_size: _serde::__private::Option<u16> = _serde::__private::None;
271 let mut m_capacityAndFlags: _serde::__private::Option<u16> = _serde::__private::None;
272 while let _serde::__private::Some(__key) = {
273 __A::next_key::<__Field>(&mut __map)?
274 } {
275 match __key {
276 __Field::m_size => {
277 #[cfg(
278 any(feature = "strict", feature = "ignore_duplicates")
279 )]
280 if _serde::__private::Option::is_some(&m_size) {
281 #[cfg(feature = "ignore_duplicates")]
282 {
283 __A::skip_value(&mut __map)?;
284 continue;
285 }
286 #[cfg(feature = "strict")]
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::duplicate_field("size"),
289 );
290 }
291 m_size = _serde::__private::Some(
292 match __A::next_value::<u16>(&mut __map) {
293 _serde::__private::Ok(__val) => __val,
294 _serde::__private::Err(__err) => {
295 return _serde::__private::Err(__err);
296 }
297 },
298 );
299 }
300 __Field::m_capacityAndFlags => {
301 #[cfg(
302 any(feature = "strict", feature = "ignore_duplicates")
303 )]
304 if _serde::__private::Option::is_some(&m_capacityAndFlags) {
305 #[cfg(feature = "ignore_duplicates")]
306 {
307 __A::skip_value(&mut __map)?;
308 continue;
309 }
310 #[cfg(feature = "strict")]
311 return _serde::__private::Err(
312 <__A::Error as _serde::de::Error>::duplicate_field(
313 "capacityAndFlags",
314 ),
315 );
316 }
317 m_capacityAndFlags = _serde::__private::Some(
318 match __A::next_value::<u16>(&mut __map) {
319 _serde::__private::Ok(__val) => __val,
320 _serde::__private::Err(__err) => {
321 return _serde::__private::Err(__err);
322 }
323 },
324 );
325 }
326 _ => __A::skip_value(&mut __map)?,
327 }
328 }
329 let m_size = match m_size {
330 _serde::__private::Some(__field) => __field,
331 _serde::__private::None => {
332 #[cfg(feature = "strict")]
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::missing_field("size"),
335 );
336 #[cfg(not(feature = "strict"))] Default::default()
337 }
338 };
339 let m_capacityAndFlags = match m_capacityAndFlags {
340 _serde::__private::Some(__field) => __field,
341 _serde::__private::None => {
342 #[cfg(feature = "strict")]
343 return _serde::__private::Err(
344 <__A::Error as _serde::de::Error>::missing_field(
345 "capacityAndFlags",
346 ),
347 );
348 #[cfg(not(feature = "strict"))] Default::default()
349 }
350 };
351 let __ptr = __A::class_ptr(&mut __map);
352 _serde::__private::Ok(hkpConstraintInstanceSmallArraySerializeOverrideType {
353 __ptr,
354 m_size,
355 m_capacityAndFlags,
356 ..Default::default()
357 })
358 }
359 }
360 const FIELDS: &[&str] = &["data", "size", "capacityAndFlags"];
361 _serde::Deserializer::deserialize_struct(
362 deserializer,
363 "hkpConstraintInstanceSmallArraySerializeOverrideType",
364 FIELDS,
365 __hkpConstraintInstanceSmallArraySerializeOverrideTypeVisitor {
366 marker: _serde::__private::PhantomData::<
367 hkpConstraintInstanceSmallArraySerializeOverrideType,
368 >,
369 lifetime: _serde::__private::PhantomData,
370 },
371 )
372 }
373 }
374};